Updates to software

Embed from Getty Images

It’s obviously a good thing for bugs to be fixed. Software should function correctly and without exposing the user to security issues, and updates to fixes for this reason are essential.

Unfortunately this sometimes, one might say often, has a negative impact on the user. The user may know of the bug and have a workaround for it, and fixing the bug may cause the cause issues with the workaround.

Embed from Getty Images

Not to mention the fact that fixing one bug may result in the appearance of another or bring its existence to the notice of the user. No software can ever be considered to be completely bug free, in spite of the advanced tools which are available to test software.

When I was learning to program, back in the time of the dinosaurs, we were told to give our program and the specs to one of our fellow students to test. We called it “Idiot Testing”. The results were mind blowing. A tester would make assumptions, put in data that they consider valid, but which you, as the program writer had not considered, or maybe you considered it “obvious” that putting in certain types or values of data would not work.

Embed from Getty Images

Almost every time the tester would break the program somehow, which was the whole point, really. So we’d fix up our programs and give them up to be tested again. And the testers would break them again.

We were taught and quickly learned the advantage of sanitising the inputs to our programs. This meant we had to take the data as input by the tester and incorporate in our programs routines to try to ensure that the data didn’t break the program.

Embed from Getty Images

So we’d write our routines to validate the data, and we’d return an error message to the tester. We’d think that we were providing clear reasons in the messages to the tester, but the messages could still confuse the testers.

For example if the message said “The input must be between -1 and 1”, the tester might try putting in “A” or “1/4”. This usually happened when the purpose of the program was not clearly defined and described, not because of any denseness or sheer caprice on the part of the tester.

Then we’d update the programs again, taking into account what we had learned from the tester’s responses, and hopefully there would be more success with the updated program.

Embed from Getty Images

This seems to be more of an issue in mobile software, I believe, as many programs out there are written by a single person working alone, and I know that by the time I finish a program I’m heartily sick of it, and I write programs for myself as intended user. A person may upload a mobile app, with plenty of obvious bugs, and may never update it. It becomes abandonware, which may lead a general disillusion with mobile software as being buggy and never fixed.

When a developer does start to work on his program, and starts to fix the bugs, this takes time and effort. Meanwhile users may keep reporting issues with the published version. The developer has a dilemma. Does he/she drop his work on a particular bug to identify and fix the possible new bug? Or does he/she finish working on the current bug and eventually release a new version which would still contain the old bug?

Embed from Getty Images

Once the programmer starts on a new release, adding new features and improvements over the original version, bug notification and fixing acquires a new layer of complexity, one which a single developer may find impossible to handle, so he or she might abandon the software rather than take on the complexities of bug management.

Other times teams form or businesses take up the software, and bug management and fixing become formalised, but updates still need to be supplied to the users. From the user perspective, updates are more regular and fixes may be supplied in the updates if they are lucky.

Embed from Getty Images

Updates have had a bad reputation in the past. In the early days of computing operating systems (such as Windows) could become unbootable after an upgrade if the user was unlucky. This generally could be tracked down to issues in the driver software that controlled the various attached or builtin devices on the computer.

Things are now a lot better. Drivers are written to be more robust with respect to operating systems upgrades, and operating systems have become better at handling issues with hardware drivers. It is rare these days for an upgrade to render a system completely unbootable, though an upgrade can still cause issues occasionally.

Embed from Getty Images

Users have become used to preforming upgrades to systems and software, and in some cases they, by default, do not have a choice whether or not to upgrade. They do not, in most cases, know exactly what upgrades have gone on to their computers and do not known what fixes are included in these upgrades.

Software updates are often seen by users as a necessary evil. There are reasons for updates though as they may well close security loopholes in software, or they may enhance the functionality of software. Just don’t expect an early fix for that annoying bug though, as the developers will almost certainly have different priorities to you. If it isn’t in this update, maybe it wasn’t serious enough to make it. Hopefully it will be in the next update, which will be along soon!

Embed from Getty Images

Upgrading

English: Upgrading Menu
English: Upgrading Menu (Photo credit: Wikipedia)

I’m a little late with this post because of an issue with my computer. An upgrade resulted in me not being able to send and receive emails. While this is partially fixed I still have work to do.

I’ve been in the business for decades so I’m acutely aware of how things can go wrong in an upgrade. Sensible systems administrators take backups, plan out the upgrade in as much detail as they can and probably spend more time getting ready than in actually performing the upgrade.


Embed from Getty Images

This pays huge dividends, but still, not infrequently, things can go wrong. The wrongness can be major, with a totally destroyed system, or minor, as in niggling irritations like something behaving slightly differently after the upgrade.

Computer firms and software suppliers often make huge efforts to make an upgrade work easily and cleanly, and many have put in place systems to make it easier to upgrade their software or back it out if something goes awry.

Microsoft Windows wordmark
Microsoft Windows wordmark (Photo credit: Wikipedia)

