The coming split in computing

Personal computers have been rarely personal. The IBM PC (the original Personal Computer) may have been designed for individuals but was used by corporations. Earlier computers (the Apple II or the Radio Shack TRS-80) were used by a few hardy hobbyists, and a few hardy businesses.

The two markets for PCs -- the home market and the corporate market -- have used the same hardware and software since the IBM PC.  Adoption rates increased dramatically with the introduction of Microsoft Windows, and there were some differences between Windows 95/98 and Windows NT, but both home and business used the same "stuff". Microsoft's dominance in the market helped create a set of uniform products. After 2000, everyone used Windows 2000 (later Windows XP) and Microsoft Office (Word, Excel, and Outlook).

The two markets are driven by difference forces, however, and those differences will drive a change in the markets. The uniform environment of one operating system and one set of software will split.

Consumers are driven primarily by cost. Not just in PC markets, but in all markets. (Consider air travel. Consumers have consistently selected smaller seats and less comforts because of the lower price.)

Large organizations (corporations and governments) are sensitive to cost, but they also avoid risk. Risk avoidance is often handled by minimize change. Large organizations often have governance processes that standardize hardware and software and keep changes to a minimum. Small updates (such as security patches) are deployed in well-specified "off hours" time periods. Large updates (like a new operating system) are delayed until necessary, and implemented in a well-coordinated upgrade project.

The long life of Windows XP can be explained by both of these behaviors, but the reasoning in the two markets is different. For consumers, upgrading from Windows XP to Windows Vista (or Windows 7, or Windows 8) was a cost, and a cost with no apparent benefit. Yes, some individuals upgraded, but the majority kept the operating system that came with their PC.

Large organizations stayed with Windows XP, but to avoid risk. Also seeing no immediate benefit from a new version of an operating system (and recognizing the risks of programs or device drivers failing) those organizations chose to stay with Windows XP.

This difference in behavior is recognized by vendors. Microsoft has introduced two "tracks" for updates: the consumer track and the business track. Consumers get updates immediately; large organizations can defer updates. Linux provides Red Hat and Ubuntu also make available two tracks: Red Hat with (free) Fedora for consumers and (paid for) RHEL for organizations, Ubuntu with "regular" versions and "long term support" versions.

Notably, Apple does not have two tracks. They revise their hardware and software annually, if not more frequently. They are focussed on the consumer, not the enterprise.

Also notably, Android has only one track -- for consumers.

With Apple and Android constantly revising hardware and software, the only player with a long-term mobile strategy may be Microsoft. We have insufficient experience with Microsoft hardware to decide.

Viewing the market as split between price-sensitive consumers and risk-averse large organizations, I expect that hardware and software will also split. Consumer software will remain free or low-priced, and move to the mobile/cloud environment -- and away from PCs. Enterprise software will stay on PCs (and servers) with little movement onto mobile devices.

Which is not to say that mobile devices won't been seen in large organizations. They will be, but they will be truly personal devices. Individuals will use them to check e-mail, confirm appointments, and surf the web during boring meetings. Enterprise work, however, will remain on PCs and on PC-like devices, including lightweight laptops such as Chromebooks and Cloudbooks.

Mobile operating systems break the illusion of control

The mobile operating systems iOS and Android are qualitatively different from previous operating systems like Windows, MacOS, and Linux. They break the illusion that an application has control; this illusion has been with us since the first operating systems. To understand the illusion, and how mobile operating systems are different, we must understand the origins of operating systems.

The dawn of computers saw the hardware emerge from electro-mechanical relays, but no software. The first computers were programmed with wires connecting components to other components. A computer was a custom-purpose device, designed and built to perform one calculation. Shortly after, the "programming wires" were isolated to removable boards, which allowed a "program" to be removed from the computer and stored for later use.

The first programs (in the sense we know them) were sequences of numerical values that could be loaded into a computers memory. They were a softer variant of the wired plug-board in the earlier computers. Building the sequence of numerical values was tedious; one had to understand not only the problem to be solved but also the processor instruction set. These sequences are now called "machine language".

Programmers, being what they are, developed programs to ease the chore of creating the sequences of machine language values. These programs were the first assemblers; they converted symbols into executable sequences. A programmer could work with the much easier to understand symbolic code and convert the symbols to a program when his changes were done.

