Infosys | Microsoft

When using object instances in XAML, there are two ways to use them. One is to directly create them as resources, assign and key and use where ever required and other is to embed them inside of ObjectDataProvider and then use.

I have worked with both ways and was curious to know the differences between the two and benefit of using one approach over another. I can across this old blog by Beatriz that explain this very well. Along same lines, here is some discussion on XmlDataProvider as well.

Posted by Atul Gupta at 04:03 AM | Permalink | Comments (0) | TrackBacks (0)

These days IT companies all over the world, Microsoft included, are putting in a lot of efforts to ensure that their products conform to necessary Accessibility standards. This blog article aims to touch upon the context and the business case for IT companies to be educated about Accessibility.

The movement towards making IT products accessible has been primarily driven by the legal framework put in place by several countries to ensure equal access to governmental services.

As mentioned in my previous posting, historically, many societies and governments have implemented disability policies that focused on isolation and segregation of people with disabilities. This had to do with several factors including ignorance, neglect, superstition and fear. The disability policies and laws have considerably evolved over last few decades to focus on rehabilitation, education and ‘mainstreaming’ of people with disabilities particularly with regards to access to technologies.

One of the first few initiatives in this direction was The United Nations World Program of Action (adopted in December 1982). The action program sought the equalization of opportunities for persons with disabilities and mandated that access to information and communication be a human right.

Across the globe, there are now public policies and laws protecting the rights of people with disabilities to access the content of the Web. For IT companies this is a very important change because the onus of understanding the relevant laws, guidelines or standards that must be complied with is on the agency responsible for developing the Web content and Web site.

In general the framework of laws and guidelines can be organized around statutes and regulations, treaties and public policies, industry codes, technical recommendations, and good practice guides.

• A statute is an act of legislation, as opposed to law generated by case law or judicial opinion. For example, in US the specifications for accessible design have been mandated through legislation (Workforce Investment Act 1998 that strengthened the Section 508 of Rehabilitation Act).
• The corresponding regulations are rules issued by government agencies to carry out the intent of the statute.  Again, using US as example, the above mentioned legislation authorized the U.S. Access Board to enter into rule-making and the publication of the Electronic and Information Technology Accessibility Standards on Dec. 21, 2000. These standards became effective from June 21, 2001

Statues and related regulations inherently tend to be country specific. What if one is developing a website for an entity in a country that does have accessible design laws? And what does one do if your country has a public policy or has signed on to treaty requiring web accessibility but provides no guidance on implementation? For such cases, remaining sources of guidance, like industry codes, technical recommendations and good practice guides are useful.

• A treaty or public policy is only as good as its implementation requirements.  Currently a new international treaty is under development to protect the rights of people with disabilities. Accessible information and communication technologies (ICT) treaty is a core component of UN efforts and attempts are being made to add specific technical requirements for implementation. When the treaty is finalized, the countries that are affected will either need to enact legislation for conformance or harmonize their current laws to conform to treaty requirements.
• In areas where treaties do not exist, there is technical guidance that may be useful. One example is the Industry Code by Australian Banker’s Association (ABA) and its Industry Standards for Accessibility of Electronic Banking
• Even the technical standards developed by W3C sponsored WAI fall under technical recommendations category. Released in May 1999, it has been adopted by many countries.
   

U.S. Section 508 is based on the W3C WCAG 1.0 version.  Rather than adopt the WCAG standards directly, the U.S. has taken the approach of creating a separate legislation.  Majority of Web Section 508 rules are based on Priority Level 1 of the W3C WCAG but there are some rules that are additional to the WCAG guidelines.  Because of the Law enacted on August 7, 1998, U. S. Federal agencies and entities subject to Section 508 must make their electronic and information technology accessible to people with disabilities. Many states and local governments in US are also actively pursuing programs that involve adoption of Section 508 rules.

About 25 other countries have web design laws and policies. They include UK, Countries of European Union, Canada, Brazil, Australia, Hong Kong, Japan, Korea, Thailand and New Zealand among others.
 

Posted by Chandan Gokhale at 01:57 PM | Permalink | Comments (0) | TrackBacks (0)

Starting this week, I will be addressing the area of Web Accessibility - organized in four separate blog entries.  This week we will look at the big picture, the meaning of Web Accessibility and its relevance for promoting Equal Opportunity.  

