Golang because despite its flaws, that’s what we’re gonna write microservices in as an industry I guess. It’s fine, honestly it’s a good work language. A bit joyless to write. Feels designed to let people start working quickly but once you get it you don’t feel like you ever get better.

I’ve been working on Kotlin lately. I always avoided the JVM so this has been eye opening to me. I came along this route by getting introduced to Intellij. Between the conveniences of IJ and the succinctness of Kotlin, i feel like kind of a sucker for avoiding this combo for so long.

Last week I learned some of the rudiments of Pure Data, which is a visual reactive programming language for creating music. Reason: curiousity (it is extremely different from other languages I used), and I want to learn more about reactive programming in the context of a pure reactive language (as opposed to a reactive library API in a conventional language).

In Pure Data, you write code by editing a running program, and you have immediate audio / visual feedback about your changes as you edit the program. This live coding experience is quite compelling.

Pure Data is a visual language in which you connect together nodes using wires. Data flows from one component to another over these wires. Based on screen shots alone, I thought I would hate this, compared to a textual language. The actual experience of programming using direct manipulation was a lot more compelling than I expected. The experience of dragging boxes and wires around made me feel like I was building things with my hands, which feels very different in my head from reading and reasoning about text, and I liked it.

Janet! I was attracted to the language because of how familiar and comfortable it was – the language is basically JavaScript, with value types, without all the crazy stuff. But the compile-time programming was really eye-opening – not just macros, which are fine, but the image-based model of programming, where you can execute arbitrary code at “compile time” – read a file, say – then freeze your program into an image and resume it later – effectively embedding the file you read in your final “binary.”

That was almost two years ago, though. I should probably pick up another language.

I learned a new – style? paradigm? – of programming this year that basically feels like writing a new language. It’s a library for building stateful self-adjusting computation graphs with an API the likes of which I’d never seen before (a “split arrow” or “relative monad” interface). It’s still OCaml, but it was really eye-opening to see UIs modeled as graphs instead of trees. It’s so much nicer!

Pony, because of the Actor approach to concurrency. (ponylang.io)

Still amazed that there a so few languages where concurrency is either not built in at all or just some form of async/await.

I semi-recently learned scheme and then C. Scheme because I was curious and it looked like “simpler lisp” which I had tried a bit with eLisp and it’d been fun. I liked how scheme felt “right” for my brain. I was able to rite very short and to the point functions that I could then compose into bigger functions to accomplish what I wanted, so if kind of matched the natural thinking “to do C and I to do B and to do be I need A”.

I decided to learn C not too long ago because frankly, I’ve just been avoiding it. It feels like I’ve tried everything around it just to not try it. Rust, Zig, LuaJIT FFI… but then when I decided to actually take a look I was just blown away!! C in itself is quite simple and easy to have the whole thing in your brain (C89/99 at least) but what blew me away was the ecosystem! EVERYTHING is written in C! And I could write and do absolutely everything and a bunch of ways! If I wanted to watch a file for changes, I could do anything from polling it myself, using a library, or just straight up talking to the kernel to do it for me. I’ve never felt so empowered and in control before with any other language. pkg-config —list-all became a dear friend and a Pandora’s box to explore :)

So yeah, C has really changed how I code inasmuch and I now feel like o can write anything to run anywhere (I did some embedded dev, so much fun!)

For last year’s Advent of Code, I picked up Gleam. Having a lot of experience in Elixir, I wanted to see what a statically typed language for the BEAM felt like.

The ML-ish syntax was very easy for me to get used to, but ultimately I did not fall in love with the language. There were lots of opportunities to violate the type system and cause a runtime crash, which felt like the main advantage of Gleam evaporating before my eyes. And on the other side, I felt a lot of friction integrating with other BEAM code (like OTP). I didn’t try any Gleam in the browser.

I couldn’t help but wonder if Gleam were written in Gleam, if it would have fewer rough edges.

Perl. I used to use it for trivial glue and CGI; I’m right now learning more of the language in order to write a non-trivial program with it.

Why? Because I didn’t want to use Go or C, and I want to eventually support Plan 9.

TypeScript. I needed to write something that could run in a browser, but I was sick of JS from my last experience of it and I’m so over dynamically-typed languages in general.

I actually really like TypeScript. The only frustrating part is the tooling — NPM and browserify and all that crap. It makes CMake and C++ link errors look like child’s play.

Zig is the only one I have learned in-depth lately.