Up to this point, the operation of the computer has been a simple one. Create a program, insert it into the computer, and let it run. The program instructed the computer, and the computer performed the calculations.

There were no operating systems. It was the computer and the program, alone together in the small universe of computing hardware. The program was in charge and the computer obeyed its instructions. (Blindly and literally, which meant that the programmer had to be precise and complete in his description of the operations. That aspect of programming remains with us today.)

The first operating systems were little more than loaders for programs. Programmers found that the task of loading an executable program was a chore, and programmers, being what they are, creating programs to ease that task. A loader could start with a collection of programs (usually stored in a deck of punch cards), load the first one, let it run, and then load and run the next program.

Of course, the loader was still in memory, and the loaded programs could not use that memory or overwrite the loader. If they did, the loader would be unable to continue. I imagine that the very earliest arrangement worked by an agreement: the loader would use a block of addresses and the loaded programs would use other memory but not the block dedicated to the loader. The running program was still "in charge" of the computer, but it had to honor the "loader agreement".

This notion of "being in charge" is important. It is a notion that has been maintained by operating systems -- up to mobile operating systems. More on that later.

Operating systems grew out of the concept of the loader. They became more powerful, allowing more sharing of the expensive computer. The assumed the following functions:

• Allocation and protection of memory (you can use only what you are assigned)
• Control of physical devices (you must request operations through the operating system)
• Allocation of CPU (time slices)

These are the typical functions we associate with operating systems.

Over the years, we have extended operating systems and continued to use them. Yet in all of that time, from IBM's System/360 to DEC's VMS to Microsoft's Windows, the understanding is that our program (our application), once loaded, is "in control" until it exits. This is an illusion, as our application can do very little on its own. It must request all resources from the operating system, including memory. It must request all actions through the operating system, including the operating on devices (display a window on a screen, send text to a printer, save a file to disk).

This illusion persists, I believe due to the education of programmers (and system operators, and computer designers). Not merely through formal training but also through informal channels. Our phrases indicate this: "Microsoft Word runs and prints a document" or "Visual Studio builds the executable" or "IIS serves the HTML document". Our conversations reinforce the belief that the running computer is in control.

And here is where the mobile operating systems come in. Android and iOS have very clear roles for application programs, and those roles are subservient to the operating system. A program does not run in the usual sense, making requests of the operating system. Instead, the app (and I will use the term "app" to indicate that the program is different from an application) is activated by the operating system when needed. That activation sees the operating system instruct the app to perform a task and then return control to the operating system.

Mobile operating systems turn the paradigm of the "program in control" inside-out. Instead of the program making requests of the operating system, the operating system makes requests of the program. The operating system is in control, not the program.

This view is very different from our traditional view, yet it is an accurate one. Apps are not in control. Applications are not in control -- and have not been for many years.

Goodbye, printing

The ability to print has been part of computing for ages. It's been with us since the mainframe era, when it was necessary for developers (to get the results of their compile jobs) and businesspeople (to get the reports needed to run the business).

But printing is not part of the mobile/cloud era. Oh, one can go through various contortions to print from a tablet, but practically no one does. (If any of my Gentle Readers does print from a tablet or smartphone, you can consider yourself a rare bird.)

Printing was really sharing.

Printing served three purposes: to share information (as a report or a memo), to archive data, or to get a bigger picture (larger than a display terminal).

Technology has given us better means of sharing information. With the web and mobile, we can send an e-mail, we can post to Facebook or Twitter, we can publish on a blog, we can make files available on web sites... We no longer need to print our text on paper and distribute it.

Archiving was sharing with someone (perhaps ourselves) in the future. It was a means of storing and retrieving data. This, too, can be handled with newer technologies.

Getting the big picture was important in the days of "glass TTY" terminals, those text-only displays of 24 lines with 80 characters each. Printouts were helpful because they offered more text at one view. But now displays are large and can display more than the old printouts. (At least one page of a printout, which is what we really looked at.)

The one aspect of printed documents which remains is that of legal contracts. We rely on signatures, something that is handled easily with paper and not so easily with computers. Until we change to electronic signatures, we will need paper.

But as a core feature of computer systems, printing has a short life. Say goodbye!