Ask HN: What programming language has you really excited lately, and why?

SBCL, mostly on Linux, but also a bit on OSX. Both platforms work really well, but the experience is a bit smoother on Linux.

On both platforms I have a script that pulls from Git, rebuilds, and installs over the previous SBCL binary image, so I'm using the absolute bleeding edge of the compiler. One day this will bite me somehow and then I'll start using the most recent stable tag, but it's worked okay up to now.

I use Emacs and Slime for development. I had used Emacs for a long time before using CL, so using Slime wasn't an issue for me at all. I know the commercial implementations have some neat IDEs, but I haven't tried them. I'm not sure there's many (or any) OSS alternatives to Slime.

On both platforms I use QuickLisp to install all of the Lisp packages I use. Pure Lisp libraries always work great on both platforms.

Libraries that wrap C/C++ libraries (like Qt or SDL) tend to work better on Linux, but in every case I can think of I've got them working on OSX also, with varying degrees of effort.

On Debian I "apt-get install ..." the required lib* and sometimes lib*-dev packages, and then (ql:quickload ...) has always just worked.

External libraries on OSX are where I've encountered the most problems. Qt was particularly tricky, and I'm not even 100% sure what I did that finally got it working. SDL has some hoops to jump through with a "cocoa helper library" that I had to build by hand, but it's pretty simple and a few minutes Googling turned up enough info to get it working. For the majority of the stuff I've needed (libpng, cairo2, mpg123, and a few others), I was able to install them with HomeBrew, and they just worked once I had my PATH and LD_LIBRARY_PATH setup correctly. OSX ships ancient versions of several libraries (like libpng), but installing the version in HomeBrew usually fixes the problem.

As a scheme guy in general, I myself am very excited by typed/racket. I have always been torn between ML-like languages and lisp-style, with the latter winning most of the time. I have gotten so used to the syntax that I prefer it to most other languages.

But I miss the niceness of typing, which typed racket provides. There are some warts, like having to explicitly typecast when using two polymorphic functions, and that the curry procedure doesn't work as in racket, but other than that it is not far from what I would perceive as the perfect language.

I could of course wish for some other things, like making a curried and strictly typed scheme-like language, but i'm not going to push my luck :)

As rvense explains below, there are a number of very desirable consequences to rusts strong static guarantees, and even performance improvements, all while getting less buggy code. It's even more secure in the sense of being less exploitable: the bugs being prevented by the type checkers are largely about resource allocation e.g. memory but also file handles. And those are often easily exploitable when not properly managed. That kind of compile-time bug prevention is something runtime garbage collection (that is, every VM platform out there) has yet to achieve and so is pretty amazing if you ask me.

Another consequence is the sheer range of applications for which this language can be practically used: systems and concurrent programming obviously, but also Web, realtime, embedded and even supercomputer programming. The reason for that is that rust mostly feels like a light weight scripting language like python, but because of its performance characteristics can viably be used as a drop-in replacement for C.

It's a pity Apache Groovy's ongoing governance problems stopped it achieving a similar goal. Groovy's still great, though, for writing quick'n'dirty scripts for testing Java classes and defining builds, and Grails still offers Groovy exclusively for scripting (though I wouldn't be surprised if Grails soon follows Gradle down the path of enabling Kotlin as a scripting language).

Thanks for the detailed answer, interesting. Hadn't known that Common Lisp had Qt bindings.