I want LISP but I don’t want LISP

LISP basically has everything I as a developer want. But somehow I just can’t bring myself to touch it with a ten-foot-pole. Maybe it’s the parenthesis ridden syntax, maybe it’s the functional paradigm, maybe it’s its mostly academic nature. Maybe it’s my preference for curly-brace languages, or my preference for object orientation. Maybe it’s those weird cons data structures and the equally weird car, cdr functions. Like LISP, Haskell and Erlang scare me. They have awesome concepts, programs can be mathematically proven to be correct, support parallel computing and more. Yet it’s that very mathematical nature that makes me uneasy. Math never held much fun or interest for me. It has always been a chore, a means to an end.

I often find myself looking at JavaScript, thinking what a great language it is. But then I remember everything that’s wrong with it: slow implementations, interpreter specific additions, bad initial design choices, artificial restrictions and it going nowhere as ECMAScript. There are efforts under way to make it more viable as generic scripting language, like module imports and similar. But I fear these efforts are futile as long as JavaScripts most basic flaws are not fixed.

Python is also quite nice but if Python gave us anything, it’s the knowledge that making indention part of the syntax does not create more readable code. There is also the matter of the GIL which extremely hinders parallel computing. And the many, many syntactic additions, some of which I see as useless if Python only had anonymous closures. Also the lax handling of naming conventions in the standard library is annoying.

I also like tinkering with Lua. It’s almost a better JavaScript and so extremely easy to embed and extend. But its syntax is just so wordy, and inconsistent: “do end”, “for do end”, “while do end” but “repeat until”, “function end”, “if then end”? Why not “function do end”, “if do end”, “do until”? What bothers me even more, Lua uses 1-based indexing. This is often discussed and well argued, but almost every other language uses 0-based indexing, so this is just estranging new developers coming from other languages. I also don’t think much of Lua’s mixed hash/object/array datatype, the table. While I can “get” hashes and objects being similar, like in JavaScript, I just don’t see what good can become of mixing in arrays. Sequential list data types are way different from hashes and objects, they need a different interface. Just because they share a similar operator isn’t enough of a reason to merge them with hashes/objects.

I have been doing a lot of coding with PHP and I probably will do some more but it never really makes me happy. PHP is a really bad language, it has no future. There isn’t really a roadmap aside from v6 maybe bringing better unicode support. It’s slow, cumbersome and way to tolerant about errors. The standard library, if you want to call it that, is a flaming mess of sloppily and haphazardly exposed C functions with no recognizable standards or pattern to it. The automatic value conversion is just a tragedy as well. Object orientation is – like so much else – so much of an afterthought, it’s really cumbersome and painful.

Can’t really say much about Ruby, having never used it. Something about it gives me goosebumps and not the positive kind.

C, C++ and Java are off my map as well, they are way to verbose about their typing, something Google’s Go is doing much better with. On the other hand C is well known, has good compilers on almost any platform and a good developer can write insanely fast code. Given enough time and effort, there is nothing you couldn’t do with C. Even object oriented programming is possible, as Gobject demonstrates.

C# is a no-go for me as long as it is connected so strongly to Microsoft. While there is Mono, it seems like all they are doing is copying and catching up to Microsoft and dotNET. The technology behind C# is also way to similar to Java and basically offers nothing over it but different syntax and a different runtime.

So what else is there, what other language is worth learning? What will development evolve to, where are new ideas, not only in architecture and paradigms but also in syntax? What will be the next C?

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: