Eli produced an interesting tale of his programming language odyssey today where he tried to recreate his programming language journey. I found it highly entertaining to read precisely because it's personal---and, for a change, even though the word "programming" in the title seems to emit some technicality, it is distinctively not a technical article. Thank god. It seemed like a good exercise to try and reproduce the structure for my own journey, considering my previous blog post was about learning new programming languages. Rest assured, that means the next one can be about biking or bread baking again.

Infant dev years

When I was 11---besides the occasional .bat file editing in DOS, Wowza!---I came into contact with Visual Basic for Applications (or VBA) to script a button on an Excel sheet via my dad's early Windows PCs. I think that would have to be Windows 3.11 but I'm not sure. A year or so later, I was hacking away with Forms in VB5 and later VB6 to create my own programs. I made a few silly things (tic tac toe, find the image behind a matrix of buttons, ...) and shady things (an automated .ace unpacker for those illegal rips and a networked client/server to listen in on my sisters' keypress events! Those were the days).

At some point, I must have started to venture into all things <HTML/>, including the obligatory <MARQUEE/> tag (see the Brain Baking museum). The JavaScript and Java applets were mostly copy-paste jobs as I understood little of what was really going on.

In high school, creating websites took off and became really popular, especially "dynamic" ones: vBulletin started being a thing, and $_POST is still hard-wired into my brain. I built a complex site for my own imaginary consulting company and an actual usable one for a family member's business. We got into contact with C and C++ but that was limited to a few loops and a cout or two. On VB front, I remember thinking about module design and even collaborating with another Dutch guy I came across on the internet. We both made software for fun and started a partnership that was branded as "[deep]/aWhile software".

Learning dev years

Things got a bit more serious at university with Java, a lot of C++ (god Qt is awful), and C#. My bachelor and master thesis was done in a combination of C# and C++ with managed libraries (watch out with garbage collection!). With some projects, we were free to pick whatever we liked, and I remember doing something in Ruby (on Rails?) that was fun. It wasn't more than dipping a toe.

Language paradigms were brought to our attention---hey, there was something else besides OO, it was called Prolog and Lisp, yay! I remember enjoying tail recursion in Scheme with the help of The Little Schemer. I never fully grasped Prolog though, but I'm itching to revisit more Lisp dialects. I also started exploring cross-compiling on PDAs with .NET Compact.

During my university years, I dabbled in Nintendo DS development by helping port DOOM (in C++), and I released my own Linux kernel flavor with the -klak suffix. It was on the 2.4 kernel I think, and it contained some experimental patches for ReiserFS and CPU scheduling I fiddled with myself. It usually resulted in a kernel panic, but I learned a lot of proper C code that way.

First work years

When I graduated, I had no idea what I was capable of (read: nothing), so I applied for a job as an analyst. Not knowing what I was getting myself into, I quickly changed course and landed on an enterprise Java consultancy job. Ant, Maven, Glassfish, Tomcat, RabbitMQ, more awful enterprise framework garbage, ... I can't say I hated all these things, as they were new and exciting to experiment with. Still, programming at big companies wasn't like they made us believe it would be like. In the early 2010s, I also dabbled in Scala (too difficult) and Groovy (too loose), two hyped-up JVM-enabled languages that also compiled to bytecode.

With back-end stuff came front-end stuff: enterprise session beans, JSF, JSP, it's all coming back, and it's bringing a throbbing headache. Glad that is over. I had much more fun exploring prototypal inheritance in JavaScript and doing silly things in jQuery, back when it was a thing and Node, Npm, or ES5 didn't exist. My love for dynamic more functional-oriented languages started there. It was also the early days of cool (and fleeting) new languages that compiled to JavaScript, such as CoffeeScript/LiveScript/Ember, and those Dojo and Underscore extension frameworks.

With the full stack also came the responsibility of storing data, and even though I touched SQL before, this was the first time I saw something on a very large scale. Load balancing, noSQL offloading, entity mapping, Hibernate woes, ... All that. Back home, I tried integrating JavaScript unit tests with Java using Rhino. It worked. Within a year, it was deemed obsolete. Cool.

More work years

Another job meant switching to C#---and C++/VB6 for maintenance---and the world of Nuget and IIS, one of the worst tools I've ever worked with. I also learned a lot of developers are scared and even hostile to change. They don't like to admit they don't know a programming language but don't want to do anything about that. Silly Java VS C# debates usually ended in "my language is better anyway!"---without having to admit they never explored the other side of the wall.

Not that it matters much. I did explore the other side: it turns out they're identical. Except that I missed Maven and Gradle, and perhaps even an embedded Tomcat...

As a developer working a consultancy job, your bosses are quick to push you towards "Java Expert" or something similar so they can charge more an hour, while you don't see any of it. I was "highly encouraged" to undertake a Sun certification (and Spring, and Scrum Master, and ...). Out of protest, I also became a Zend certified PHP architect, that'll teach 'em. Without effect: I never got a PHP job. Luckily, I quit consulting a few years later.

For the occasional script, I started really liking Ruby again. Until that was shot down by the company because nobody else knows it... The Ruby script became a PowerShell one. Much better, right?

Academia years

Funny story. My PhD is education-oriented and uses qualitative research that leans towards psychology: distinctively not coding. Still, the freedom and flexibility of academia permitted me to properly explore more languages than the previous years as a "real" developer in industry.

Since I had to teach C/C++, I got into GBA programming and developed a 2D sprite engine for it, a change to hone my C++11 skills. Not that I like the language, but I like the Game Boy, so I complied (and compiled). At least I let CMake generate the Makefiles.

In-between research and teaching, as a JS fan, I try to keep up-to-date with the latest Node and ES standard changes, although the more I write async and Promise.all(), the crazier I think I'm becoming. I also dipped a toe or two in Python because of a teaching assignment, but it's a very limited first-year course, so the effort was limited. I did already play with it while writing a converter for exporting my DokuWiki site to this Hugo site. I'm still torn whether or not to like the ecosystem.

Last year I decided to take a few weeks to explore Go because, you know. It compiles natively and I was getting sick of malloc(). I've done a few homebrew projects with it, including the Webmention service for this site, and like its conciseness so far. I know many people dislike Go because of its "enterprisey focus" and inconsistencies, but I don't think those people have plodded in the JDK/.NET/C++ world for years and years. If I could choose between a Java, .NET or Go job, for the moment, I'd choose the latter. Perhaps because I know the least about it. New is exciting, right? My wife's Wordpress site allowed me to dig into PHP 7, and a lot has changed since high school, but surprisingly little in the Wordpress core. The Loop is still there!

A new Android app development course this year forced me to explore Kotlin, and although I was initially quite excited to get rid of all the Java plumbing, disappointingly, Kotlin is still just Java. If I had to work on the JVM and interop with Java, I'd write in Kotlin---probably because if I attempted to commit Clojure code, I'd get "but I don't know any (((!" responses. I wonder how many larger companies rely on JRuby.

That about sums it up. TLDR:

1. Visual Basic
2. HTML
3. PHP 3 (the wrong way)
4. C
5. C++
6. JDK 1.4
7. Scheme/Lisp (a tiny bit)
8. Prolog (a tiny bit)
9. .NET 2.0
10. Ruby (a tiny bit)
11. JavaScript & flavors
12. Java EE
13. Groovy/Scala (a tiny bit)
14. "Proper" C#
15. More C/C++11
16. Python (a tiny bit)
17. Node/ES6
18. Go
19. Kotlin

It's hard to pick a favorite. I'd like to learn more Ruby and Lisp dialects, that was fun to fiddle with, but my experience with both languages is quite limited. I tend to use ES6 to write scripts nowadays but that's because most scripts are for my site and it already has a Yarn/Node dependency anyway. I'm thinking about deprecating JavaScript as a go-to language, it's just getting too frustrating to do anything in. For enterprise server stuff, I'd say Go or perhaps Kotlin, although the JVM is getting tiring to work with. I'd never choose C/C++ willingly. I actually never had the ability to choose (except in small hobby projects of course) so I never thought about that.

Languages to learn to look forward to:

• Lua & Fennel
• Elixir
• Ruby 3 (more in-depth)
• Perhaps Elm? Not sure if this is going to be just a fling
• Perhaps even Clojure, although the JVM is getting boring

What about you, what's your programming language odyssey like? Do you have any recommendations for me? Let me know! I'll blatantly ignore your assembly requests.