aquiline ascension

published: 2010-12-01
author: Hans Nowak

Hans's crude language assessments

The title says it all... here's what I (currently) think about a variety of programming languages, condensed in a few lines.

Python: The first language I really loved; it used to be my secret weapon against the evil statically typed empire of the late 1990s. ;-) IMHO, it has lost much of its luster, especially in the last 5 years or so. Where the focus used to be simplicity and scripting, it now seems to be complexity and web programming, neither of which are especially liked by me. I fear that it is slowly becoming the Java of dynamically typed languages, which is sad.

Ruby: Is pretty cool; its community is (and has been) doing of lots of interesting things. A little too messy for my taste. It's possible that using it more would make programming fun again for me.

Perl: I used to loathe it, but that was mostly based on opinions from people in the Python newsgroup. Although its philosophy is very different from Python's, it also makes sense in a way, iff you read the Camel book. In my experience, other books may not convey the spirit of the language adequately. I am now using it for small scripts (and maybe more in the future).

Io: I used to think this was the language of the future. It has some cool ideas, and is minimalistic and concise (although there are a few things I don't like, like the object/namespace conflation, and operator precedence). It hasn't been going anywhere since I first looked at it though (circa 2006), and I doubt that this will change anytime soon.

Common Lisp: Well, it's a Lisp, so it's super flexible, which I like. Forests of parentheses no longer bother me; the abrasive Lisp community does. Other than that, the language is too messy for me and its standard hasn't changed with the times.

Scheme: I prefer this over Common Lisp; the language is cleaner, and its communities, although scattered over many implementations, are much friendlier. Will take me forever to master; I think it might be worth it though. Only problem is, which implementation to pick? Chicken is currently my favorite, followed by Gauche.

Clojure: I have mixed feelings about this. There are quite a few things I don't like, for rational reasons or otherwise: being a JVM language it's slow to start (making it unsuitable for scripts); I don't like the additional syntax like [] {} #{} #^{} etc; you have to fall back to Java methods in certain cases, etc. On the other hand, it is well thought out, and it's full of cool ideas, allowing easy-to-use concurrency, and sidestepping many problems that Lisp traditionally has had. And, of course, being a Lisp, it's very flexible. This is definitely one to watch (and I'm studying it as we speak).

OCaml: Its type system is like Fisherman's Friend; it's strong as hell and will drive you to tears, but it's also very refreshing. :-) Will likely be my language of choice if/when I decide to implement a programming language. A bit lacking in documentation; the Practical OCaml book is pretty bad; fortunately the online tutorial is better.

Prolog: Pretty interesting. Some things that are very difficult in other languages are really easy in Prolog, and vice versa. I will probably use it am currently using it for an experiment or two. If nothing else, it's great to broaden your mind.

Delphi: I actually used to use this professionally, from 1998-2001, and occasionally after that. I love the fact that it's easy to build GUIs and do database integration and all that, and miss these features sometimes. After learning Python, the language itself (ObjectPascal) suddenly appeared quite restrictive, which is one of the reasons why I've had a hard time getting back into it.

Haskell: Interesting, but too math-y for me, and maybe too terse. I don't think its abstraction capabilities are up to par with Lisp's, either.

Scala: I started reading a Scala book but soon lost interest. Too much syntax, too many ways to do the same thing, too much like Java.

C: I don't use C a lot, but it does come in handy sometimes. I did write some software from scratch in it a few months ago, but usually I only use it to make some changes to existing code, if necessary. Comes in handy for writing extension modules for Chicken as well.

Forth: I like stack-based languages because they're relatively easy to implement. Or so I thought before I tried writing a real Forth, anyway. The language is powerful, simple and elegant (to an extent); however, programs are pretty much unreadable without extensive comments, unless you are very good at juggling stacks in your head.

J: Definitely an interesting beast, although I don't see myself using it seriously anytime soon.


My opinion on these will slowly change over time, to some extent anyway, and I will revisit this post at some point.

blog comments powered by Disqus