Beyond Java - Bruce Tate [92]
In the end, Smalltalk may yet make an impact on development, but as the proving ground for ideas like continuation servers. You'll find evidence of Smalltalk's object model and syntax everywhere. Most notably, Ruby liberally borrows code blocks and idioms like returning self. I think continuation servers will ultimately play a role in web development. They just make too much sense, are too natural, and are too compelling. Smalltalk is where all the continuation research is happening.
Lisp
Lisp is an extremely powerful language that excels in its strange but pure syntax, abstract modeling, and raw efficiency. In Lisp, everything is a list, including Lisp programs. Metaprogramming in Lisp feels natural, and is quite popular. Important ideas like aspect-oriented programming and continuation servers started in Lisp. Several dialects like Dylan and Scheme appear periodically, but none has achieved much success in the commercial mainstream, beyond a macro language for the Emacs. Still, start-ups often use Lisp because once you learn it, you can be incredibly productive. Some very successful programmers like Paul Graham (author of Hackers & Painters) believe Lisp is the most expressive programming language, and they could be right.
Lisp's community has always been made up of intelligent developers, and it's still popular among academics. In fact, some of the best programming universities, like MIT, emphasize Lisp early, to get students to quickly think in the abstract, and to expose them to functional techniques.
Maybe all languages will once again return to Lisp, but I don't think that Lisp itself is the ultimate answer. It's just too alien, and it takes too much time and effort to learn.
Functional Languages
It's probably a bit too early to be talking about functional languages , because we seem to be moving toward object-oriented languages instead. Still, functional programming provides a higher abstraction and very good productivity. It's possible that some functional language could explode, with the right killer app.
Haskell and Erlang are two of a family of programming languages called functional languages. Functions are the focus of functional languages. I use the word function in the pure mathematical sense:
Functions have no side effects. This oddity takes some getting used to for most procedural programmers, but also has significant benefits.
Functions return values.
You can use the return value of a function anywhere you can use the returned type.
You can do functional programming in languages like Ruby and Lisp, but for research or purity, often it's better to use a purer language. Here's a Haskell example, which computes the factorial of a number:
fact 0 = 1
fact n = n * fact (n - 1)
Then, as expected, you can compute the value like this:
fact 10
Here's a Fibonacci sequence (where each number is the sum of the previous two):
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
Functional languages let you work at a higher level of abstraction. Haskell has good traction in research and academic communities, and seems to be gaining a small, vibrant commercial community. It's easy to teach, and as such, it could provide a doorway into functional programming, much like Pascal provided a doorway to procedural languages.
You can see the power of functional programming in the Erlang language. Developed at Ericsson, Erlang's main focus is concurrency. Erlang lets you easily create and use threads, and communicate between them. Erlang also improves distributed computing, because the location of threads is transparent—a thread might be in the same process as another, or on a different machine. It's productive, dynamically typed, garbage collected, and very small. There's