In the weeks to come, we will look at follow-up topics like the legal framework that dictates the implementation of Web Accessibility (Overview), the interdependent systems  and components of Web Accessibility and harmful myths about Web Accessibility.

What is Web Accessibility?

According to Shawn Lawton Henry, a well know expert in this area, Web Accessibility simply means that people with disabilities can use the Web. More specifically, Web Accessibility means that people with disabilities can perceive, understand, navigate and interact with the Web.

Web Accessibility addresses the entire breadth of disabilities that affect access to the Web – visual, auditory, physical, speech, cognitive, and neurological disabilities. It is easy for a non-disabled person to browse the Web. Point your mouse, see the screen, use the navigation and then concentrate of the area of the web page that contains the relevant content. But what about people with disabilities?

Some people cannot use their arms or hands to type or move a mouse. Some people with tremors and diminishing fine motor controls can use a keyboard but not a mouse. Some people cannot see at all and use a screen reader that reads aloud information in the webpage. Some people have blurry vision and cannot read text unless it is very large.

Web Accessibility tries to address these barriers that restrict access to information on the Web. 
To help include everybody in the Web, World Wide Web Consortium (W3C), constituted a group called the Web Accessibility Initiative (WAI) whose mission was to develop the strategies, guidelines and resources to make the Web Accessible to people with disabilities. This group issued the Web Content Accessibility Guidelines (WCAG) version 1.0 in May 1999 to help make Web content ‘understandable and navigable’. These s guidelines are the ‘touchstone’ by which most lobbyists, legislatures and web developers determine the accessibility of a website.  The guidelines are organized around check points that fall under three levels of priorities; Level 1 includes checkpoints that must be met, Level 2 includes checkpoints that should be met and Level 3 includes checkpoints that may be met to ensure improved Web Accessibility.

A simplistic way of understanding the gist of these guidelines is
·         Ensuring that pictures used for communicating information have text equivalents
·         Audio is subtitled/transcribed for those who are hard-of-hearing
·         Links and form controls can be easily accessed by those with motor problems
·         Site is well structured for those with learning difficulties or problems with the language

The WCAG 2.0 version is currently in the working draft 11 stage.

It is important to understand one aspect that most experts agree on – an individual web site can never be perfectly accessible to everybody. This has to do with the sheer diversity of disabilities as well as the potential overlap of multiple disabilities. But a systematic approach like implementing the WCAG guidelines can go long way in accommodating a very large number of people.

Use of Web is spreading rapidly into most areas of society and daily life. In many countries, the Web is increasingly being used for government information and services, education and training, commerce, news, workplace interaction, civic participation, healthcare and more. In some cases, the Web is replacing traditional resources used to do all the things listed above. Therefore, it is essential that the Web be accessible in order to provide equal access and equal opportunity to people with disabilities

Encouraging (and sometimes mandating) accommodation of people with disabilities in the mainstream is a direct reflection of evolution of disability policy. Instead of prescribing a social welfare approach, under the medical model of institutional care, the new policies focus on rehabilitation and education.

Next time, we will look at the growing body of laws and public policies that are requiring the accessible design of products and websites, and how IT firms need to understand them to build websites that compliant with prescribed standards.

 

Posted by Chandan Gokhale at 05:19 AM | Permalink | Comments (2) | TrackBacks (0)

I have been playing around with WPF for a while and have been blogging about some of the technical aspects on it. However today I will like to touch upon another important aspect of WPF and that is designer-developer connect.

Having worked on Windows Programming using C++, MFC etc for a decade and working with the various controls, it is a real pleasure to see the capabilities now available to WPF developers. It is true to a large extent that with WPF and XAML and the tools like Expression Blend, designers and developers can work lot more closely than ever before. The working closely is more towards the ability for designers to style the UI for the WPF application and the developers to write the code for it.

The WPF controls are called as look-less controls and the designer can do just about any type of styling on them. WPF does provide for a great design support for the controls and the look and feel of any control is only limited by your imagination. It can be argued that designers can take Expression Blend and sit on a beach, let their imaginations run wild and create an out of the world UI (whether anyone in this world will use it or not is a different question) and then come back and give the developers the XAML which they can then include in their VS solution and stitch the application logic to it and be good to go.

However, if only real life was this easy! Many a times the styles/templates defined by the designer are applicable at runtime since they may be set to apply on specific triggers like say mouse hover or button or item click etc. In such cases, for the designers to be able to succcessfully build the style and test it, they will need actual data to be able to run the application. Designers can temporarily use dummy data like embedded XmlDataProvider, but that means that during actual code build, developers will need to replace it with the real live data.