It’s the “better C” for me. It has taught me that dependent(ish, limited to compile-time values) types aren’t that scary, but very useful, and now I miss them elsewhere.

I learned a new language every year for Advent of Code (Haskell, Clojure, Rust) until I got sick of it and didn’t feel there was a point in racking up languages just for the hell of it. If I had wanted to go on, I’d probably learn APL, Racket, Forth, Julia.

The last language I ‘learned’, just very recently and reluctantly, has been Nixlang which is a disgusting amalgam of Haskell and Bash. There’s absolutely no point of learning this if not for the ecosystem behind it.

I learned LISP! (well, scheme) Because I have fallen in love with functional and it’s something I have always heard is powerful and beautiful, and it is! Probably one of my new favorites.

Hmm this post made me realize that I haven’t learned a language in a long time (by my standards, which include building something)

• OCaml (went through Real World OCaml in 2014) – I only played with toy code, so you can argue I didn’t learn it, but I did get familiar with algebraic data types, which changed my coding in other languages (make illegal states unrepresentable, etc.)

FWIW I no longer plan to use OCaml. I was investigating it as a language for implementing languages, but settled out on the “middle out” / language-oriented programming / DSL style instead

• R (2010) – I learned it because my “data science” team was using it, and I like dynamic languages with REPLs. Looking back, there was some movement toward Python, even at the time. It does seem like Python has a little more gravity now, though I still think R is better for that use case.

I was about to say I haven’t really learned a language since 2010 or 2014. (Python continues to be my go-to, jack of all trades tool)

But I forgot that I did learn PHP !!!

• PHP (2020) - I wrote a small web image tool in PHP, for both my blog and personal use. Mainly because I already use shared hosting for static sites, and PHP is easy – you just upload your files, and they are live. And PHP has ImageMagick built in.

I always “hated” PHP because it was ugly and inconsistent compared to Python. But I like how PHP has a “web framework” builtin – the .php files just correspond to pages. And you don’t have to import libraries to parse web requests, or accept file uploads. What I can’t really get over is that string escaping seems to still be problematic without a template engine in PHP. If I’m going to use a template engine, it feels like I might just go back to Python.

I also wrote a web app in Python Flask around the same time.

So even though I appreciated many things about PHP, I don’t see myself using it again. It was more like a language experiment, to see how much “whipupitude” it has :)

Funny thing is that the next language I will learn may be Elixir. I bought an Erlang book in 2008, and thought it was cool, but I didn’t really have anything to build with it.

I’ve gone through some Elixir and Phoenix docs, and it looks cool, and I want to build some dynamic web sites, including some that have client-side progress indicators and so forth.

For someone interested in languages, I also find not knowing Haskell to be a bit of barrier, since it comes up a lot in papers and demos of languages. Ironically I think ChatGPT could help with the Haskell syntax

Here are some others I’ve looked at:

• Go - I had to write some Go code for work, and I have read a lot about its language design. I definitely respect the design, but it doesn’t seem fun. It seems low on “whipupitude” :)

• Rust - I’ve read a lot about it, but don’t have a project to justify really learning it. And I already know C++, which takes up a lot of head space. I’m impressed at anyone who “knows” BOTH C++ and Rust :)

Honorable mention

• SQL - I wrote SQL by hand in a toy project awhile ago. I still have mixed feelings – it’s powerful, but also really flawed.

• HTML, CSS - I still write these by hand, and improved my knowledge, which I’m grateful will last

• I like to read about other people’s nascent languages, e.g. research languages like Virgil

In the last year I’ve really been focusing on R and Zig. R for classes & my grad research, hacking on my advisor’s R/C++ packages. I don’t particularly enjoy R, but I’ve become comfortable enough in it to (somewhat) read the insane incantations of veteran R statisticians. I’ve been learning Zig in an attempt to use it as a replacement for where I end up using C, and have recently started a compiler that uses Zig for small runtime components (similar to Roc). I find myself having a lot more fun in Zig than in C or C++, but Rust is still my go-to systems/low-level language.

Neither of those were my “latest” which goes to Mojo. I wrote a neural network from scratch a last year in Python, and I wanted to recreate it in Mojo to compare the languages. There were some issues I ran into, but I was able to get a small model working. Mojo caries over the mutable value semantics of Swift which I’m still trying to wrap my head around (the implicit copies were killing me before I added debug to every constructor I had).

