Here are snippets from two conversations I had recently:
20:03 < psnively> DRMacIver: I do think of you as taking a “Scala is one of the few languages worth criticizing” stance.
psnively’s comment is of course patently untrue. I criticize all sorts of languages. It just happens that Scala is one of those I use the most (at least in my free time), so I tend to criticize it more often than others. It’s true that as I rather like it I hold it to higher standards, but I feel no problem with criticizing other languages. :-)
llimllib’s comment is much more close to home. I get into arguments about languages all over the place. The problem is that:
- All languages have problems with them
- There are very few languages which don’t have something good about them as well
So the first point gets me into arguments with the people who love the language, the second gets me into arguments with people who hate it. I really can’t win. :-)
So, just to piss everyone off, I figured I’d write a post about the different programming languages I have opinions on. The structure of this will be simple: For every language I feel like I’ve used enough (or at least know enough about and have used some), I will write four items: Two saying what’s good about it, two saying what’s bad about it. These points are not intended to be the best or worst things about the language, or even neccessarily representative. They’re just something that has struck me as good or bad. Also, the format practically guarantees that I’m probably not saying anything anyone else hasn’t said a few dozen times already. :-)
- Very interesting modularity features
- Implicit arguments are great.
- The standard library is pretty embarrassing
- It’s very easy for it to look like Java with weird syntax, particularly when using Java libraries.
- Extremely powerful and interesting type system
- Purity enforced at the language level often makes it much easier to write correct code
- Really weak support for modularity
- Aspects of the type system make it difficult to reuse nearly identical code across different contexts (consider sort vs. sortBy and map vs. mapM).
- Flexible syntax and semantics make it easy to write some very terse code
- Makes general purpose scripting tasks very easy to hack together
- Namespacing issues abound, between open classes and a tendency to stomp all over the global scope.
- The implementations.
- High quality implementation, with very good JIT and garbage collector.
- Very rich ecosystem with lots of libraries.
- Bindings to native libraries tend to be rather low quality or non-existent (JNI is a pain)
- Their closest Java equivalents typically are too
- Gives you a lot of fine grained control over details that higher level languages hide
- High performance native code compilers for just about every platform ever
- Almost no capability for abstracting over type.
- Language level support for modularity basically doesn’t exist – namespacing by prefixing your function names, yay.
- Provides a lot of shiny new features over standard ML – lazy evaluation, row polymorphism, polymorphic variants, etc
- Very powerful module system (which I’ll admit to not entirely understanding)
- If you ignore the shiny new features, the core language is basically a worse Standard ML.
- Although it has a justified reputation for writing high performance code, this seems to be only true if you write it as if it were C.
- Borrows many more features from functional languages (tail calls, lexical scoping, etc) than most of its peers.
- Very embeddable, rendering it very easy to use in the context of applications where the core is written in other languages.
- Weirdly deficient standard library (I know this is related to ease of embedding, as it seems to be the result of a desire to keep Lua small)
- The language can be very verbose in places – consider the use of “local” to mean “Hey, I like not stomping all over the global scope”.
This one is a bit weak, as I’ve only really used python in a few contexts, and haven’t really formed any strong negative opinions about it aside from a generic mild dislike. :-)
- Has a lot of really cool libraries / projects built on top of it. (NLTK, NumPy, Sympy, pygame, etc).
- The batteries included philosophy of the standard library is very appreciated.
- I find the “there is only one way to do it” attitude of community very dogmatic.
- I’m not a big fan of the syntax. (I know, I know).
- Forms a nice back end for a data processing app
- Extremely good for constructing ad hoc queries against your data model
- Dear god can it be verbose.
- Total lack of standardization a pain in the ass.
- Pretty decent support for functional programming
- The prototype based OO is interesting and useful.
- Really weird scoping issues in places (particularly behaviour of globals and “this”).
- The implementations are weak and inconsistent
And there we have it. :-) Some of these I could probably say a lot more good and bad about, some of them I struggled a bit on one side or the other and probably couldn’t, but those tend to be the languages I’ve used the least (in particular I’ve used Lua, Python and OCaml dramatically less than I have the others on the list).