005 2021-03-22

Thirty years of learning programming languages

I think I started programming with Logo back in elementary school, but I didn't consider it "programming" at the time.

Fast forward almost 30 years, and I can proudly say I've accumulated knowledge and skills in a boatload of programming languages.

The list

Below, I'll try to list every language I've learned throughout the years, in chronological order. I'll also write a brief thought on each one. The languages I still use quite often are bolded, and all dates may be off by one:

• 1993 Logo: I learned it in elementary school and used it to move a turtle around the screen. I remember making it draw patterns and stuff, but quickly got bored. At the time I had no idea it was Lisp. More on that later.
• 1994 HyperCard: I used this to build animations of stick men moving around. I also hardly consider that "programming", but it was good enough for a 12yr old.
• 1995 QuickBASIC: This was a fun intro to actual programming. I wrote loops and made the screen flash and the computer beep. It wasn't used for anything useful other than learning how to use conditionals.
• 1996 Batch files: Since I was using Windows, it was useful to learn how to perform certain tasks on start up, or to automate other system tasks. Batch files definitely saved me some time throughout my career.
• 1997 mIRC Script: In the mid/late 90s, I started using IRC on Windows and needed to customize the experience. I quickly learned this language to improve my mIRC experience. My scripts were never shared, but used personally for managing channels, auto-replying to people, etc.
• 1997 BitchX Script: I honestly have no idea what language was used to write BitchX scripts. When I finally switched to Linux in the late 90s (RedHat, Debian, SuSE), I was still on IRC but needed different scripts to help with channel and user management. I did release most of them, and they're still available online, but I won't tell you where ;)
• 1998 Tcl: Around the same time I was writing BitchX scripts, I was also managing eggdrop bots and had to learn Tcl in order to manage those bots. They were mostly used for private/encrypted DCC chats over the eggdrops, outside the IRC network. The scripts also added some automation and primitive AI features to the bots.
• 1999 Bash: I guess this was when I started leaning more into automation and system administration. Some UNIX books explained that I needed to learn Bash in order to be a Sysadmin, so I did, and I used it to send out emails automatically, update my BIND DNS entries, etc. I still use Bash today for basic scripting tasks like pruning directories, backing up and checksumming data, etc.
• 1999 C: I regularly picked up a copy of 2600 at the Camelot book store in Montreal, and occasionally read Phrack online, so I have to admit I didn't learn C for good intentions. It was used mostly for learning about shellcode, tweaking exploits, and writing small utils as part of a rootkit. I don't write C at all nowadays, because I don't think it's a good language, but I have no problem navigating my way through C code and understanding what it's doing.
• 1999 C++: Soon after learning C, I started Computer Science at College and was forced to learn C++. I actually brushed up on it before starting the first year, and I hated it from the start. "What a horribly verbose and ugly language", I thought, and I vowed to never get a job as a "C++" programmer. I didn't and I don't regret it.
• 1999 HTML: Back in the Geocities days, it was cool to publish websites online. My first was created with Front Page Express, but that was a disaster until I switched to Dreamweaver and then plain text manual HTML editing. Of course, I still write HTML today but mostly use templating systems to generate the code.
• 2000 Server Side Includes: I'm almost embarrassed to add SSI on this list, but it was definitely useful for adding a bit of modularity to static HTML web pages.
• 2000 Perl: I bought a used Perl programming book while I was in high school, and that allowed me to learn concepts around vectors and cgi scripts. It was used mostly with my Apache web servers as the first useful server-side programming language.
• 2001 AWK/Sed: I never really considered AWK to be a programming language. For me it's always been just a way to hack up some text files to extract the data I want as quickly as possible. I still use it today, but only its most basic features, and haven't bothered to learn more. Same for Sed, which I often find wildly useful.
• 2001 PHP: As I was working in tech support at an ISP, I was pushed by a co-worker to learn PHP because it was "the best language for the web". He then moved to a startup and they hired me to work full-time at a new startup coding e-Commerce platforms in PHP while also doing system/network admin work. PHP was much more "fun" than C++ and I used it heavily for over five years.
• 2001 SQL: This one is not really a "programming" language but more like a very specific language for manipulating data in a database. Of course anyone doing PHP was also doing SQL. The nice thing is SQL is still mostly identical even today, and of course I still use it for almost everything that needs a database.
• 2003 Visual Basic: I'm not sure why, but in University I was required to learn Visual Basic, against my wishes. What a butt ugly language, however it had one nice property in that it was possible to make GUI apps for Windows quite easily. That was kind of fun until I discovered Flash.
• 2004 Flash/ActionScript: While I was coding in PHP, I also ended up learning ActionScript for work, and that was a lot of fun. I started with AS 2.0, but when AS 3.0 released was when I really hit my stride. I was using it to build shopping catalogs, animating websites and connecting the Flash site to PHP-backed content. I think those were the glory days of web development because you had full control of every UI element, and with some good AS 3.0 code it was possible to build Flash sites that loaded super quickly even with dynamic content. It helped that I worked with awesome designers.
• 2004 ColdFusion Markup Language: What an awesome name but a terrible language. I was pushed to learn CF while working part-time at an awesome web design company. It didn't take long to pick up, but it was clearly not a "good" language. I only used it in that one work setting for a few years, and never touched it again.
• 2006 Ruby (and Rails): I discovered Rails before Ruby, and that was great because it allowed me to quickly build websites using scaffolding and not much code. Unfortunately I had no idea what was under the hood (i.e: Ruby) and was a terrible Ruby dev, so I didn't progress with Ruby until I dropped Rails and decided to learn Ruby from scratch. I used it for almost a decade for various projects, tools, and websites. Ruby is an amazing language that I would still be coding in if the devs weren't so hung up on continually breaking functionality in newer versions. After being burned by "code that doesn't work anymore" following two separate version upgrades, I got fed up with Ruby and tossed it in the trash. To use the language for production requires stability, and the constant breaking changes made me spend countless hours "fixing" code that previously ran just fine. Now it seems they're quickly deprecating "old" versions which means you need to constantly keep Ruby up-to-date to get security fixes... even though you just want your code to run and you never want to think about it again. I pass on Ruby.
• 2007 Markdown: I use Markdown for almost all my documentation nowadays. I started using it just for wikis, but once GitHub was introduced around 2009, I saw myself progressively writing Markdown documents for personal notes, todo lists, documentation, readmes, anything. Even this blog post is written in Markdown and the HTML is generated from it. Although there are different flavours, I prefer GFM for obvious reasons.
• 2008 CSS: Not really a programming language, but learning CSS was extremely helpful for styling websites. Flash was nice because it somewhat replicated the mix of JavaScript and CSS. But with Flash out of the picture, it was almost necessary for any HTML dev to learn CSS and JavaScript. Of course I still write CSS today.
• 2008 JavaScript: I learned this way back in the early PHP days, but only used it to validate forms and for other basic stuff (ex: updating a ticker on a web page). When the JS standard matured and Flash was out of the picture, I used it more and more for front-end tasks, specifically handling data from external APIs (AJAX/REST). I don't write pure JS anymore, but I still use it lightly in a few places.
• 2009 Erlang: While I was working at Canada's largest datacenter and hosting provider, I grew very interested in distributed systems, so Erlang was next on my list. I fiddled with a few basic tutorials but I never went any further than that. I think the syntax was too "ugly" for me, and I just didn't enjoy writing Erlang code. Although I do consider it a good language with great features and stability. It just wasn't for me.
• 2011 CoffeeScript: I was introduced to CoffeeScript while working at GitHub. One of the devs planned to rewrite Hubot and he encouraged us to learn CoffeeScript in order to port old Hubot scripts, and to write new ones. I took that challenge and now I never write pure JavaScript (JS) anymore. I wrote a ton of the initial Hubot scripts and part of the brain/logic code, but all my git commit history was wiped by the original author before public release. That was shitty but it wasn't intentional, oh well. Even though many people hate CoffeeScript, I think the code it generates is perfectly fine and it's wonderful to write in. I still use it today for all the JS I need to write.
• 2013 Jade/PugJS: Although I really despised the name change from Jade to Pug (because they broke functionality as well), I still use it as my go-to HTML templating engine. Like CoffeeScript, it is a bit similar to Ruby and saves a lot of time and headache for coding. It generates perfect static HTML pages and the syntax is fairly simple.
• 2013 NodeJS: Although not strictly a programming language, I still feel the need to highlight it here due to its importance. I wrote a lot of CoffeeScript/JS for NodeJS, and still find it useful today for specific use-cases. However I would never use it in production again due to its bloatedness and constant security issues. I like it for running local web servers / dev app prototypes with express.
• 2014 Python: I never really "learned" Python to do anything useful. I only picked it up to debug crappy python scripts on my Linux systems. I don't think it's a nice language, and the Python 2 - Python 3 ordeal was a deal breaker and major turnoff. Most python devs seem to be noobs as well, like nodejs devs, and that just never sat well with me. Although I do use a few great and useful python programs (Ansible, Scorch, Bronzebeard), I don't like it as a language and given the choice I would much rather code in something else.
• 2015 Haskell: I began learning Haskell around the same time I was getting annoyed with NodeJS's security issues. At the time I was quite proficient in functional Ruby and wanted to do more functional coding. Haskell was the next logical step, right? Wrong! I can't begin to explain what a terrible experience that was. For starters, 90% of the code examples and tutorials out there don't even work anymore. Next, the language is stupid. Perhaps if you squint real hard you can see some interesting concepts, but after a month of banging on my keyboard I barely got past Hello World and Fibonacci and I had enough. I couldn't see myself building anything useful within a reasonable time frame, so I gave up on that language.
• 2015 Scheme: I eventually grew fed up of messing with stupid languages or stupid maintainers, and decided to grab a copy of SICP and watch some videos about Lisp. Well well, what a surprise, it turns out I love Lisp. The years I spent mastering functional programming in Ruby were a stepping stone to Lisp and all its magnificence. I don't use scheme at all, but it was a great introduction to the language (and the idea).
• 2015 Racket: I then migrated to Racket as it seemed like a more developed version of Scheme. It had libraries and lots of good primitives and a vibrant community, however Racket's focus on pushing you to "create your own language" was not interesting. I wanted to build stuff without needing a whole new DSL. I also didn't like how "bloated" the language felt, despite being much smaller than Common Lisp. I quickly discarded Racket but it's still on my system, as I might one day give it another try.
• 2015 NewLISP: The attraction here was the tiny size of the interpreter, and the very useful approach to the Lisp language. A few features of the language were less interesting, so I also quickly discarded NewLISP and went searching for the ultimate Lisp.
• 2015 PicoLisp: I discovered PicoLisp while looking at other languages on RosettaCode. I was interested in the smallest/most legible implementations of an algorithm I myself had coded in Ruby. PicoLisp was the smallest, clearest, and most interesting of the bunch. The creator of PicoLisp was always on IRC, and he helped guide me through the first couple months of learning Lisp and PicoLisp. I was hooked and I've spent the last 6 years coding almost exclusively in PicoLisp. I also published a ton of open source libraries and projects written in PicoLisp. It's difficult to explain, since PicoLisp is not very popular, but the interpreter is sooooooo small and quick to compile that it's a pure joy to use anywhere for anything. I've even replaced some Bash scripts with PicoLisp. The only downside is its lack of community and libraries (we're a very small group of less than 20 people) and I'm pretty much the only person releasing usable and well documented libraries for the language. I do wish PicoLisp had better native byte manipulation without relying on external C (FFI) code.
• 2016 Prolog: I initially learned Prolog from the PAIP book and was delighted to find it included as part of PicoLisp. I don't use it for anything, but it's good to know that it exists and good to know when to use it when a use-case eventually surfaces.
• 2017 SystemVerilog: As I got more into hardware and embedded systems, I discovered FPGAs and SystemVerilog thanks to the Harris & Harris Digital Design and Computer Architecture book. It's a totally different type of "programming", and I know some people hate it but I actually like it and look forward to using it more in more advanced FPGA projects.
• 2018 RISC-V ASM: I didn't list it here, but I did learn the MIPS instruction set before RISC-V. I guess the turn-off at the time was that it wasn't open source. Now that we have the amazing RISC-V ISA, I find it more and more interesting to write assembly directly for that architecture.
• 2020 Zig: Since I didn't want to write C, and I wanted to perform low-level programming with PicoLisp, I thought I'd learn the trendy new Zig language to created shared libraries to interface with PicoLisp. That was super easy and worked well, however I severely dislike Zig's documentation (or lack of it). I also don't like that the language is still a moving target, and like Haskell, many tutorials and examples from a long time ago just don't work/compile anymore. I think Zig has a LOT of potential, but I won't look into it any further until it reaches a stable 1.0 with a guarantee of backward compatibility and long-term support.
• 2020 Rust: Following my leap into low-level code, Rust was obviously my next target. I bought a few Rust books, read through them, tested things, and ended up writing a few open source libraries and implementations of some ideas I had. I even wrote some Rust code targeting my RISC-V microcontrollers, and the code works perfectly. Everything I wrote is well tested and documented and "bug-free", but after about 4 or 5 months of coding in Rust, I think I don't like it. For starters, it reminds me too much of C++. The language is sooooooo complex and requires one to hold a ton of information in their head just to do something seemingly stupid and simple. All the complexity, bloat, and feature creep in the language make it "not fun" to code in. Seriously, I don't think anyone actually enjoys coding in Rust. It feels as though all the devs from the NodeJS world suddenly jumped to Rust. "Crates" definitely allude to that. Other people's code is hardly legible and very hard to "copy paste" from because they use esoteric language features and countless external dependencies. Ironically, every time I'm looking for a neat CLI tool or library, I always want and hope it's written in Rust, because I know if someone wrote it in Rust, it's probably orders of magnitude better and safer than anything written in C or C++. That doesn't mean I want to code in the language, but I do want others to code in it and create great software in Rust. Right now I want to code in much simpler languages with more stability, less features, less complexity, less bloat, and lower iteration time. If needed, I'll definitely write code in Rust, but I'd rather not - given the choice.
• 2021 Forth: I just picked up Forth a few months ago, and I absolutely love it. It's exactly the right amount of simplicity with exactly the right amount of expressiveness to go and build whatever I want. I love that I can run it easily on an MCU or an FPGA, and still "improve" my code directly through an interpreter. It's a bit day and night compared to Rust since Forth does not come preloaded with batteries and an army of libraries. However the language is battle-tested (used in Spaceships, hello??!!!) and it's been around for so damn long. I don't need to worry about it changing under my feet as other languages have. I would love to see a mating of Forth and PicoLisp one day, but for now since I'm working more on hardware, Forth will be my go-to programming language moving forward.
• 2021 OpenSCAD: Although I haven't learned OpenSCAD yet, I already have it installed and it's in the pipeline of next things to learn. I am getting more into 3D printing and hardware stuff, so I started with Tinkercad and quickly came to realize that clicking around like a moron is not a good way to design something. I had the same epiphany when I was messing with Flash and later discovered ActionScript for doing animations and aligning things perfectly on the grid. For me, designing any kind of hardware component will be best made through code. Since it's parametric, I can easily change the parameters to make a part smaller or larger or taller or whatever. Of course it's a bit more difficult than clicking and dragging a cube on the screen, but it allows for much more precision and accuracy. OpenSCAD is high on my priority list, but I don't have a 3D printer yet...

The end, for now

I think the list above is rather exhaustive and covers pretty much every programming language I've ever learned and used. I may have missed one or two but it's because they're not significant in any way.

There's quite a few languages that I've "mastered" and can use in a professional setting, but I wouldn't necessarily want to (ex: if you asked me to code something in Ruby, ugh... I'd pass).

At the moment I'm much more interested in lean, simple, low-level, and fully controllable languages - like Forth and PicoLisp - where I'm free to write whatever I want with very little constraints. Since I have specific projects, the languages I choose are tailed for those tasks. I have no interest in "coding in Java because there's lots of jobs".

I can't even say that I'm done learning though, so I'll try to remember to adjust this list in the future as I add more languages to my repertoire.

https://blog.a1w.ca/p/2021-03-22-thirty-years-of-learning-programming-languages
2021-03-23 08:26:27 UTC