The Boring Now leads to the Exciting Future
written by Peter William Lount
version 1, 20050223 6:30pm PDT

In the OSNews editorial The Boring State of Operating Systems Today Eugenia Loli-Queru writes about the sorry boring state of Operating Systems today. This issue goes much deeper than simply the OS, it's pretty much all software systems that suffer, especially applications and operating systems build using static software technologies.

In reply I posted the following:

I must agree with Eugenia that the current state of the art of OSes looks bleak.

As someone working with state of the art technologies for applications and operating systems it's very important that the operating systems evolve more rapidly then they have. Why? To support the latest advances for the end users pretty much all applications need to be rethought and rethought deeply to their roots in the underlying systems. Many new features and capabilities are simply not possible to build upon existing OSes.

For example, the limitations of the number of protected processes is usually way under 10,000. With new advanced object based systems the number of active threads will be in the millions if not billions (for some corporate collectives). With clusters of cheap PC hardware running it's important for parallelization and security that programs be broken into small fragments each contained within it's own protected process space. This enables safe widespread grid computing with automatic process migration between computing nodes in a users trusted grid. This is a necessity to take advantage of N-CPU motherboards and awesome systems such as Cell computing (9 CPUs per chip), 64 bit computing (AMD-64 & Itanium, yes Itanium) and specialized multi-processors, but mostly to take advantage of massive numbers of cheap networked and clustered PCs.

It has been said that C is a language that was built for making Unix. C isn't the language for the next breakthrough operating system primarily due to C's lack of expressive power and it's static nature. Unix (and most other software systems) are contained within a protective shell due to their statically compiled nature. Having the source code isn't the whole answer either as 99.99% of users have no idea what to do with the source. They can't easily tinker with it as they must learn a complex set of tools and they are subject to the hell of edit, compile, link, run, debug, test cycles. It simply isn't reasonable for the majority of computer users to use today's software development tools.

Anyone can take a path that leads them to produce systems as static, complex and bloated as Microsoft Office, Windows XP or, yes, Unix. A serious problem with these systems is that there is no way to access the full power embodied in the program. It's as if all the money spend by Microsoft on Office (and that's likely more money than most, as in 90% of, companies will ever earn in their respective corporate lifetimes) is locked up behind a static shield to protect it from the users. Almost like a museum artifact that must be protected at all costs. Unfortunately for the users of static applications and operating systems this isn't a metaphor it's reality, the functionally is really locked away behind, usually, clunky user interfaces that almost seem to coddle the user. This forcibly shapes the user to fit through tiny uncomfortable holes in the dark to follow impenetrable and often inexplicably torturous paths to get some trivial task done. Who wants to take Frodo's journey into Mordor everyday just to get something done?

There is a better way. A few of the state of the art technologies required are:

Dynamic systems that reveal what is going on at all levels in real time. Dynamic systems that provide tools that enable users access to the full power of all the components in the system and applications. Dynamic systems that the users can evolve. Dynamic systems that eliminate the horrors of the edit, compile, link, run cycle by providing interactive tools. Dynamic systems that are capable of rewriting themselves based upon new specifications. Systems that make use of and leverage technologies that simplify while providing expressive power. Cellular automata in combination with declarative systems that assist the users in getting their job done. Dynamic systems built using Virtual Machine-less mobius languages (languages that are written in themselves) and Kernel-less (or nano-object kernel) systems that maximize features and capabilities while optimizing system resource utilization. Systems where simply using the computer is a form of “programming”. Shared collaborative environments where groups of people can accomplish what one alone can't and to be able to do so in real time. Generative programming systems where entire applications and systems are built from the ground up from specifications and user actions. Three dimensional environments that are visual languages (and which have a potential to replace the current one dimensional stream based ascii language forms). Fault tolerant systems that provide robust systems that can handle machine and human errors gracefully.

There are other exciting technologies being developed the combination of will produce the next revolution in operating systems and applications design. The key is to find and exploit them in a cohesive whole, and if you can't find the technologies, invent them! Make them up and get them working!

The path to the future isn't clear unless we make it so. See the future. As Alan Kay said “The best way to predict the future it to invent it”. That's the first step of the hard part. The rest is building real systems that work and finding solutions that make the users life easier and more productive – whatever they happen to be.

There are many challenges. I've been working on a new operating system and a language to support it's development and expression for quite sometime (research since 1987 and implementation for the last few years). It's a major challenge for technical and economic reasons, many of which present massive barriers to entry, which is one of the main reasons there are only three or so main operating systems in the marketplace. The driver issue is one of many problems that need practical solutions for an ever increasing choice of devices.

Last year saw the definition of the dynamic language, Zoku a derivative of Smalltalk and Fault Tolerant Object database systems, that is being used to build the Zoku Collaborative Operating System (ZokuCOS). There is much work to be done implementing the system, years of work. Why do it? If I don't then I'll never see the system I want, as I don't trust the big boys to get it right. Maybe I won't either but it's worth a shot.

To learn more about an exciting new collaborative visual interface technology that you can run now checkout: OpenCroquet.org

To learn more about the Zoku language and system visit Zoku.com and read the relevant articles at Smalltalk.org.

---

Copyright 2006 by Smalltalk.org™, All Rights Reserved.