Programming languages worth checking out (opens in new tab)

I'm learning F# now because it will be another weapon in my arsenal that I would be allowed to use here. My impression of it, so far, is: "Heh, kinda cool". It is basically the total compromise functional language, but in a good way. Immutability is optional, you can write imperative code whenever it makes sense, and there is a reasonably syntax for defining .NET object oriented constructs. It is very much a functional language that peacefully co-exists with the rest of the .NET ecosystem and that is a strength if you need it. Sure, all of that interop comes at a power and complexity cost, but it is surprisingly small.

If Microsoft can work out a sane licensing arrangement for compute farms/clusters/clouds (whatever we're calling them this week) of Win 2008 Server, then F# is a game-changer of a similar scale to Google's MapReduce. That's a big if tho'.

Having said that, Windows is cheaper than RHEL already...

Sounds interesting. How much is the community tied to Microsoft? "Runs on Mono" is ok, but if no one actually does, that's perhaps problematic for those who don't do MS.

Strongtalk is definitely worth a look. The ability to have static typing when you want it is awesome!

I could imagine a deployment process where code can't be deployed unless it's all statically typed. This lets you do very fluid rapid prototyping, but then firm up parts of the system once they go into production.

Self seems to be a dead project?

I co-wrote (with Steve) SoundConverter for Windows:

http://dekorte.com/projects/shareware/SoundConverter/

The interface talks to an Io "server" which handles business logic.

We're currently working on a shopping aggregation startup. The crawler is written in Io.

Pixar's RenderMan image tool uses Io as its scripting language:

https://renderman.pixar.com/products/tools/it.html

Io is still under development so you might run into the occasional bug. Bugs are encountered more often in the addons than in the core interpreter (which is stable).

I played with Io a long time (like 4 or 5 years) ago, at which time it didn't seem ready for anything serious. I would expect it's gotten much better since then. It would be interesting to know what sort of apps are easy to build in it.

This author doesn't seem to know his subject very well, though. To say that an object-oriented, message-based, fully-reflective programming language goes "far beyond" Smalltalk suggests ignorance of how far Smalltalk goes.

Tried Io a year back. Gave up after it crashed after a few tries. Add with it that it was one of the slowest in speed comparision tests.

There is also an issue with an implementation: the official implementation from Walter is awkwardly packaged and lacks the source (you can't build it yourself). This pretty much turns it into a toy for Linux/OSX programmers: you can't distribute your D code, nobody will figure out how to build it.

And GCC-based implementation is lagging behind in features, and also scores consistently 10-30% slower than C/C++ in benchmarks, which kills D's appeal as a performant replacement for C.

What Walter needs to do, IMO, is to abandon his own implementation completely and closely work with GCC/Linux community to include high-quality D into standard GCC package. Then we may start seeing decent software written in it.

well, i played around with it for sometime. it is pretty good e.g i really like the new (and much improved!) template mechanism especially meta-programming abilities, variadic template arguments, contracts for enforcing class/function invariants, function-literals, dynamic closures etc.

the issue that i have (imho ofcourse) is that of 2 incompatible standard libraries phobos and tango, which makes it quite painful to work at anything significant/non-trivial. iirc, there was an effort to have an stl kind of thing for D, not sure how far (or in what state) it is.

also, it seems to me (i can be wrong about it) that D is being marketed towards corpo-drones doing win32 (c++) stuff, rather than to linux C devs. most likely, they (corpo-drones) are moving towads C#/.net and i doubt that they are interested...

The things I like about Clojure:

1. It has the simplicity fo Scheme. 2. It has literals for datastructures. Hashmap: {"BANK" 122323 "TRANSFER" 212001} . That's it, I created one. Oh, here's a vector for you: [1 2 3 4 5]. Veru convenient, not revolutionary by any measure, just very convenient. And it doesn't sacrifice any power for that practicability. 3. It is more functional than common lisp. 4. Access to all the Java libraries. Whatever you want to do, there is a library. And yes the excessive amount of documentation you have to read to just do something simple might frustrate you but it's a lot more effective than re-solving a problem that has been solved a hundred times before.

I think these things together make it an excellent language.

Why? It's a nice adition to the language and makes using it a much better experience.

My first big project in LISP was making a Sudoku solver for a school project. Could only use basic instructions and lambdas. It was not pleasant trip :P

Have you tried programming in Prolog? The automatic backtracking search is cool when it is exactly what you want, but most of the time it isn't. So you end up working to keep it on the leash least it give you exponential run times when you were not expecting it.

I ended up concieving my algorithms without thinking about Prolog's backtracking, and then coding: bending the Prolog interpreter to my will by getting the backtracking to implement the control flow called for by my algorithm. It seemed a bit indirect and a bit clumsy.

My attempts at writing a parser in Prolog were absurdly slow. Later I read that there are ways of writing parsers in Prolog that work well, and writing parsers was one of the killer apps for Prolog, so I guess I never really understood programming in Prolog properly. On the other hand it is troubling that I failed at one of the things the language is supposed to make easy. I'm in no hurry to give it a second look.

Is it still being used at all? I would be interested in it, too (and I don't think Erlang is very similar to it at all???).

...Erlang is bad enough :P

It's one of my favorite languages, and is rapidly crowding out Python. It's a tremendously clean and powerful language. Since Lua was designed for embedding, its design favored adding a few meta-features that could be used to build task-appropriate features into the language, rather than adding to the language core. It's also a relatively quick language to learn, and is extraordinarily portable - the whole language is written in pure ANSI C.

It also has tail-call optimization, closures, coroutines, and other aspects that are interesting from a pure CS standpoint, such as the way the table datatype is implemented and its register-based VM.

For a good taste of Lua, skim "The Implementation of Lua 5.0" (http://www.tecgraf.puc-rio.br/~lhf/ftp/doc/jucs05.pdf), the quick intro to Lua in the LPEG paper (http://www.inf.puc-rio.br/~roberto/lpeg/lpeg.html , around page 6 of the PDF), or _Programming in Lua_ (http://www.inf.puc-rio.br/~roberto/pil2/). The first edition of the latter is online, though the second edition has a bunch of added material, and IMHO is well-worth buying if you get into Lua. Also, check out LuaJIT (http://luajit.org/), if you're using i386 hardware -- it's a FAST JIT.

It's great as an embedded language. The implementation is so tiny you can effortlessly change the language to change whatever it is you don't like about it.

The C++ bindings aren't so great, last time I checked. The documentation is not of a consistently high quality, but it doesn't matter much because, once again, the language isn't very complex.

I prefer lua to any other embeddable language, including Python.

Playing with Lua is a blast. I don't have much experience in using it for anything but a third-order language (e.g. writing programs that write programs), but it's very lightweight, fast, and easy to pick up. I view it as a language that I use when I need the power of a programming language (as opposed to a one-off program), but not enough to justify using Perl/Python/Ruby.

There are some parts that I did find annoying, however, like the fact that in the standard libraries array indexing starts at 1 instead of 0 and that it gets a bit kludgy when you try and add lots of things that are not part of standard language features, but nothing you can't overcome.

Don't forget Eiffel and its progeny. Design By Contract and heavy use of assertions feels to me like it's closely related to Test First development. You also get fast runtime code out of it (as in C++ fast) in a very Pure-OO environment. (By many accounts, even more so than Java and C++.)