Another similar issue is with the designer being live. Not the designer as in person, he/she needs to be alive anyway, but the designer surface in Expression Blend or VS. What I mean to say is that the controls and data providers in the XAML are instantiated during design time also. This means their constructors are invoked and hence requires that the code behind work properly, else designer (person) will be stuck with errors that they may have no clue on how to resolve. See some of the typical design time issues here and here. One of the common ways to handle XAML load issues is to use the DesignerProperties.GetIsInDesignMode API and based on the return value, avoid doing some processing that may require the application to be in running state (if return value is true).

However I would say that these are probably still small issues when compared to the ability of styling the WPF applications. The UX development has come a long way with WPF, since the earlier thick client applications  (and with Silverlight for the Web). The designers and developers, by working closely, can really work wonders.

Posted by Atul Gupta at 12:51 PM | Permalink | Comments (2) | TrackBacks (0)

WPF data binding a very effective way to bind .net CLR objects to WPF UI controls and ensure appropriate updates (by proper use of binding mode and property change notifications). However it can become a bit tricky if not used properly. I recently found these interesting 10 points about WPF data binding. I am sure you would find them helpful as well.

Posted by Atul Gupta at 08:23 AM | Permalink | Comments (0) | TrackBacks (0)

There are enough online sources that talk about how to buid and use custom Converters in WPF and also how to pass parameters to these converters. However for some reason, all these examples tend to either use a single integer or a single word string. So recently when I had a need for passing a sentence as parameter, I was confused.

Fortunately the simple trick of using single quotes inside of double quotes to provide strings worked in this case as well. Following are two ways you can pass a string that has multiple words to a converter.

Though VS color coding goes for a toss, the designer still loads fine and code also runs fine. If you use the more elaborate syntax for setting the binding, the regular double quotes will also work.

And the converter logic in this case is pretty trivial and is as below.

BTW, needless to say that you need to include the appropriate namespace for the DateTime.Now to work and that will be xmlns:sys="clr-namespace:System;assembly=mscorlib"

[Updated: April 25, 2008] There is another simple way to pass strings. First define a resource as below

And now use this resource for setting the value of ConverterParameter as below

Posted by Atul Gupta at 11:53 AM | Permalink | Comments (3) | TrackBacks (0)

"Let there be light!" And there was light.
 
"Let there be organized information!" So evolved ledgers and related recording systems, computers and applications.
 
Now in the age of digital nervous system, when we say "Let there be Automation!" , Information flow should address the whole spectrum of source, relation, content and target. Right from the days of hurricane lanterns till now, source of light has been an integral part of almost all the gadgets be it torches, mobile phones or big ones like street lighting systems or trains or even huge A320 airbus that fly about.
 
Just as a light source has become indispensable in all these gadgets and systems, the future years would see  miniature devices, microcontroller, sensors proliferating in alomost all space, be it domestic, automotive or retail…almost all that we could imagine!
 
Microcontrollers and sensors will become an integral part of almost all gadgets. To make them collaborate amongst them and other applications is the challenge!
 
 
Let us take an instance of a temperature sensor in a hard disc, which needs to monitor the temperature.In case of an abnormal situation,it needs to discover a target (device/application), and know if it can address the situation and send information to the target and invoke some service in the target, say capture the snap shot image of the media and store in a recovery mirror.
 
In order to achieve this i.e. to program the sensor, at least,
 
1. You need a base operating system to host your logic which discovers and invokes services.
2. You need to define communication mechanisms.
3. You need good enough space to place your binaries, operating system files and the kernel.
 
 
Now, how do you accommodate all the above in a temperature sensor processor which can at most have a few 100 KBs of memory?
 
.NET Framework with its miniature size and its ease of getting hosted and powerful programming model with high level programming language like C#, makes it possible. .NET Micro Framework does not need an operating system as it comes with a small bootable run time host for the CLR, It uses DPWS which is a  service oriented discovery and service invocation paradigm also it can take advantage of RF based communications as well.
 
.NET Framework - its big brother, other complementary technologies like Windows CE and XPe which are hard real-time embedded, Windows Embedded for Point of Service systems, enables devices built on .Net Micro Framework to easily integrate and communicate with enterprise scale applications and vice-versa with seamless mobility.
 