As for “how did it changed the way you see programming”, I feel like every language has a bit to teach you. The compiler I started is for a language I’ve been designing for a while that takes inspiration from some of these and more. Zig’s comptime is incredibly eye opening in terms of what a language could provide for type manipulation. Mojo shows us a relatively simple language can achieve insane performance compared to standard C/C++ by utilizing better/different hardware and compiler architecture. R taught me…. well, I’m not sure what, but at least I can use ggplot well.

Clojure, for work - I wanted to work with some folks from the CHICKEN Scheme community I always enjoyed working with, and in the not-so secret hope that we’d be able to do a project in CHICKEN later (still on the original project and no new one in sight so far). I wrote up my thoughts on the language. I don’t have any language on my radar that I’d like to learn right now. Honestly I’m a bit burnt out on software stuff right now and don’t really have the energy to even think about learning something new.

Rust and typescript, around the same time, though that was a few years ago now.

Typescript fills the hole in my heart left by the death of coffeescript, and while the underlying JS is full of design flaws, the ES specs keep making incremental quality-of-life improvements that keep me happy. It’s high-level enough and fast enough for rapid iteration on things like servers (a MUD, an activitypub node, …) and toy web apps.

My day job and some side projects are firmware or other extremely low-level stuff, which is where rust comes in. TBH it has a lot of the same “too many features” problems of C++ and scala, but the benefits far outweigh that pain, and it’s straightforward to write code that’s absurdly fast and tiny.

I’m glad other people are enjoying golang, but I’m too opinionated and like modern affordances too much to really get into it. I can see that it fills the gap between high-level TS and low-level rust, but both languages are “good enough” for me, and I’m writing code mostly for myself.

Coq, though it was a bit ago; I’d mucked with it and other dependently typed languages, but the better part of a year ago was inspired to sit down and actually wortk all the way through software foundations volume 1 & a bit of volume 2, and finally felt like I grokked dependently typed programming & using proof assistants. I then also went a bit deeper into Idris than I had before.

I spend a lot less time learning languages than I once did, and mostly dive into it these days if I think a language is going to teach me something deeper.

My last one was Elixir, for work. My team already did Erlang and we needed something rest-api-like and Elixir+Phoenix just sounded a lot more fitting than doing the hard work in Erlang proper. I like it but I wouldn’t call it revolutionary, guess it depends what you worked with before.

A while back, Elixir. It was a bit difficult to get hang of it as I didn’t have any experience with the paradigm and functional aspects. But oh boy, it did really change the way I look at things. Pattern matching along changed a lot of aspects on how I look at data.

Recently, Go. Seeing the need for it all job posts and people constantly asking about it in interviews decided to learn it. I think Go does well in many aspects where you just want something done quickly and don’t want to spend too much time on getting setup with the language. I can see now why people prefer it for business. Though, my main idea to pick this up is the job market.

I did try Zig, Odin, Rust and OCaml. I really want to keep doing OCaml, but I absolutely have no time or incentive on doing so. It’s still in pending.

Learning about databases on the side, so probably SQL also comes in at times.

Go, because I felt stuck with supporting old apps written in Perl

The last language that I learned is Cython for work. It didn’t feel like learning a language from scratch, because it’s sorta Python, sorta C with Python syntax. There is not a lot of documentation, so sometimes I have to derive the semantics from reading the generated C++ code (we mostly target C++, because that gives us access to STL which is handy for containers).

I used Rust + PyO3 in the past, which I like a lot more, but Cython undeniably gives deeper integration with Python.

