Advanced Programming Languages, Hacker News

Students often ask for a recommendation on what language they should learn next. If you’re looking for a job in industry, my reply is to learn whatever is hot right now: C , Java and C # – and probably Python, Ruby, PHP and Perl too.

If, on the other hand, you’re interested in enlightenment, academic research or a start-up, the criterion by which you should choose your next language is not employability, but expressiveness. In academic research and in entrepreneurship, you need to multiply your effectiveness as a programmer, and since you (probably) won’t be working with an entrenched code base, you are free to use What language best suits the task at hand.

Here you’ll find descriptions of four good languages to learn – Haskell, Scala, ML and Scheme – with a list of my favorite features for each, and pointers on where to learn more.

Of course, this short list is by no means exhaustive. There are many uncommon languages that excel at niches. To name just a few more, there’s also D for systems programming; Erlang or Clojure for concurrency; and Datalog for constraint programming. Then there are languages like Smalltalk – alternate yet fully capable universes that branched off from mainstream computing long ago.

I encourage my students to never stop learning niche languages. They expand your modes of thinking, the kinds of problems you solve quickly and your appreciation for the meaning of computation.

Some advanced languages

Haskell .
Scala
.
Standard ML and OCaml

Scheme

Haskell

Haskell excels as a language for writing a compiler, an interpreter or a static analyzer. I don’t do a lot of artificial intelligence, natural-language processing or machine-learning research, but if I did, Haskell would be my first pick there too. ( Scheme would be a strong second.) Haskell is the only widely used pure, lazy functional programming language.

Like Standard ML and OCaml, Haskell uses an extension of Hindley-Milner-style type inference, which means that the programmer doesn’t have to write down (most) types, because the compiler can infer them. It has been my experience that it is difficult to get a bug through the Hindley-Milner type system. In fact, experienced programmers become adept at encoding correctness constraints directly into the Haskell type system. A common remark after programming in Haskell (or ML) for the first time is that once the program compiles, it’s almost certainly correct.

As a pure language, side effects (mutations of variables or data structures and I / O) are prohibited in the language proper. This has forced the language’s designers to think seriously about how to provide such functionality. Their answer, monads , Enables one to perform side effects and I / O inside a safely constrained framework. Naturally, Haskell lets users define their own monads, and now the programmer has access to monads for continuations, transducers, exceptions, logic programming and more.

Aside from being pure, Haskell is also lazy. That is, an expression in Haskell is not evaluated until (and unless) its result is required to make forward computational progress. Some have argued that the promised efficiency gains from laziness Haven’t materialized, but that’s not of concern for me. I appreciate laziness for the increase in expressiveness . In Haskell, it is trivial to describe data structures of infinite extent. Where other languages permit mutually recursive functions, Haskell permits mutually recursive values.

More pragmatically, I have found laziness useful in encoding option types, where utilizing the empty case should always nuke the program. In Haskell, you can avoid creating an option type and instead use error to produce the empty value. Because of laziness, every type in Haskell automatically has two additional values: non-termination and error. Used well, this eliminates much tedious pattern matching.

My favorite feature of Haskell is type classes. Haskell’s type system allows the compiler to infer the correct code to run based on its type context, even when that type context is also inferred. The example of type classes that got me excited was bounded lattices. A bounded lattice is a mathematical structure that has a least element ( bot ), a greatest element ( top ), a partially ordered less than relation ( <:>), a join operation ( join ) and a meet operation ( meet ).

In Haskell, one can define a bounded lattice as a type class:

class Lattice a where top :: a bot :: a ( a -> Bool join :: a -> a -> a meet :: a -> a -> a

This says that if type a (is a) (Lattice) , then a supports the expected operations.

What I really love about Haskell is that it lets the programmer define conditional instances of a class; for example:

instance (Ord k, Lattice a)=> Lattice (Map k a) where bot=Map.empty top=error $ "Cannot be represented." f <: g="Map.isSubmapOfBy" f join meet>

This rule says that if the type k is an instance of an order (class Ord ) and the type a is an instance of a lattice, then a map from k to a is also an instance of a lattice.

As another example, you can easily turn the Cartesian product of two lattices into a lattice:

instance (Lattice a, Lattice b)=> Lattice (a, b) where bot=(bot, bot) top=(top, top) (a1, b1) <: b2 a2 b1 join meet>

It's easy to make the "natural" lifting of the lattice operations, relations and elements to almost any data structure. The end result is that if you use the expression bot or the relation <: href="#scala"> anywhere in your code, Haskell can infer, at compile-time, their "appropriate" meaning based on the type of the expression (which it can also infer).

The ML languages have functors to play the role of type classes, but they lack the ad hoc polymorphism support of Haskell's type classes. Having spent a significant amount of time programming in the MLs and in Haskell, the practical ramifications of inference on expressiveness cannot be overstated.

Favorite features

Type classes

A rich library .
Monads
List comprehensions
Compact, readable, whitespace-guided syntax.
Resources
- haskell .org
. Downloads, documentation, tutorials and more.
The Glasgow Haskell Compiler (GHC) . GHC provides robust support for Haskell on multiple platforms.
Kathleen Fisher’s slides

for her class at Stanford are a good introduction to Haskell.

Real World Haskell

As the title implies, this book pays attention to using Haskell for real applications ( eg , web programming), instead of just for compilers, interpreters and program analyzers.
Scala



   Scala

  It is a rugged, expressive, strictly superior replacement for   Java.   Scala is the programming language I use for tasks like writing   web servers or IRC clients.      In contrast to OCaml , which was a functional language with an   object-oriented system grafted to it, Scala feels more like a   true hybrid.   That is, object-oriented programmers should be able to start using   Scala immediately, picking up the functional parts only as they choose   to.

  I learned of Scala from Martin Odersky ‘s invited   talk at POPL 390957.   At the time, I saw functional programming as strictly   superior to object-oriented programming, so I didn’t see a need for   a language that fused functional and object-oriented programming.   (That was probably because all I wrote back then were compilers,   interpreters and static analyzers.)



  The need for Scala did not become apparent to me until I wrote a   concurrent HTTPD from scratch to support long-polled AJAX for yaplet .   In order to get multicore support, I wrote the first   version in Java.   I don’t think Java is all that bad, and I can enjoy   well-done object-oriented programming.   As a functional programmer, however, the lack of terse support for   functional programming features (like higher-order functions) grates   on me.   So, I gave Scala a chance.



  Scala runs on the JVM, so I could gradually port my   existing project into Scala.   It also means that Scala, in addition to its own rather large library , has   access to the entire Java library as well.   This means you can get real work done in Scala.



  As I started using Scala, I became impressed by how tightly the   functional and object-oriented worlds had been blended.   In particular, Scala has a powerful case class / pattern-matching   system that addressed annoyances lingering from my experiences with   Standard ML, OCaml and Haskell: the programmer can decide which   fields of an object should be matchable (as opposed to being forced   to match on all of them), and variable-arity arguments are   permitted.   In fact, Scala even allows programmer-defined patterns.



  I write a lot of functions that operate on abstract syntax nodes,   so it’s nice to match on only the syntactic children,   while ignoring fields for annotations or source location.



  The case class system lets one split the definition of an algebraic   data type across multiple files or across multiple parts of the same file.   Scala also supports well-defined multiple inheritance through class-like   constructs called traits.   And, Scala allows operator overloading; even function application   and collection update can be overloaded.   Used well, this tends to make my Scala programs more intuitive and concise.



One feature that turns out to save a lot of code, in the same   way that type classes save code in Haskell, is implicits.   You can imagine implicits as an API for the error-recovery phase of the type-checker.   In short, when the type checker needs an X but got a Y, it will   check to see if there’s a function marked implicit in scope that   converts Y into X; if it finds one, it automatically applies the   implicit function to repair the type error.



  Implicits make it possible to look like you’re extending the   functionality of a type for a limited scope.   For example, suppose you want to “add” an escapeHTML () method to type   You can’t modify the definition of String , but with   implicits, you can make it so that when type-checking fails on    myString.escapeHTML () , it will look for an implicit function in   scope that can convert a String object into a type that   supports the escapeHTML () method.



Implicits also allow cleaner cleaner-specific embedded   languages (DSELs) in Scala, since they allow you to transparently   map Scala literals (like 3 or while while into literals in the DSEL.

   Favorite features
- (JVM) (support.)
- Intelligent operator overloading .
- Extensive library.
- Case classes / pattern matching.
- Extensible pattern matching.
- Multiple inheritance via traits.
- Rich, flexible object constructors.
- Implicit type conversions.
- Lazy fields and arguments .
()

Read More