.NET Micro framework has a huge potential of bridging the gaps  between tiny devices and other devices, applications and thereby connecting islands of information and holding the key to future autonomous digital enterprise.
 
 
And looking into the effort part of it
 
1. What would be the effort in programming in a legacy programming paradigm for embedded systems?
 
2. What would be the effort to debug them? Etc.
 
With state of the art development environment from Microsoft, development
and debugging efforts are radically less as seen in “Leviton Manufacturing” case study in my previous posts.  
 
Visual Studio 2005 and higher versions provide best of the class IDE for programming the .Net Micro framework and debugging capabilities. Whether programming an emulator for the device or direct deployment to the device, it is all just clicks away.  

Posted by Venkatesh Rajagopalan Narayanan at 06:20 AM | Permalink | Comments (0) | TrackBacks (0)

In this part we will try to identify the differences these two models present that brings into fore the impedance-mismatch. I have created a data model and an object model and to keep the things simple for now, all of the objects map one to one with the data entities (tables). In addition, I will be using terms Table, Row, Column etc. rather than relation, tuple or attribute as these are easy to understand. Looking carefully at the two diagrams I am sure you can identify some of the most basic differences in the approaches the two methodologies take while defining entities.

 

 

Fig-1:Data Model

 

Fig-2:Object Model

Shadow Information - Identity Problem

The first difference you might have noticed is that while there is a identity column for each entity in the data model, we don't have an identity property in any of the objects. This is not considered to be a good practice to have key value in an object since each object can be distinctly identified by its location in memory. But in case of data stored in a table it becomes imperative to identify each row uniquely by using a primary key. This extra piece of information which is required to persist an object to a database is called shadow information.

Association

Another major difference is how the associative relationship is modeled in object and relational world. In the above diagrams, you can see that there is a many-to-many relationship between Users and Roles. Object model supports this kind of a relationship natively whereas there is no direct support for it in Relational model. That is why we have to introduce an associative table UserRole (Figure 1) to implement many-to-many relationship. Another subtle difference is in the way you access the child object. In the relational model, each row in child table holds information about its parent which means that parent does not have any idea about its children. For example, in Figure 1, LineItem table contains a reference to Order in the form of OrderID. Contrary to it, object model models it differently in the form of aggregation and composition. In Figure 2, you can see that Order object conatins a collection of LineItem objects.

Partial Data Load

While retrieving data from a database, it is a common practice to retrieve only those column values that are necessary for a business process in order to optimize network bandwidth. No matter how fast the network is, it is still costly enough to bring down the application performance if not used Judiciously. That means we need to optimize our SQL query and retrieve only that amount of data which is relevant to the current process. That is where problem arises. Once we retrieve data and populate our objects, most of the attributes of that object will remain empty as data corresponding to those attributes has not been retrieved. That is OK until we try to persist that object back to the database since there is a great probability that some of the empty attributes correspond to the columns that are declared NOT NULL. Secondly even if the columns are nullable, existing values will be overwritten by the empty values.

Apart from these major problems there are other issues as well like mapping inheritance, computed fields, foreign keys referencing only a single table etc. We will take a look into how to solve some of these problems in the next article of the series which hopefully I will try to publish soon. So keep watching this space for more..

Posted by Mohammed Farrukh Nizami at 10:30 AM | Permalink | Comments (1) | TrackBacks (0)

These days, Microsoft Evangelists are using a new buzzword – Differentiated User Experience’ -  to promote the capabilities of user interface technologies like WPF and Silverlight.  Needless to say, design community is scrambling to understand what this new term means and how they can build truly unique interfaces leveraging these technologies.

Before the dot.com boom, most of us that dealt with the design aspects of IT used to simply call ourselves as ‘user interface designers’. Some saw this term as too much of an overlap between the visual design and cognitive engineering aspects; and so started calling themselves ‘interaction designers’. Both these terms are still in common use and quite rightly so as they get the correct meaning across.

With the advent of Web and the internet build up boom that followed it, we started hearing more and more about User Experience Design.  From years spent in the field, I am of the opinion that it is a nice sounding word that tries to relate with the larger picture that designers care about, but is often misunderstood.  Experience means a lot of things to different people and even designers themselves struggle to have a unified view of what this means.