Manatee (https://cs.lmu.edu/~ray/notes/manatee/) because I like writing compilers and I hadn’t written one in a while and it looked like a fun one to write. When/if it’s finished I’ll post it here.

Golang, because I like https://charm.sh and decided to build a similar looking TUI.

Initially was not very fond of learning Golang. But even with downsides, it’s a pretty cool language to have under a belt.

Starlark, an embeddable dialect of Python, specifically the Golang implementation starlark-go.

I’m at the RIPE DNS Hackathon in Rotterdam. Our team is prototyping a mechanism for scriptable network measurements using the RIPE Atlas distributed probing system. At the moment Atlas supports a fixed collection of measurement types; scripting should make the measurements extensible, and allow data reduction on the probes.

For this purpose we wanted a scripting language that’s reasonably friendly for data scientists, and which can be sandboxed so that the Atlas probes don’t become a programmable botnet, and which has a host language that’s quick for prototyping.

I don’t know if “learned” can apply to the latest, but I needed to create a frontend for an application, so I started hacking some JavaScript together. I didn’t really delve into the language itself more than getting over frustrations with types and getters, setters. The bulk of the “learning” was getting familiar with the browers’ APIs surrounding HTML Templates.

Before that I learned Jai, in a more iterative learning process, because the language comes with examples and tutorials that go over the basics and less basics of the language. I managed to create a naive HTTP parser that I plugged into a naive socket based server.

Last languages learned and used:

• Go - I learned this in probably ‘16, but only used it long enough to learn that it wasn’t the style of language that I enjoy working in (just a personal preference; there’s nothing wrong with the language). Recently, I’ve been looking at some Go again, and it is very effective in the areas that it gets used in. I need to find time to re-explore the now-updated language.
• Ecstasy - This is my day job for the past several years; I’m creating class libraries for the language and building some apps.
• Kotlin - I’ve learned some Kotlin over the past few years while working with Gradle; I love Kotlin, but Gradle not so much.
• Ruby - I’ve learned some Ruby over the past few years while working with Homebrew (brew); I love Homebrew, but Ruby not so much.

Currently kind-of learning (async mode):

• Haskell - Currently reading some Haskell books to learn the language and the thinking behind it.
• Erlang - Reading about it and learning it slowly over time, mainly because people have suggested Erlang to me to look at. I’ve yet to get time to actually write code in it, and although some of the runtime ideas are brilliant, the language itself is archaic and (IMHO) ugly.
• Type Script - This is a nice language that I’ve used some with React. In theory, it should suck way less than Javascript, but it’s awfully hard to hide that it lives in a world defined completely by – and dominated by – Javascript.
• Dart - I’ve mainly learned bits and pieces from Flutter. Seems like a really nice language.
• Swift - It’s a surprisingly easy language on the eyes; I actually like it from reading other people’s code. It seems like a significant upgrade on objC. I do want to like it, but I haven’t had any opportunities to really use it, yet.
• Scala - Started learning it close to 20 years ago, thanks to friends who were writing books about it, and friends who were building startups around it. I keep learning more and more about Scala from random things, most recently from Jamie Willis (Parsley). It’s an impressively powerful language that I have always wanted to like, but it just never clicked with me; it feels so much like C++ in terms of the “never met a feature it could say no to” aspect.

Languages I’d like to get time to learn:

• OCaml - I mainly want to learn it because it’s commonly cited in academia. Students seem to like it.
• Idris - Another mostly dead academic language. I’d like to play around with its type system.The concepts seem pretty well thought out.

I had to really think about this because I start to learn something and then, you know, don’t (at least not in any meaningful way), but working my way back I think Lua was the last language I took the time to learn and actually use.

It’s used to write tools for Renoise, the DAW I use (along with Reaper) to create music Over the last few years I’ve written a number tools for myself to aid my workflow.

I’m using now to play around with Solar2d, a game engine.

The “indexing starts at 1” thing was a bit weird at first but you get used to it. :)

Can’t say it’s changed how I think about programming, though.

Last one I had to learn was last year with TypeScript. I hated it as a massive step down from the PureScript and Elm I had previously done a bulk of my work in. I was tasked to write in a functional style with the libraries that helped, but overall the ergonomics were just awful for FP, taking 4–10× the amount of code to express the same thing with another language. The cherry on top was a junior had to use some of the code I wrote & didn’t understand Option and just called o.value which rendered the whole exercise moot. If folks can slap Haskell on the server-side and realize they want FP on the client-side, they should recognize there are a wealth of options where the ergonomics and readability are better suited for a team that thinks within the FP reference.

Lately I’ve been reading and doing slow introductory work with OCaml now that multicore is here (while libraries catch up). I don’t fully grok it, but the goal is to get less lost in the ‘nice’ parts of the Haskell-realm type system and more grounded with modules (which Elm, despite it’s clear limitations, clicked better with me even if the boilerplate sucked). It helps that the compiler is super fast and the output binaries are efficient.

C++. It started when I applied to a random job offer, which listed the language as a plus. During the first interview, I was asked how much I knew about the language, to which I answered truthfully: not much; I believe it is mostly C, with classes. Boy, was I wrong! Thankfully, I didn’t get that job, but it made me curious to learn how C++ actually works, and what “Modern C++” means. I did get a different job since then, programming in C++20. I don’t know if it is the language, the topic, or even the team, but I am having a lot of fun with it! While it’s not perfect, I am not in a rush to move onto something else.