Programming languages worth checking out

The tool we used to write the supervisor code and GUIs for machine operators was a language called Alltalk. It was inspired by Smalltalk and developed by an old graybeard at the company. Reading the description of Squeak/Smalltalk brought back some fun memories. A few interesting highlights:

- Alltalk ran in its own VM. You could create objects, change their state, and save the entire stack/image back to the original VM. Running the VM again would pick up execution right where it left off. This let someone do crazy things like email an Alltalk image to another engineer and say, "Here's the machine state halfway through an emergency shutdown. The actuators all came to rest in 10ms, but it's taking way too long to shut down the hydraulic pumps. Any ideas?" and the engineer could run the VM and debug away.

- The Alltalk VM had its own object inspector and terminal/interpreter. So you could walk up to an Alltalk instance connected to a live machine with motors spinning at 20krpm, for example, open up the inspector, and code away. Realize you need a low-pass filter on the motor speed feedback sensor? Create the object, tweak the parameters, and wire it into the signal chain live.

Cowboy coding at its absolute finest.

Problems that I've found worth studying:

- Parsing. This is hard if you don't know the standard techniques: mostly recursive descent parsing with precedence -- or a parser generator, but that won't teach you much unless you write the generator yourself. Moreover I've found that you quickly run into limitations with parser generators and they don't make parsing easier in the long run, that's probably why most real world parsers are hand written (e.g. gcc, llvm). You can probably hack something together that sorta works, but knowing the right techniques makes writing an efficient parser that you have high confidence in a breeze. I've seen many ad-hoc parsers that would have benefited greatly from proper parsing.

- Constraint solving. Examples are solving sudoku, the zebra puzzle, SAT solving, optimal register allocation and many others. The three most important techniques are backtracking, constraint propagation and conflict learning. Even professional programmers can't do this if they don't know these techniques (e.g. http://xprogramming.com/articles/oksudoku/).

- Interpretation/Compilation. In addition to being a hard problem, writing an interpreter and a compiler makes you understand how programming languages work. This is sometimes seen as a black art, but it is quite easy once you got the pattern.

- Numerical algorithms. The speed and the simplicity of numerical algorithms is astonishing. Newton's method is particularly amazing. In about 10 lines of code you can solve equations, do state of the art numerical optimization or solve differential equations. It can even handle problems that are usually considered to require specialized algorithms, like max flow and linear programming. It can also perform arithmetic operations, like division and square root.

- Machine learning. This gives you a different perspective on problem solving. Many people when presented with the task of spam filtering or determining the language a snippet of text is written in will respond with a hard coded scheme based on a lot of rules. A much better approach is to take a data set of known text and analyze the statistics of the data set and compare that with the snippet of task text. The same applies to many other problems.

What should be added to this list?

I don't think the author's list provides much variation. They're all important languages, to be sure, but I believe you can get better mileage for your time.

My ten recommedations, in recommended order, are:

    - Racket (nee Scheme - why did they have to change the name!?)
    - Haskell
    - Java (reading the GoF)
    - C, and the POSIX libraries and system calls
    - Go
    - Javascript or Lua
    - Smalltalk or Squeak
    - Erlang
    - Forth
    - Prolog

I don't think you should assume people have used all of these, and they're all worth "checking out". Millions of people use these languages every day to create 99% of the software you're using right now. Maybe it's worth a shot if you don't know one of them to learn one and maybe even get a job with it. There's a lot more opportunity to learn Ruby and get a job in it than there is for Scala.

  * Mozart/Oz - will (probably) change your thinking about concurrency.
  * Clay - really pushes the idea of generic programming.
  * Rust - typestate makes assertions part of the type system.
  * Cilk - concurrency again.

The only type of language I rarely seen mentioned are dependently typed languages like agda or epigram. maybe it is because they are not yet practical. They are an interesting directions things could take though. Fortress is another interesting one.

Another interesting language is Aldor. It's unique in that it has a weak form of dependent types and is a statically typed Computer Algebra/general programming language. Going through the types of the language is an education itself and a reasoning helper. While some take issue to the hierarchy it defines, it is the only one I know that has tried and is useful. The type provide some scaffolding for reinforcing the novice math person trying stuff out.

"“The most obvious common ‘personality’ characteristics of hackers are high intelligence, consuming curiosity, and facility with intellectual abstractions. Also, most hackers are ‘neophiles’, stimulated by and appreciative of novelty (especially intellectual novelty). Most are also relatively individualistic and anti-conformist.” – Eric S. Raymond, The Jargon File"

Which reminds me of that immortal Reservoir Dogs line: "let's not start sucking each other's dicks quite yet"...