“The Singularity is the technological creation of smarter-than-human intelligence.” – The Singularity Institute

The likes of Vernor Vinge and Ray Kurzweil have long been espousing the coming of this event.  These discussions often focus around breakthroughs  in hardware and rapid advancements in artificial intelligence. I know Moore’s Law means the number of transistors that fit on a piece of silicon has boomed, but hey I’m a software guy and I’ve been thinking about advances in more traditional software technologies and will any of them aid in the rush to the Singularity?

The promise of object-oriented programming was going to allow developers to create reusable code. Write it once and use it in many applications.  Just assemble like Lego blocks. Yea, right. RPC vs. CORBA vs. RMI vs. WS-*.  Enough said.  Web services will allow us to create great applications by just wiring them together. Don’t worry about the details, just use the API exposed via the web services.   Though many web services are well thought-out and implemented these days, I contend the semantics of the majority of web services is hazy at best.   Hence, many web service based applications are really just doing CRUD operations to a database.  Now that’s progress. So instead of getting depressed about not aiding in the creation of  superhuman intelligence, I decided to investigate a relatively new technology on the sage advise given to me from a good friend of mine at Apple.

The Low Level Virtual Machine Compiler Infrastructure project (LLVM) is being developed by the Computer Science department at the University of Illinois at Urbana-Champaign as an open source project.  LLVM is a compiler framework designed to support transparent, lifelong program analysis and transformation for arbitrary programs, by providing high-level information to compiler transformations at compile-time, link-time, run-time, and in idle time between runs.  Let the last part of the above sentence sink in. This could change how we think about developing and deploying software.

So how does LLVM get this to work? There are five capabilities that the framework implements to make this possible.

1. Persistent Program Information. The compilation model preserves a complete representation through the entire life of the program. This allows optimization to performed at any stage, since information isn’t lost and the LLVM code representation is small enough not to bloat the run-time.
2. Offline code generation. LLVM also allows you to compile programs offline, using code generation techniques well suited for programs where performance is critical.  I don’t fully grok how they get this to work in conjunction with Persistent Program Information, but I fully understand why this capability is critical for anyone writing serious software.
3. User-based profiling and optimization. LLVM gathers profiling information when your program is executing and can use this to apply profile-guided transformations at run-time and idle-time.  Wow.
4. Transparent run-time model. No dependencies on existing run-times, object models, etc.  Any language (or combination of languages) can be compiled.  Think about all the configuration headaches this could eliminate.
5. Uniform, whole program compilation. Language independence makes it possible to compile and optimize all code for the program in a uniform manner, including language specific and system libraries.

Right now, LLVM supports a C and C++ front-end, but there is no reason why other languages can’t be added.  In addition, LLVM has a number of static back-ends for all the usual suspects (X86, ARM, etc.).  These guys have done a great job.  Would be interesting to see if a program compiled using LLVM just worked on a Xen virtual machine.  Would a Xen specific back-end be optimal? Anyways, there’s lots of documentation on the site for the details  And as always the truth is in the code, so download it and check it out.

Now here is the real interesting question?  Could the LLVM compilation strategy be realized to create a dynamic back-end that targets a computing fabric or even a cloud.  The LLVM architecture appears to appropriately decomposed.  So modification to one or more of elements of the multi-stage optimization infrastructure should be fine.  The current representation model is brilliant in its simplicity, however it is restricted to the the concepts necessary for program execution on a single host.  Keeping  the representation model light-weight is critical, so you would need to be prudent about adding additional information in order for program to execute in computing fabric or cloud environment and leverage the LLVM capabilities.  However, the implications could be pretty profound;  Your software would essentially perform self analysis and transform itself to optimally run in your cloud, based how it is being utilized.

In LLVM I see the opportunity to create self-optimizing pieces of software, freeing developers to spend more time solving problems for their users, using languages that best fit the problems they are attempting to address.  This is at the heart of the ever elusive “programmer productivity” dilemma. Technology changes, developers have to change their code or write entire new applications to take advantage.  In theory, programs written using LLVM won’t have to change when technology improves, they will just self-optimize to use it.  Maybe not step towards the Singularity, but seems like a promising innovation, and one to watch, for those us creating software today.