There are probably a few thousand programming languages out there, some of which are quite esoteric. Yet most developers only end up learning a handful amongst the most common ones that are currently in use within our industry.
I would argue that learning a new language, perhaps even a lesser known one, can be a lot of fun and definitely worth your time. Even if you don’t end up using a given language in production for anything of a serious nature, a good language will offer you a different perspective and let you grow as a programmer in the process.
People who learn, for example, Lisp or Haskell, will end up being better programmers because of it, even when using Ruby, Python, or Java in the course of their day-to-day development.
It’s also worth noting that it pays big dividends to become an early adopter of a programming language that ends up being popular, both in terms of job / consulting opportunities and in regards to the impact you can affect the community. (Though I wouldn’t use this as your main motivation, as your crystal ball might not be as haze-free as you think.)
In this week’s post, I’d like to list (and link to) ten different programming languages that have caught my eye, and which I’ve personally found to be interesting for one reason or another. I invite you to check them out and perhaps spend some time getting more familiar with one that, after a precursory look, appeals in particular to you as well.
Depending on how closely you follow the development world, I expect some people will find this list to be somewhat too mainstream for their tastes. Even then, you may still encounter some languages you are not familiar with. At least I hope you do.
Without further ado, here is my list:
1) Pony is an open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language. (Launched in 2015.)
2) Nim is an imperative, multi-paradigm, compiled programming language. It is designed to be efficient, expressive, and elegant, supporting metaprogramming, functional, message passing, procedural, and object-oriented programming styles by providing several features such as compile-time code generation, algebraic data types, an elegant foreign function interface (FFI) with C and compiling to JavaScript. (Launched in 2008.)
3) Julia is a high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to users of other technical computing environments. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library. Julia’s Base library, largely written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for linear algebra, random number generation, signal processing, and string processing. (Launched in 2012.)
4) Elixir is a dynamic, functional language designed for building scalable and maintainable applications. Elixir leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant systems, while also being successfully used in web development and the embedded software domain. (Launched in 2012.)
5) Rust is a general-purpose, multi-paradigm, compiled programming language sponsored by Mozilla Research. It is designed to be a safe, concurrent, practical language, supporting pure-functional, imperative-procedural, and object-oriented styles. (Launched in 2010.)
6) Haxe is an open source toolkit based on a modern high level strictly typed programming language, a fast cross-compiler, a complete cross-platform standard library, and ways to access to each platform’s native capabilities. (Launched in 2005.)
7) Agda is a dependently typed functional programming language. It has inductive families (i.e., dependent types), parameterised modules, mixfix operators, Unicode characters, and an interactive Emacs interface. Agda is a proof assistant. It is an interactive system for writing and checking proofs. It has many similarities with other proof assistants based on dependent types, such as Coq, (Launched in 2007.)
8) Idris is a general-purpose purely functional programming language with dependent types. The type system is similar to the one used by Agda. The language supports interactive theorem-proving comparable to Coq, including tactics, while the focus remains on general-purpose programming even before theorem-proving. Other goals of Idris are “sufficient” performance, easy management of side-effects and support for implementing embedded domain specific languages. (Launched in 2011.)
9) Gosu is a general-purpose programming language built on top of the JVM. It is object-oriented, statically typed (with type inference), imperative, Java-compatible, and it offers simplified generics. It’s a “simple and pragmatic” language for the JVM. (Launched in 2010.)
10) Kotlin is a statically typed programming language for the JVM, Android, and the browser. It is entirely interoperable with Java. Kotlin is developed by JetBrains. (Launched in 2011.)
(Most descriptions are from Wikipedia and/or the homepage of each project.)
Have you found a lesser known programming language that intrigues you? What do you like and dislike about it? Feel free to share in the comments below.
Get more stuff like this
Subscribe to my mailing list to receive similar updates about programming.
Thank you for subscribing. Please check your email to confirm your subscription.
Something went wrong.
Thanks for posting this! We really are in a golden age of programming languages. Half of these are totally new to me, and of those, Pony looks really exciting.
Agreed, Pony is one of the most interesting and promising ones.
I recommend Pharo, a modern immersive live-programming vm and language, which some would say is “smalltalk for the 21st century”.
http://pharo.org/
Pharo is a good one. Though in my mind I just think of it as Smalltalk, if we are not distinguishing between the language and its implementation.
The actual Pharo team sees Pharo as something that moves beyond “Smalltalk” the language, which has its last official “standard” in 1980, “Smalltalk-80”.
This is not too different a situation from the Delphi language, which some people call ObjectPascal, but it’s clearly so far past Pascal that it’s silly to call Delphi just “Pascal”. Pascal as Wirth envisioned it didn’t have objects, let alone generic types or interfaces.
In the case of Pharo, the internals have evolved without a need to extend the base language syntax, but as Smalltalk is both a VM, and a language, and a set of facilities for coding, calling it just “smalltalk” is understating what it contains and what it can do. It’s a smalltalk-based ecosystem containing many fascinating tools.
It originated as a fork of Squeak smalltalk but it’s grown a LOT since then.
Thanks for the clear explanation, Warren.
Someone on Reddit recommended J. I included it in the first revision of this post but then replaced it at the last minute in favor of a different language. Feel free to check it out, though.
s/Gosu is a is a/Gosu is a/
I hope you would like https://www.pyret.org/
Fixed the typo. Thanks.
Pyret has a very nice syntax. Do you know if it’s meant to be more than just an educational tool?
Yes, we intend to make Pyret general-purpose indeed: certainly general enough to solve all of our _own_ programming tasks.
However, it’s really important when starting out to have some way of focusing, and some way of making consistent decisions. We find that asking “How will that play out in a setting with students new to computing?” has been very productive and a good filter.
We’re in fact using it to create some pretty innovative curricula (e.g., what we’re calling “lightweight data science”). This is content that will have natural uses beyond teaching programming.
Should also note crystal-lang.org is an upcoming ‘replacement’ for ruby.
Also interesting, Lamonte.
Lily is a language that I’ve developed almost entirely by myself, over the course of about 5 years. It’s not as complete as the languages you’ve mentioned (still not 1.0), but maybe someone here will be interested. For those who are, here’s the intro website: http://jesserayadkins.github.io/lily/
Lily looks really nice. Currently Pony and PicoLisp are my favorites.
Huh, are Rust, Haxe, and Julia really lesser-known at this point? I was expecting stuff people don’t hear about every other day from every programming news outlet… D, J, maybe F#?
This isn’t to say they’re bad (I’ve been a Haxe evangelist since 2007 or so), but I feel like they’ve got a lot of buzz about them already.
The average programmer wouldn’t even know that Haskell exists. Just saying. 🙂
Sure. And an order of magnitude more people have probably used Haskell than have ever even heard of Elixir. 😉
I was just surprised to see languages that are quite popular in programming circles (Rust is Mozilla) and general use (Haxe has basically taken over everywhere Flash used to rule and a lot of web) in the list next to relative unknowns (even I haven’t heard of Gosu).
(Array-oriented languages are a highly recommended exercise for everyone, btw. They’ll change how you think about data.)
Fair enough. 🙂
My list currently only has two entries: D and Rust
Rust, because the Borrow Checker is pretty unique. We need safer systems programming languages.
D, because its meta programming capabilities are awesome. The C++ committees are very busy copying stuff from D.