Why software doesn’t “just work.”

Here are my two bytes on the matter: Computers are seemingly very simple; they take 1s and 0s, perform some mathematical functions, return the result and repeat. But computer software is very complicated these days. There are many different layers which software operates on (a kernel talks to the hardware, an operating system talks to a kernel, an application talks to the operating system, a user talks to the application), designed by many different people, used on many different pieces of hardware and communicate between each other over a network.
 
Apple like to say that their software “just works”, but every piece of software is prone to errors. Some errors are very visible (e.g. a computer crash, such as OS X kernel panics) and others are not (perhaps a piece of software seemingly works most of the time, but sometimes functions incorrectly, which both frustrates users and makes it very hard to diagnose). On top of that is the design of software, which you would typically regard Apple as a good designer because their products look clean, simple and intuitive, which they probably do more than most (sometimes too simple if you ask me), but sometimes it’s a design failure which causes a user’s problems, such as not being able to locate a function where the user would expect it to be. In that case a software engineer calls it a “user error“, because the software does exactly what it is supposed to do, but the user doesn’t understand how to use it. For some software the design should be so simple that anyone can use it intuitively, such as a calendar where it should be obvious how to flick through the months and insert a new entry, just like a real life calendar. For other software it’s just not possible to be simple, such as Logic Pro, where there are endless menus, endless options, and endless ways to combine things together, because you expect and need that kind of power and freedom with a professional piece of software. In real life you would have to fill a room with 1,000s of switches to simulate the various options the software provides to you, so it is merely a matter of learning how to use the software’s interface. Of course, if such a complex program has a bad interface, then you’re making it much harder than it needs to be to use an already-complex program.
 
Unlike cars, software isn’t something which average Joe can examine or fix, because the source code (the code used to build the software, kind of like a blueprint or schematic) is typically not available. Any person can open the bonnet of a car, find a broken spark plug and replace it using the right tool, but if you were to inspect a piece of software, it would just look like jibberish, no matter how much of an expert they are in software development. For this reason, if a piece of software doesn’t do what you want, typically you have to move on and find another piece of software. And if you cannot find a piece of software which does exactly what you want, then you’re out of luck unless you are capable of writing software yourself, or have the money to employ a team to make it for you. A lot of open-source software exists, where the source code for a piece of software is available to the public, meaning anyone can dive in and fix a problem or add new features. However, since the majority of computer users do not understand how a computer works, let alone have skills in software development, it’s not very beneficial to the public, except in that the software can typically be advanced and fixed much faster than closed-source software (with the added benefit of many people checking the code, meaning fewer errors are let through). In closed-source software, it may be the case that only a single person on Earth knows how some code works, and only a handful of people may have access to the code. Open-source software is also less invested in financially, since if you make a good product which people want, why not keep it to yourself and charge people money for it?
 
So, all software operates differently, unlike pens which all obey the laws of physics and have a standard design. All software operates in an unknown way, unlike pens which are simple enough that anyone can understand how they operate. Complex software will typically have problems which the developers didn’t notice, and the users certainly cannot do anything about. Interaction between software and physical hardware or networks like the Internet introduces even more opportunities for errors. Users who have no time to learn how to use software are error prone. Badly designed software wastes the user’s time and frustrates them.
Advertisements

~ by Daveoh on August 15, 2013.

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: