Not to be left out in the “doing cool things on the web”, is a fairly
new framework for Scala (another highly functional language with some similar features to Erlang and Smalltalk) called lift. There’s an interesting post by the author showing a twittr clone he claims can scale to
handle twittr’s traffic with only 2 machines thanks to message
persistence with the Actor based model.
The neat thing about the code examples shown is that they look
substantially easier to follow and maintain than code I’ve seen for
Haskell, plus with Scala you can use existing Java classes and
lift is yet another web development framework. lift runs inside a Java web container and uses the Scala programming language for coding. lift stresses security, developer productivity, ease of deployment, ease of maintainability, performance, and compatibility with existing systems.
lift borrows from the best of existing frameworks including Seaside‘s highly granular sessions and security, Rails fast flash-to-bang, Django‘s “more than just CRUD is included”, and Erlyweb‘s scalability for Comet-style applications.
lift is built on Scala, a hybrid Functional and O-O language that compiles code down to the Java Virtual Machine. Scala code can call any Java code and make use of all Java classes. Java code can call some Scala code. lift applications are packaged as WAR files and can be deployed on any Servlet 2.4 engine (e.g., Tomcat 5.5.xx, Jetty 6.0, etc.)
lift code is as clean and brief as Rails, yet performs 6 times faster and is multithreaded. Additionally, because Scala is strongly typed, the compiler catches type errors.
In followup discussion about the Java VM as a target for multithreaded languages, Keith Fahlgren wrote: “The JVM is steamrolling everything! Just ran across a JVM-backed GHC-based Haskell translator. (via Philip Wadler, the guy who wrote our Java Generics book.)”
As you may know if you’ve been following this blog, we’re seeing an upsurge in interest in functional programming languages, based in part on the rise of multi-core and other parallel programming architectures. On that note, I should mention this Wednesday’s lecture in Dennis Allison’s class at Stanford, Multi-core, Multiprocessor, and Memory Hierarchies:
An Application Developer’s View of Next Generation Systems Enablement
Keith went to a related talk last week, and noted:
Yeah, the one last week from the same series was quite good and well attended (70 , I think). “Taking Concurrency Seriously: New Directions in Multiprocessor Synchronization” mainly dealt with a
harnessing (Software) Transactional Memory and existing (potentially lock-based)
low-level concurrent collections (in Java, written by “experts”) into a
higher-level transactional model (which he called Transactional Boosting).
Keith also reminded me of Dave Patterson’s talk in the winter, Computer Architecture is Back: The Berkeley View of the Parallel Computing Research Landscape.