There are various levels of upgrade – a small part of a program may need to be upgraded, or the whole program may need to be upgraded, or indeed the whole operating system, Windows or what have you, may need to be upgraded.

In the early days of computer systems upgrading would mean downloading some source code or source code changes called “patches”, making changes to the existing source code, compiling it and then installing it into a particular location on the computer.

English: C++ source code for an (unfinished) p...
English: C++ source code for an (unfinished) program, shown in the geany editor, screen shot Svenska: Källkod (c++) för ett ofärdigt program visad i geany (textredigerare), skärmbild (Photo credit: Wikipedia)

The technical terms don’t matter too much. I just want to convey how complex and manual the process was. That is fertile ground for errors to creep in. You download a bunch of code, trusting that it will work and fix some problems, some of which you may not even be aware of, and then transfer them to the existing source code.

You may mistype something, or mistakenly overwrite something in the existing source, feed the new code into the compiler, and out pops a new program, which you then transfer into the correct location and cross your fingers and test.

English: Works Records System - schematic
English: Works Records System – schematic (Photo credit: Wikipedia)

Incidentally a compiler is also a program and as such it has bugs which need to be fixed. What if you update or patch the compiler and it breaks? You can’t remove patch and re-compile as you just broke the compiler!

The solution is to reinstall the original compiler that came from the supplier, and potentially patch that to the point before you broke it. Or, if you a sensible system administrator, you restore the original compiler from the backup that you took before the upgrade. Either solution is tedious and frustrating.

Administrator interface in WordPress blog system
Administrator interface in WordPress blog system (Photo credit: Wikipedia)

Operating systems are the biggest upgrades that can be done. They are also the most dangerous because they are big and complex, which multiplies the chances of hitting problems or ending up with a system that doesn’t work.

Operating systems upgrades used to come as a magnetic tape or two, and a small book or manual of instructions. IBM for instance used to supply several books of instructions, hints, cross references, dependency lists and so on for each major upgrade. The necessary books for looking after IBM mainframes amounted to a library and that was what it was called.

Reel of 1/2" tape showing beginning-of-ta...
Reel of 1/2″ tape showing beginning-of-tape reflective marker. (Photo credit: Wikipedia)

IBM and others quickly realised that something needed to be done to help the system administrators to install, maintain and operate their big computer systems. Otherwise people would end up with unusable systems, and IBM would have to spend time and money helping them fix them up.

So the concept of a package was conceived and from very early in computing history, everything was supplied to the customer as a package from the actual operating system down to the programs that ran the printers.

English: The Siemens SIMATIC S7 SATEP 7 V5.4 S...
English: The Siemens SIMATIC S7 SATEP 7 V5.4 Software Package. Deutsch: Das Siemens SIMATIC S7 SATEP 7 V5.4 Software Paket. (Photo credit: Wikipedia)

A package was a cluster of programs that provided some feature or facility on the computer. Packages requisites and dependencies on other program – it would be no use installing a package that needs stuff printed, like an accounting package, if there was no printing package already installed.

Computer manufacturers also moved away from providing source code to customers. They supplied, for example, a printer driver or a compiler in binary, ready to run, form, so that the program binary could be simply dropped in place and it would run right away.


Embed from Getty Images

I’m simplifying a little, as there were other program chunks that, while they weren’t compilable source code, could not be run as supplied and which had to be intimately connected to other program chunks to produce a runnable program.

Nowadays the average user, professional or home, of the Windows operating system has never seen source code. All updates through Windows Update, and programs like browsers, games, utilities and other programs, are binary distributions, binary packages that the operating system installs for you. The Windows operating system doesn’t even provide a compiler.

A Nuon DVD player with a video game controller
A Nuon DVD player with a video game controller (Photo credit: Wikipedia)

This whole distribution system for programs and updates requires very rigid interfaces between the bits of the operating system itself and other programs which are not part of the operating system, and this is, when you know what is going on in the background, truly amazing.

Indeed, a Brazilian Windows systems operator can confidently install a program on his computer, which communicates with him in Portuguese, and so can a Windows systems operator in Finland or even Japan. All can expect that the program will work almost perfectly on all these diverse systems.

中文:
中文: (Photo credit: Wikipedia)

It’s slightly more blurry in the Unix/Linux world. There the operator or maintainer is given an option – use packages similar to those used with Windows or use source code. Many Unix/Linux users these days will never have knowingly compiled source code packages, though sometimes the package maintenance system may compile code for them. However this is rare.

Some Unix/Linux users however like to compile some things for themselves, so that they can get the very latest versions of things, and some even compile their whole systems from the ground up though this is rare.

Diagram of Monolithic kernels
Diagram of Monolithic kernels (Photo credit: Wikipedia)

So when you complain about your Windows system installing updates when you shut it down, reflect that things could be worse – you could have needed to compile them yourself.


Embed from Getty Images