Why should you care about software installation?
Software installation is usually the first interaction developers have with their new user. The download is a brief period full of opportunity and potential pitfalls. If the installation fails, it is likely that your user, short of attention-span and patience, will also fly away.
This process of software installation has come a long way since compact discs and manual registration. Let’s take a look at how modern software installation became a ‘given’ and how it is positioned to continue improving.
To learn about the history of software installers, naturally we have to cover a little bit of the history of software development.
The start of software activation
Let’s say you’re a developer writing a software that you want to distribute and share with other people.
In the early days of desktop computing, software was not as complex as it is today. For example, one of the first widespread pieces of software was Calculator. Normally it’s an open source, but it’s software all the same–it contains an executable file that you need to launch in order to use it. Calculator is usually comprised of a single file that contains the code that operates the handful of mathematical functions.
As the years went by, people began developing much more complicated software that could handle more data, more details, and so on. At some point placing all the code into a single file became impractical and cumbersome for developers. After all, a single long code is difficult to edit, debug, and improve.
So next developers started writing in ‘modules’ or multiple files containing code. For example, a single module might be able to show images on the screen, while a different module is able to retrieve images from a web server.
And the complexity increased, but so did efficiency
Next, instead of putting a lot of functions in the same code, developers began writing code to perform specific functions. These functions responded to instructions from the main .exe file.
Programs evolved into 1000s of files each. Common code was placed into “libraries” and shared and re-used by many developers. A typical program could contain tens of libraries, each developed and maintained by a different programmer.
Windows operating systems made big strides in the path to modern software installation. But their first iterations on software activation and installation were far from perfect.
Before Windows, in order to run a program you inserted a disk into your harddrive to prepare the operating system, and then after you put in another disk that contained the software you actually wanted to run. This form of software ‘installation’ seems primitive indeed when you consider that most new hardware doesn’t even carry CD drives anymore.
But Microsoft said, if you are a more complicated program and you want to communicate with the OS, you need to ask various permissions (ex. user has to be admin to run the program, testing the network, checking if the software is printable), for a software to do certain activities.
This adjustment was an improvement in many respects, especially security, but it also created more roadblocks to usability.
You could say that the early versions of Windows did not want to be surprised; Windows needed to already be familiar with anything that you planned to run on your computer. They implemented a registration process to make sure the user had a legitimate copy of the software, and to ensure that they were allowed to use it.
You still have to register software within the operating system with basic identification information, but now this process is considerably less involved thanks to the installer.
So, like we said before, modern software is composed of many modules (files) under a folder. To organize all these files, Windows designated a folder within the operating system named ‘program files’. Once a program gains access to ‘program files’, the system knows to treat it like a software in terms of maintenance, the amount of memory the system requires to run these files, etc.
As we’ll see later, today’s installers know can automatically designate a space in the program files and place their own folder, all without overriding or erasing information from separate software.
Registration requires entrance into the registry of the operating system. As soon as you put software on a computer for the first time, it will write in it’s own ‘registry keys’. These keys are the roots of the software within the computer. This sounds scary, but these keys are really just light-weight notes about the software; what version it is, where it’s located in the computer, etc.
These keys are so deep within the computer that sometimes when you uninstall a piece of software, the registry keys of the program remain.
This Windows system comes in handy when, after uninstalling a program, you decide to install it again. Software developers often make use of this feature when keys contain values that notify the software that the user purchased the software. If they uninstall, and then install again, they can do so without repurchasing because the software provider is assured that it’s a legitimate copy.
Manual registration–not user friendly
So fast forward to when you, the developer, had a completed piece of software. The files, the folders, the keys, etc. were all in place. But for a user to install your product, the operating system had a seriously convoluted process for completing all the permissions and system requirements.
Windows said; first you have to copy the folder and place it in your program files. Next you have to go to your registry keys, find the following five files, type several parameters, enter the following values, decrypt the following values…and on and on.
A sieve for new users
These were all the steps required to activate a software. But of course, even if the software is great, not all the users were technologically adept enough to go through these steps to activate it.
What’s worse is that some of the values that need to get written into the registry keys are secret or calculated values that developers either can’t or don’t want to explain out of concern for their own brand safety.
So herein lies the pain point from which modern software installation arises. There was a clear need for a program that could automate placing software correctly within a user’s computer in a safe and user-friendly way. There was a need for a system that allowed the user to get started immediately after agreeing to make the download.
Placing the files in the right place, registering the software in the right location, permitting the software to certain areas of the computer…this all falls under the description of installation.
Simplifying the Process
First, someone wrote a script that simply went through one by one, and attempted to automate each phase of the installation.
This initial attempt at installation seemed great at first, but the programmers quickly discovered that as soon as you try to run the installation on another operating system, or a different version, it failed miserably. The installer got tripped up when it encountered unexpected discrepancies between computers or changes made by the user.
These early installation programs did not work for the vast majority of computers in the world.
But slowly but surely, the installers improved. They became more logical and adaptable to variance in different kinds of computers and operating systems.
As time went by, more and more companies tried to build installers for their proprietary software.
As you might expect, developers tried to streamline the process of building installers. Instead of creating unique installers for each program, they built platforms that would be compatible with different types of software. With only some minor adjustments, the installer would work with any software regardless of the size of the software or the type of functions it could run.
The installers were composed of a set of functions that users and companies could use for their specific needs. To get a sense of what these installers looked like, some common functions that could be customized were ‘welcome page’, ‘background color’, ‘background image’, etc.
This one-size-fit-all installer was called an ‘installation wizard’. These installers were so helpful that they are still in use today.
The Next Generation of Installers
Software installation from this point has made leaps and bounds in terms of usability and functionality. Over the last five years, technology companies focused on installation have shed light on a process that was once entirely opaque.
Remember when we talked about those first days of automatic installers? The industry leaders have been hard at work making every operating system and version compatible with every software installation. Now the industry gold standard for installation success rates sits at about 90%. Compare this to only five years ago when the best installers were only delivering approximately 65% of downloads successfully.
But the real evolution in this process is the ability to find out these success rates. The analytics that are now within every installation have completely changed the way developers think about their downloads. By delivering a piece of software with the most modern installers, developers now receive crystal-clear insight into how and where their software is being downloaded.
For example, developers are using installation platforms as a way to measure their app’s reception in different countries, languages, and user segments. They can also A/B test different installer ‘skins’ of the same product to see which communicates to users most effectively. You may be surprised to learn that seemingly ‘minute’ changes to an installer’s UXI can translate to huge shifts in installation success.
Clearly, software installation has come a long way. Installation has gone from barrier to boon for developers getting their software in the hands of their users. And with cross-platform installation on the radar, the engineering environment is ripe for more innovation.