There is a big battle running on the Free/Open Source field: the Virtual Machine war. What will be the next generation of development environment? Java or .NET (Mono - DotGNU). Both environments use a VM as the core and I don’t understand why it’s so important.

Sure, worldwide developers have finally agreed that, to create modern applications, they need more high-level and dynamic environements with services such as automatic memory management or interactivity. But again, you don’t need any virtual machine to achieve that.

Classic virtual machines (JVM or CLR) are a bad abstraction of a real processor. They don’t behave like a processor and have a limited instruction set, generally driven by the language to implement (Java or C#). That’s not the case of a real processor that doesn’t have any clue from which language compiler came it’s assembly. A real processor is a complete toolbox. It supports different and clever mechanisms for the language implementor. That’s a big difference.

Because of these lack of flexibility, some classes of language don’t have any chance to be efficiently implemented on these virtual machines. Common Lisp for example, is not a statement-based but expression-based language and has a lot of uncommon (understand modern) features: closure, first class functions, multiple-dispatch, CLOS, and more. But most VM vendors just thought, “I have to make a processor designed to implement a particuliar vision of the object-oriented paradigm”. Unfortunately, Java and C# implement a limited part of object-orientation. Chances are that in a near future, new programming paradigms will appear and experimental implementations on these virtual machines will be a pain.

If we have to use these virtual machines to implement future applications and therefore compilers, it will be an unacceptable limitation. Using an intermediate language (CIL) is like translating French to English by passing by Russian and Japanese first. You’ll lose precision and compilation performance. Common Lisp proved it’s possible to implement an interactive, multi-paragdim, programmable and dynamic environment compiling to native code without the help of a virtual machine. The code is highly portable and modern implementation run on more than 14 architectures. So what are we looking for?

One may say: “come on! how about portable executables? that’s is a big win!”. Actually, who cares about that? Developers? Maybe but definitely not end users. Users are very unlikely to use the same application on a different platform. They just want the application to use the most of their system, and it have to be designed this way. User interfaces (UI) are one of the problem. Even if your application can be executed everywhere (Java/Swing), the design of your UI won’t be “portable” in the sense that it won’t follow the UI guidelines of the running system and it won’t take any advantage of the system.

As a Mac user, I won’t use a Windows-designed application because it won’t fit the Apple guidelines and their digital hub concept (where application interacts together). To properly fit the requirements of the host system, you’ll have to “port” the application to each system. As developers, we already know how to design portable code and portable binaries are definitely not the Holy Grail. Look at Java, application “written once, ran everywhere” failed on the desktop.

These new environments are hyped and won’t solve computing problems. Much better tools already exists and deserve to be highlighted. If you seriously think about switching to a more productive and dynamic programming environment, give a try to Common Lisp.