Programming Languages I have tried this last year

I have been exploring different Programming Languages over the last couple of months, from Imperative to Functional Design, Largely to increase my understanding of different coding paradigms to expand my knowledge. Here are some of my thoughts on the languages that stood out to me.

For this article I will assume that Rust, Odin, and Hare are imperative languages, discounting some of the OOP and meta-programming patterns that can be found in Rust, I will do a basic comparison and my thoughts on these languages.

Rust is a language that I had to pick up around a year ago for an ongoing project. I enjoyed some parts of the syntax, such as impl blocks for structs, explicit signed types like 'struct Foo { num: i64 }' and parts of the package-management system. One of the largest things that Rust changes about how you program is the explicit thinking around lifetimes and memory allocation. Having to manage 'mut' keywords all around your codebase can be annoying, but as a beginner, the borrow checker does make this type of thinking forefront. Common arguments around this are that this type of thinking exists for any systems-level codebase, which is correct.

However there are some large negatives to Rust as well. Namely that Rust's default package-manager Cargo, is both a safety concern and is a main cause of code-bloat. As an example, The previously mentioned projects final state was around ~1.4k LoC and took around 1-1.5 minutes to compile. This was in large part to the amount of dependencies, and the dependencies of the dependencies, and etc.

During the compilation process we had around 3-4 different versions of parking_lot that had to be used, I have no idea what parking_lot does, but it was apparently needed.

A Dependency graph this large is nothing to scoff at, and is also a massive security concern if your pulling in random packages without any capability of understanding what code you are using and why. This was one of the main reasons for my frustration, although I also had some bones to pick with other parts of the syntax. I wont go into specifics, but it was pretty common to spend 5 minutes rereading sections of Rust code to figure out what was going on and why at times.

My favorite part of Rust was something like this

  struct Foo {
      name: String,
      age: u32,
      health: i32
  }

  impl Foo {
      // functions on type Foo here
  }

This makes treating structs like their own type a pretty nice way of organizing code in a OOP-like way, without any of complexity of things like constructors, etc.

I spent less-time with Ocaml, although I have some good things to say about it.

First: for a Functional, OOP, Garbage-Collected language. Ocaml is incredibly fast (basic scripts rivaling the speed of C)

Second: Ocaml has surprisingly more bindings and a good-size library for various programming tasks than I expected

Third: Ocaml brings together a lot of the Rust concepts around Options, Matching, and Destructuring into focus, as these were borrowed or directly influenced by Ocaml and ML languages

I suggest that you play around with learning about Ocaml through this book and course here. One of the reasons for Ocaml's high preformance is that it's the language-de-jure for Jane-Street, a company focusing on High Frequency Trading and other high preformance applications.

Example Code:

  (* number of elements in list that match with value 4 *)
  let rec findfour lst =
  match lst with
    | [] -> 0
    | h :: t ->
    (if h = 4 then 1 else 0) + findfour t 

type ptype = | TNormal | TFire | TWater
type mon = {name: string; hp: int; ptype: ptype}

Janet is a Lisp-based Dialect that is mainly inspired by Clojure. The language was written by the same person who made Fennel (Lua-based Lisp). Janet is extremely easy to understand if you have already grasped the basics around Lisp syntax. It's implemented in around 15k lines of C. It takes the same(ish) approach to Clojure by compiling to byte-code for a VM. Janet has immutable and mutable data-structures. These structures are pretty much mapped directly to C structures and arrays. Janet has a great library, easy iteration speed with the repl, and is 3-5x more preformant than other popular scripting languages like Python. If you are familiar with Lisp or Clojure, learning this language should only take you an afternoon. Like other lisps it also has powerful macroprogramming abilities. Here is an example script on my machine that is used to setup coding projects

  (use spork/sh)

  (def readme-contents "* Overview \n")
  (def makefile-contents "target:\n	cc main.c -o main && ./main")
  (def proj-root "testing")

  (defn project-name []
    (print "get project name"))

  (defn make-dirs [name]
    (create-dirs (string name "/docs"))
    (create-dirs (string name "/bin"))
    (create-dirs (string name "/src")))

  (defn make-readme []
    (spit (string proj-root "/README.org") readme-contents))

  (defn make-makefile []
    (spit (string proj-root "/makefile") makefile-contents))

  (make-dirs "testing")
  (make-readme)
  (make-makefile)

Hare is a systems-level programming language that is an improvement over C, with defers, string-slicing, and other language features that improve the daily-usage of using it. From a cursory glance it has similar syntax to C++ with :: scoping for different functions and features.

It is implemented on QBE rather than LLVM, although from my testing in a lot of cases it's faster for smaller programs than other LLVM-based 'Better-C' languages like Odin, Zig, etc. It has a medium-sized standard library, but nothing that really stands out to me. This looks like a great language for implementing CLI's or other programs that might not be dependent on other libraries. Otherwise you would need to create your own bindings to build anything large.

It looks to be attempting to replace C in being a bedrock language, with no constantly changing standard, and with a stable support release that you can build programs for that will work forever after they hit the 1.0 release of the compiler.

I have been trying Odin for the last two weeks and have largely fallen in love with the language. It has a much better build/module system than C, all of the benefits of the 'Better-C' languages that you would expect (defer,slicing,built-in DSA) while also providing a very simplistic syntax for everything. It has a massive standard library. A community of people who are encouraged to vendor dependencies. And lots of Example Code for getting started.

I have been working on making a basic X11 Window Manager in Odin the last couple of days with the built-in "vendor:x11/xlib" package, and it's been a pretty pleasant experience.

Here is some example code for Odin.

  Foo :: struct { name: string, age: u32, health: i32 }
  fmt.printf("example")
  defer { fmt.printf("program is finished") }

  hmap := make(map[string]int)
  my_arr : []u16 = { 0, 1, 2, 3, 10 }

Odin's only downside, alongside other LLVM languages, is that it's still slower than C for compilation time comparisons. Largely because of LLVM. It also has data structures for bit-sets, xar-arrays, simd-explicit syntax and other goodies to help you be performance-aware. Odin largely comes from the 'data-oriented programming' community, and adopts a lot of thier principles and ideas.

It has bindings for every Graphics API (Vulkan, OpenGL, SDL2/3, etc) It also has bindings for GUI, Sound, Images, and various other things that would be useful for making large applications, such as game-engines. Odin's Motto is: Be Simple, but Batteries are Included

Out of all the other languages that I have tried, Odin is much simpler to quickly spin up various different projects for different libraries without having to wonder how you could provide some type of workaround here or there.

I want to continue working on my Ocaml skills before moving over to Haskell and taking a deep dive into Monads and type-systems.

I want to look at Erlang and Elixir and see how they handle concurrency.

Go seems very similar syntactically to Odin, and looks to be more comercially viable for the labor-market, than most of these other languages I have discussed so far.

It also seems that I have very weak SQL skills, which is pretty surprising, but considering that SQL is more like a DSL, than a fully-blown programming language, I don't think I have to worry about investing too much time into learning more about it.