Style and substance

There are people who, when asked what car they would like to have, say "Red, with a sunroof and leather seats". A car is a powerful machine that exists to move people and/or things from one location to another, handle high speeds, protect its content from strong hits, and last a significant amount of time.   Leather seats are cool, but are not exactly high on my list of important characteristics of a car.

Leather seats are not unimportant.  They are one of the first things that a person notices about a car, and have a big impact on the driver's and passengers' experience.   However, car owner's experience is more than just driving and riding in that car: most car owners also have to survive an accident or a dozen while in the car, handle service and repairs for the car, and occasionally drive in adverse conditions where good handling becomes extremely important. 

If a car was a piece of software, the leather seats would be a feature.  Engine, handling and protection for the passengers provided by the strong body of the car would all be parts of the architecture.   Many people, when thinking about software, tend to consider its features, and nothing else.   When these people are product owners or project managers, the product features get a lot of thought and resources, while architecture evolves like a weed, with little care and hardly any testing.

Let me continue with the car analogy: an automobile can have the best-quality leather in the world on its seats and also be a complete lemon.  The wonderful seats won't make the car run, be safe or reliable. Same goes for software projects: great features do not guarantee usefulness, user satisfaction, or return on investment.  While features of an application make or break users' experience, the software, like a car, must also work, handle its load gracefully, and protect its owners and users from failures.   And that takes effort: time, resources, and careful thought about software architecture.

Ideas on software usability: power of a nudge

A nudge is a suggestion, a small incentive, but it can have big consequences on the outcome.

Placing certain products at or just above eye level in the shop is a nudge to consider these (presumably, most profitable) items first. Placing broccoli early in the lunch line-up leads people to get it more often, improving nutrition.  Automatic enrollment in 401k is a strong nudge to save for retirement, since the money will go in automatically.  Enrollment in a gym isn't much of a nudge, but signing up for a group exercise class or sessions with a trainer may work as a nudge and encourage attendance.

The nudge can come from a policy, from a physical environment, or from software.  Mozilla Thunderbird is smart enough to nudge the user to actually attach a file if it finds the word "attachment" in the text. Amazon.com and many other online retailers learned to nudge customers to write reviews, and to rate reviews left by others. Word processors nudge users to correct the spelling and sentence syntax by visually marking unknown letter sequences.

However, there is plenty of software that is less helpful than it could be if it was to nudge the user to follow better practices.

•  PowerPoint offers no nudges to produce good presentations - small font is as easy to reach as large, bullets go in indefinite layers with no suggestions to keep it simple. 
•  Modern IDEs have a lot of great capabilities to help write readable code, but don't yet automatically generate nudges to rename and refactor. 
•  Software like Infinitest nudges the developer to update unit tests regularly to keep them passing, but not to write new ones. 
•  Neither Wordpress nor Blogger.com nudge to limit the size of the blog post, suggest pagination, and do not remind to include pictures (but not too many pictures).

Behavioral research shows that nudges work. Yet, in order to work and improve performance, nudges need to be carefully designed and created. Software design industry is currently in the early stages of learning how.

A case for testing

Agile universe revolves around testing.  Developers are supposed to test, testers are supposed to test together with the developers.  Then the newly done work is supposed to be delivered to product owners and end users, who in turn get to try it, meaning, of course, to test it.

The result of this process is a high-quality product, where defects are known due to extensive testing, and features are exactly what the product owners and users have asked for and reviewed in their testing.    In fact, that’s the definition of a high-quality product – it does exactly what is expected of it, and its features are just what the doctor owner ordered, no more and no less.

However, there is a disconnect between the happy Agile universe, and the grim reality of software development industry. Testing is hard, expensive, decidedly not glamorous, and traditionally not valued very high.  For all the lip service that testing gets, there is relatively little research on the value of testing, how to do it right, how to measure the value, quality and quantity of the testing that does happen, and how much testing is enough. There is even less understanding of the importance of testing out in the field. 

Testing is a purely informational pursuit.  A test is something that’s done to learn how a product (a process, a person, etc.) behaves in a particular situation.  Modern software systems are very sensitive to lots of variables, i.e. “particular situation” is often extremely complicated to specify definitively.  Yet, this is what testing is all about – gathering information about what and how affects behavior of a system.

Regardless of how much work is done in testing, the reward and appreciation often goes not to the test and the people who performed it, but to the person or the team that changes (improves) the system behavior using the information gathered by testing. The idea that the improvement (or a bug fix) is wholly dependent on the information gathered in testing is not intuitive and usually gets lost in the shuffle.  A lot of information gathered by testing does not directly lead to a bug fix or improvement, and, thus, is not considered at all. 

It is hard to value the information, therefore, it is considered to be of low value.  It is easy to value the results of system improvements, therefore, they are valued highly.  As long as this mindset persists, the software industry will continue to under-test, and produce low-quality product that behaves unpredictably.

These thoughts are inspired by the recent news about Sony Playstation network compromised and subscribers' data possibly breached, private data of Texas employees handled unencrypted and left on publicly accessible website for months, Intuit's Quickbook service unavailable for many days earlier this spring.