There are some who quite eloquently describe what User Experience Design, means while some like Uday Dandavate of SonicRim question the basic tenet that Designers can design the ‘experience’ for eventual users. During the IDSA Western District conference, Dandavate presented a talk entitled “The Scam Called Experience Design.” As reported by Stephanie Munson in Core77, Dandavate said: “We can’t hope to design experiences for people; rather, what we can (and should) do is co-create with the people for whom we are designing. In order to do so, we need to be empathizers, and in order to become empathizers we need to visit people’s homes and their imaginations. Designers should be looking for inspiration not in the slick design magazines (although we all love them), but in the real world and the world of imagination. Only by understanding deeply what experiences people dream of and aspire to can we then hope to innovate the tools they will use to get there.”
A new buzzword that is doing the rounds these days is ‘Differentiated’ User Experience. Brian Noye wrote a really good post about this some time back where he compares the buzz around this new term  with early days of ‘SOA’!
As the post continues, Brian tries to put some markers around what he thinks the term really means (or could mean).
So “differentiated UX” remains an ambiguous term at best. I think I know what it means when I hear it, because I have seen a number of examples that I think would qualify for that term, and have thought about what makes these applications different from the way they probably would have been written, appeared, and behaved had WPF not been available.
If you had to boil it down to a few key attributes, I would include the following:
·         Application styling and UI features create a unique and distinctive look and feel for the application
·         2D and 3D graphics are leveraged to provide better data visualization that traditional forms over data controls
·         Integrated data interaction across multiple different data views
·         User context hints provide richer context clues for the user about what they are doing or what they should do next (rich content tooltips, animated attention grabbers for focus shifts, etc.)
·         Location of user interface elements is less rigidly defined by the application shell, and may be completely in the control of the user. This may range from something as simple but important as dockable/floatable windows to a Microsoft Surface-like desktop metaphor where application ui widgets can be moved freeform around the screen by the user (Minority Report effect).
·         The UI framework (WPF/Silverlight) supports defining these features with a minimum of code
This is good beginning but in my view still too much focused on the ‘means’ and not the ‘ends’.  We are working on putting more focus on the ‘ends’ – what is it that designers should try to achieve as they try to build ‘differentiated’ user interfaces; and how can advanced UI technologies like WPF/Sliverlight help with this. In the coming weeks, I will post more stuff on our point of view on what ‘Differentiated’ user experience means to us.

Posted by Chandan Gokhale at 06:54 PM | Permalink | Comments (1) | TrackBacks (0)

With .NET Micro Framework gaining recognition, Analog Devices have announced porting .NET Micro Framework to their BLACKFIN processors.

Developers of resource-constrained portable devices offering multimedia and other specialty applications will for the first time be able to use Microsoft’s field-proven productivity tools, .NET and Visual Studio®, with the Blackfin processor, speeding the design of small-footprint, low-power embedded systems.

Analog Devices’ Blackfin processors combine high performance, power efficiency and system integration to enable highly optimized embedded designs without compromise. With power consumption as low as 0.16 mW/MHz (at 250 MHz) and performance up to 600 MHz, applications can add greater signal-processing performance without sacrificing battery life.
Blackfin will be the first DSP in Microsoft’s .NET Micro Framework sphere, Developers will be able to work with Microsoft development tools to implement feature-rich products on Blackfin, with the power efficiency, performance level and system cost that is right for compact embedded applications. For example, one of the exciting possibilities is using Windows® SideShow™ to display information on mobile PCs and portable electronic devices such as media players, even when those devices are in sleep mode.

 

Blackfin® Processors embody a new breed of 16/32-bit embedded processor, ideally suited for products where a convergence of capabilities are necessary – multi-format audio, video, voice and image processing; multi-mode baseband and packet processing; control processing; and real-time security. The Blackfin's unique combination of software flexibility and scalability has gained it widespread adoption in convergent applications.

The .NET Micro Framework was created from the ground up as a .NET solution for small embedded devices from industrial sensors and instrumentation to home automation systems and healthcare monitors, The addition of Analog Devices’ Blackfin to the .NET Micro Framework fold will make high-performance, low-power digital signal processing (DSP) capabilities accessible to developers, using the world-class development tools of Visual Studio.

In addition to being fully integrated with Visual Studio, the .NET Micro Framework software development kit (SDK) comes equipped with an extensible emulator to simulate targeted hardware capabilities. The framework enables device developers to connect diverse hardware solutions to virtually any peripheral device through industry-standard communication connections and custom-managed drivers.

Analog Devices also plans to complement the Microsoft .NET Micro Framework SDK with additional development tools for Blackfin developers. The company will announce details as the tools become available.

