If you’re alive and breathing in the 21st century, you’ve probably had a miserable experience with software at some point in your career. Your frustrations were most likely compounded if you’re using niche software, such as a business to business (B2B) application, or, dare I say, legal case management software.
Software applications have come along way, that’s for sure. Microsoft Windows crashes less since the days of ’95 as a general rule. Apple paved the way for amazing user interfaces and product experience, and Google raised the bar in web applications with ground-breaking tools like Google Maps.
However, these beautiful, mainstream applications only highlight the limited nature and ugly look-and-feel of much B2B software. In all fairness, some applications go the extra mile and truly rise above the rest. But as a software engineer, I’d like to share a little inside information on why so many software products are poor.
User Interaction is an Afterthought
Why are some software products simple and enjoyable to use, but others dull, painful, or confusing? Most likely, the problematic software does not incorporate a discipline known as interaction design as one of the key components of the product development process.
Much B2B software, including some offerings in the legal industry, originates with an enterprising practitioner in his or her field. The individual dreams up an idea to streamline his or her business and teams up with a programmer to build out the product. Once the functionality is nailed down, they slap on some window dressing to doll up the software and ship it into the market.
Elegant software, by contrast, is built the other way around. It starts with a consideration of the humans using it. Design comes first, defined not just by pretty icons, color, and typography. Rather, larger issues, such as the organization of information and screen work-flows are optimized for human consumption and efficiency. Once these issues are tackled, design teams work with engineering to determine what can and cannot be accomplished.
Feature Bloat Disfigures Software
Imagine you’re offering a brand-new software product and you need traction in the marketplace. Or imagine you have a mature product with competition. In both cases, you’ll encounter potential buyers who demand certain functionality before spending a dime.
What do most B2B software companies do? They believe they’re meeting the needs of the marketplace by providing the features their customers request. This strategy is needed to a degree: there is common functionality shared between most users. For instance, in legal practice management, not storing client telephone numbers would be a grave oversight.
However, when a software company packs in every feature requested of it without offering resistance, over its lifetime the product grows to a point of obfuscating what most people truly need to accomplish. Consider the number of menu items Microsoft Word contains versus the number of those items people typically need: users can tackle almost any task imaginable, but it takes a lot of hunting and searching to find the small subset of features they require most often.
Often times, a user feature request is rooted in a deeper problem they’re trying to solve which the software company fails to recognize. Steve Jobs of Apple likes to quote Henry Ford as saying,
“If I’d asked people what they wanted, they would have asked for faster horses.”
The best software companies figure out the underlying problems people have and come up with a terrific solution no one ever dreamt of.
Shipping Bytes Is Inherently Complex
Many promising and creative software ideas never see the light of day. Some estimates maintain that 44% of all software projects fail. As everyone knows from personal experience, even software from leading players in the industry often ship with bugs and issues. With all of the bright people working as engineers and programmers, how could this be?
The reason for quality issues is due to the incredibly complex nature of making software. The logic and algorithms for features are frequently very complicated. Integration between systems is tricky, and even a slight change in code might have an unintended consequence in an unrelated part of the program. The number of possible outcomes and bug opportunities in a program multiply wildly as additional data fields, conditions, and features are added.
Ideas can be so complicated that even discussing them can present a challenge: because of communication overhead, adding people to a development team can slow progress, not accelerate it. One of the seminal books in computer science literature published in 1975, The Mythical Man-Month, explored the concept that “adding manpower to a late software project makes it late.”
Moreover, just as there are bad lawyers out there who muck things up, the same exists in the software industry. Bad programmers take tolls on their teams by introducing bugs or requiring assistance from better programmers and slow down development considerably.
The Good News
From the software side, we’re in the fourth decade of the personal computer and are able to stand on the shoulders of the giants that came before us. Code libraries, software development methodologies, and design patterns are all time-tested and vetted, leading to higher levels of quality and a richer user experience.
Perhaps the best news is on the consumer side. Users have seen the light. They’ve seen what Apple can do on an iPhone and how Google and Facebook have improved the web experience. Their desire for a high level of user experience in their products will drive the marketplace, pushing the dinosaurs towards extinction and favoring new, more adaptable life.