In the blog posts I wrote in 2006, I was primarily trying to bring some reality and common sense to the hype flying around many new ideas (it was a lost cause); discuss usability theory; and expose that mainstream programming is pretty mediocre. In 2007, my main themes were education, multithreading, and functional programming. This year, I will examine my prediction of a decline (not a demise but a decline) in traditional client/server desktop computing.

Here’s a roundup of some of my previous writings that feed into this progression of ideas:

News stories of interest

Two seemingly unrelated news items that we should pay attention to are: Bill Gates is retiring this year, and phone manufacturers finally settled on an across-the-board power/connectivity connector. To put it another way: The man who drove the systems that 95% of us use is leaving the scene; and our cell phones, PDAs, and other devices can now easily interconnect to each other (and our existing peripherals) with a $5 cord without the need for a PC.

History lessons

What does all of this have to do with programming? Everything. We are in the middle of intense change within the programming industry even though most of us can’t see or participate in it. We will just be stuck cleaning up the aftermath five – fifteen years down the road. The programming industry prides itself on rapid change and instant obsolescence, but the reality is that it’s changing very, very slowly. There are still a ton of important computing systems that are rooted in designs from the1950s and 1960s.

I have been learning a lot about the mainframe and supercomputer eras in an effort to try to mine that history for clues about our future. I believe that many of the standard features of mainframes are going to migrate to the current server hardware, typically in OSs adapted to take cluster configurations and treat them as a single addressable system. The result is that programmers are increasingly writing code that targets systems that behave like the Windows or *Nix servers of yesterday and today, but have the reliability and abstraction of multiple processors that mainframes have enjoyed for years. Look at the list of mainframe-like features that are sprouting up all over the place in microcomputer-oriented server rooms:

  • Virtualization of resources
  • Zero down time for hardware failure/replacement/upgrades
  • In-place OS and application upgrades
  • Bytecode interpreters and runtimes that abstract the hardware to the point that the programmers do not know or care what is underneath

Note: All of these trends are already well underway.

Ride this programming wave

We are seeing the server room getting better and better, the desktop platform stagnating, and the mobile device platform improving. How much longer will it be before “the suits” ask themselves, “Do employees really need expensive PCs and phones if I have been using my BlackBerry as my sole computing and telephony device for a year?” The answer all too often is, “No, they do not.”

As applications shift to the Web platform (or even just a server-based platform, so long as the client can be mostly lightweight), the only thing holding these cell phones, UMPCs, game consoles, and smartphones from entirely replacing the desktop PC as well as the desktop phone is the input situation and the output situation. Give these machines a USB port, and the problem is resolved with one connection to a docking station. I would love to replace my desktop PC with a UMPC with a docking station, but the prices need to come down some and my personal needs would have to be a bit less development oriented for that to be reasonable. But for an office worker with a $700 Dell and a $300 Avaya phone, it makes too much sense to the IT department to replace these with a $400 smartphone.

This will severely impact how we program and how we develop applications. I believe that the programmers who ride this wave will be the leaders of the next generation. Another odd knockoff effect of this change is that Linux will suddenly figure much more prominently in client-side development, and technologies such as Web browsers, Adobe AIR, Java, and Silverlight (a lot is still unknown with Silverlight) that allow a “write once, instant-client anywhere with zero configuration needed” will be reconsidered. The failure of Java applets in the 1990s to become a worthwhile technology (not fully cross-platform compatible, slow, resource hogs) is a shame in retrospect. We could have skipped the whole mess of trying to squeeze all of our work through HTTP/HTML/JavaScript like we are attempting now with AJAX. Developers who learn to write client code for mobile devices will be far ahead of the game down the road.