Posted by Venkatesh Rajagopalan Narayanan at 10:22 AM | Permalink | Comments (1) | TrackBacks (0)

Overtime, I have used different approaches to binding pictures to Image control in a WPF application. I have seen various questions on the WPF forum as well on this topic. The information is all available out there, but scattered. Hence, I decided to create a sample application to demostrate the various scenarios that can exist when you need to use the Image control to display pictures.

You can download the demo code (Download file) and play around with it. If you unzip it in C:\, it should work without having to change any file paths etc. There are 7 scenarios that i have currently handled in code. If you can think of more, do pass them along and I will update the code to add them as well

1. Regular resource image binding to Source property in XAML
2. Binding resource image, but from code behind
3. Binding resource image in code behind by using Application.GetResourceStream
4. Loading image from file path via memory stream (same is applicable when loading blog image data from database)
5. Loading image from file path, but by using binding to a file path Property
6. Binding image data to a user control which internally has image control via dependency property
7. Same as point 5, but also ensuring that the file doesn't get's locked on hard-disk

Comments welcome !

Posted by Atul Gupta at 09:11 AM | Permalink | Comments (5) | TrackBacks (0)

ASP.NET AJAX is come a long way since its inception a few years back and my personal take it is that it in a hype cycle right now, where everyone is trying to jump on-board and create AJAX based applications. Needless to say that it has its own benefits, but there definite downsides to it as well. You can read a set of 10 important aspects around AJAX here.

It is known that though it gives a flicker free UX, the under-the-hood story tells a different tale. Having read about it, some days back, we did a small experiment to really see the kind of differences one can get with different approaches and you can read about our findings in this report (Download file). The scenario we took is very simplistic, but the results are still eye-opening.

Posted by Atul Gupta at 03:37 AM | Permalink | Comments (6) | TrackBacks (0)

This is a sad story. So please do not laugh.

Harri was born a developer. People say, the baby was born with a Silverlight spoon. When he was three weeks old, he wrote his first ‘Hello World’ application.

XYZ Inc. hired him instantly. In just another fifteen years, he would report to XYZ Inc., as the youngest developer to lead their trillion dollar initiatives. His overjoyed parents poured him with affection, taught him his first alphabets – A, B, C – A for Address, B for Binding, C for Contract;  and the next three alphabets – W, P, F. “Gimme code, gimme code”, he would mutter in his baby talk whenever he felt hungry. His parents fed him imported coffee from Java served in a Shell decorated with Ruby, and he had a massive appetite.

Fifteen years later...

He stepped into his office where he was recruited fifteen years ago, with drumrolls and trumpets. He was shown his high tech cabin where he paused to look around and took his seat. ‘Gimme code, gimme code’, he said in his deep throated adolescent voice. The big guy at XYZ Inc., introduced him to Mr. Finpert, who was their expert in all financial affairs. ‘Mr. Finpert will take you through all the requirements of our trillion dollar initiatives. You have eight months to create a software that will do magic and is customizable enough for any future miracles that may or may not happen. ‘Gimme code, gimme code’, Harri kept saying. Mr. Finpert was amazed at this prodigy and wasting no further time, quickly took the seat beside and started explaining.

“The software you’ll build will serve international banks and insurance companies to adapt to changes in their environments, as well as manage risk and ensure regulatory compliance. Here’s how...”. Thus spake the master.

The next few hours the prodigal developer was disillusioned by the wrath of his own genius. What he was hearing wasn’t part of any language his parents taught. While he wanted to hear what’s public and what’s private, what’s the service, what’s the controller, what’s input, what’s output, Mr. Finpert was bragging about some guy called Dow Jones and why we should worry about him. The shock was imminent and he suddenly started feeling strange in his head. As the prodigal developer, he knew what that meant – he was having a memory leak.

The lesser technical Finpert’s words sounded, the more his memory leaked. His eyes were reduced to a mere pixel, and he could barely see. He fell face first and crashed into a carton of hard disks.

Moral of the Story: You may be a born developer, but without Domain Specific Languages, software development only becomes harder.

Inference: (Er, on a more serious note) Just understanding the technical nitty-gritty can only go so far. When the perspective of “Domain” is absent, the resulting software would always be far from the ideal.

In the next post I’ll discuss more on the “Domain” perspective of software development.

Posted by Kishore Gopalan at 05:05 AM | Permalink | Comments (0) | TrackBacks (0)