Interesting Programming Languages

I kinda have a fetish for unconventional programming languages. Basically, programming is a hobby of mine: if I’m going to spend my free time coding something I better write it in an interesting language. Here’s a list of the languages that I’m interested on and some notes on them.

Stuff I use

This are languages I know and love. It’s basically what I use on my day-to-day — besides more conventional languages such as Python and Ruby that I use when contributing to random projects on the web. There’s some other languages I know well too, but I don’t quite like those…​

Rust

Rust has a lot of things going for it. It’s meant to be a modern alternative to languages such as C and C++. It’s very fast and it has a minimal runtime.

One of it’s more interesting features is it’s memory model: references in Rust are owned, which means memory is guaranteed to be safe — unsafe memory is one of the most common bug-causes in C and C++, so this is a direct answer to some of the shortcomings in C-ish languages. Some people have a very hard time “fighting Rust’s borrow-checker”, but I love it.

Another very interesting feature of Rust is it’s type system. Rust supports algebraic datatypes (ADTs), which means Rust types have products and coproducts. ADTs means pattern-matching too, which is awesome!

Finally, Rust also has a very interesting hygienic macro-system. You can checkout the details in here: danielkeep.github.io/tlborm/book/README.html

Haskell

The one and only. Haskell doesn’t need much introduction, but for those of you who don’t know: it’s a lazy, statically-typed, pure functional language.

The lazy bit means evaluation is postponed as much as possible, which allows for infinite data-structures and generally improves performance. The pure bit means functions in Haskell have no side-effects — well, not really, but there’s a type-level barrier between the world of pure functions and the side-effecty world.

Like Rust, Haskell supports ADTs — it even supports generalized algebraic datatypes (GADTs), which are a generalization of ADTs.

Stuff I’d like to learn

Idris

Idris supports dependent types, which means types are values and type-parameters need not to be types — type-parameters can have any type.

This allows the programmer to express precise constraints of a peace of data using it’s type-signature. For example, one can write v : Vect 5 t to say “v is a list of five elements of type t”.

Of course, you can already do this sort of thing in languages like C or Java (i.e. t v[5];), but Idris supports generalized dependent types: type-parameters can have any type.

For example, one could define a generic type Transaction (db : DataBase), which is parameterized by a value of type DataBase — Transaction is really a function that takes an instance of DataBase and returns a type (i.e. a value of type Type).

It turns out dependent types can also be used to express and prove statements about a program, which is really cool too.

Racket

Racket is a Lisp dialect — specifically, it’s a Scheme implementation. I’d really like to experience the joy of Lisp everyone talks about. People say Racket is a pretty cool choice for writing DSLs too.

Prolog

Prolog is a logic programming language. Programs are expressed as relations instead of functions or procedures, which is very interesting.

OCaml

OCaml is another language from the ML family. I’d really like to get some experience with more traditional ML descendants — basically anything other than Haskell and Miranda.

Erlang/OTP

Erlang is a beautiful language for writing embarrassingly concurrent systems. It’s a really really interesting paradigm and it’s definitively my choice for concurrency-related problems — I just don’t get solve those very often.

There’s actually a whole bunch of languages built for the BEAM — the virtual machine Erlang runs on. Some highlights are Elixir and Alpaca. I’m interested in learning any of those.

Stuff I’d like to play with

GAP

GAP “is a system for computational discrete algebra”. It’s mostly focused on Group Theory, which is something I’ve been studding lately. I’d like to know what it’s actually capable of.

Assembly

I’ve played around with x86 assembly in the past, but I’m far from being able to be productive with it. I’m also interested in developing a game for a vintage console such as the NES.

Here’s a video o talk of mine on (basic) assembly programming: pablo.escobar.life/2020/11/19/introduction-to-assembly.html