20 years of programming

It hit me just now that I've been programming for fun since 2004-2005, aka 20 years... So I thought I'd ramble a bit about some of those years, in brief. This isn't going to be an autobiography or anything, and isn't complete or well-edited, but just a bit of history for my own future reference I guess. Maybe I'll want to write something up that's more serious in the future.

According to an old updates file, I launched my first public site on November 3rd, 2004. That was just HTML though. On the 16th, an online friend took pity on me using a free site host that injected ads and other pop-up spam onto my page, and offered to let me host on his server as a subdomain. So I figured out how to use FTP and was hosted there. Then much later that same friend took pity on me again, I think after he realized how much copy-pasting I was doing in HTML, and showed me a basic PHP script (that by using his host would work automatically) that let me require_once some include files for all pages, or conditionally on some pages, and basically cut down my HTML burden significantly. My records say that August 20th, 2005 was when I replaced the old HTML file for my updates, with September 2nd, 2005 saying "The recoding is complete!" I assume that means the PHP recoding.

I'm not sure if I got it for my birthday that October, or if I got it earlier on, but I remember my mom taking me to Borders and I picked up a recommended book from my friend, PHP and MySQL for Dynamic Web Sites, 2nd Edition, by Larry Ullman. (Published June 21st, 2005.) In any case, PHP is actually a programming language, unlike HTML, so you could say I started programming for real sometime in 2005. It's now 20 years later...

Programming skill improves in a non-linear way. It's not the case that more time spent at it actually helps. There are conceptual barriers. The best way to overcome those barriers is to be situated where overcoming them is necessary (for school, for work, to complete some project for fun). But I think there are diminishing returns, and at some point anyone's skills tend to plateau. I doubt I'll ever be that much better at debugging in general than I am now, for example. Other skills decay without practice, but can be built up again more rapidly the first time. (Some of my old digital signal processing code doesn't really make sense to me anymore, not because the code operations themselves are confusing, but because the math driving the reasons behind the code was high level and I'm out of practice or have forgotten why such-and-such is needed.)

I used to have the belief that one should learn a new programming language each year -- I still think that's a great way to put yourself in new situations and overcome new obstacles, and thus improve your abilities, but if you actually follow through with that, you'll quickly hit diminishing returns too. Especially if you don't sample from actually different languages. If you started with Python, then in a year learned JavaScript, then in a year had a choice between Ruby or Java, I claim you would learn a lot more with Java, just because it's different enough from the two you've already seen. Just having static types vs. dynamic types is a big difference. (We'll pretend you didn't get into optional typing with Python, or JSDoc or TypeScript with JS.)

These days though, a lot of languages have blurred in what concepts are popular and idiomatic, so there's less of a leap from any one modern language to another assuming you really mastered the one you started with. Java has lambdas, even C++ sort of has them, classes in PHP aren't that weird anymore (they've got a very Java-like OOP system such that it makes more sense to me to just use Java over PHP now if you want to write PHP like that). Some fancy features in more expressive languages sometimes end up getting looked down on and so discouraged -- you might learn a lot of Python or C++ without coming across operator overloading, for instance. This semi-convergence of many ways to express yourself is all another reason for rapidly diminishing returns. There are still some radically different language groups though -- Lisp, an ML, Rust with its borrow checker, an array language like J, Forth... there's still enough out there beyond just the "algol-likes". If you picked a non-algol-like for your language-per-year, you'd learn more than someone who just picked yet another algol-like.

(Of course there is still a bunch of diversity in algol-likes these days, much like there's diversity in Lisp-likes, I group C, C++, Java, Go, Python, JS, Ruby, Perl, and others all in the algol-like family somewhat tongue-in-cheekly because they're all as different from each other as Common Lisp is from Scheme is from Clojure but people like to lump those 3 into Lisp-likes.)

My own path, at least in my memory, was basically PHP-only for my first year, with some MySQL. I went through my book in its entirety and learned to program with it. I still remember struggling to understand the for loop syntax -- and crashing my friend's server when I uploaded a "print 99 bottles of beer song" PHP script when I changed 99 to a big number, creating an effectively infinite loop (it wouldn't terminate anytime soon until the server crashed/forced terminated).

My learning was always recontextualized from the book into features for my website -- I moved stuff to MySQL instead of hard-coded files, I started playing around with more fancy features like regular expressions, started having more form inputs (some even automatically inserting data into a database table) and even made some polls to share with friends... It was fun. Then in 10th grade, 2006, I started AP Computer Science (skipping the first non-AP CS course my school offered since I already knew how to program -- the basics, anyway) and started learning my second language for my second year.

I remember getting stumped on one of the earlier assignments. I couldn't figure it out -- fortunately some in-class help from the teacher guided me along, then it clicked. Many of our assignments used Java Applets to give them a graphical presentation flair (I even made a terrible MS Paint clone), this was one of them. The solution was a simple loop of straight line draws to create the illusion of drawing a curved/warped grid... Actually I still have the code, which I ported to PHP:

<?php



// Step 1. Create a new blank image

$im = imageCreate(630, 980);



// Step 2. Add Content

// begin by defining the colors used in the image

// with imageCreate, the first allocated color becomes the background

$white = imageColorAllocate ($im, 0xFF, 0xFF, 0xFF); 

$other = ImageColorAllocate ($im, 155, 48, 255); 

$black = imageColorAllocate ($im, 0x00, 0x00, 0x00); 

$other2 = imageColorAllocate ($im, 255, 165, 0);

$bla = imageColorAllocate ($im, 38, 29, 48);



imageFilledRectangle($im, 0, 0, 630, 980, $other2);

for ($counter=0; $counter <=80; $counter++) {

imageLine($im, 0, $counter * 980 / 80, ($counter + 1) * 630 / 80, 980, $other);

imageLine($im, $counter * 630 / 80, 0, 630, ($counter + 1) * 980 / 80, $other);

imageLine($im, 630, $counter * 980 / 80, 630 - ($counter + 1) * 630 / 80, 980, $black);

imageLine($im, 630 - $counter * 630 / 80, 0, 0, ($counter + 1) * 980 / 80, $black);

}



// Steps 3-5. Send headers, image data, & destroy image

// refresh won't work for most browsers & not within HTML

// header ('Refresh: 1; URL='.$_SERVER['PHP_SELF']); 

header('Content-type: image/png');

imagePNG ($im); 

imageDestroy ($im); 



/*



int lineCounter = 0;

//declare and initialise counter for lines

while ( lineCounter <= 15 ) {

//start drawing from top-left to lower-right filling lower-left corner 

g.drawLine(0, lineCounter * height / 15, ( lineCounter + 1 ) * width / 15 , height );

// filling top-right corner 

g.drawLine( lineCounter * width / 15, 0, width, ( lineCounter + 1 ) * height / 15 );

//filling lower-right corner

g.drawLine( width, lineCounter * height / 15, width - ( lineCounter + 1 ) * width / 15, height );

//filling top-left corner

g.drawLine( width - lineCounter * width / 15 , 0, 0, ( lineCounter + 1 ) * height / 15 ); 

lineCounter++;

//increment line counter

}

//end while

*/

?>

If you couldn't tell, I didn't believe in indenting my code back then. (The Java code is commented at the bottom, even.) It still works (assuming the gd functions are installed with your PHP installation) and produces this image:



The original assignment was just to make one corner, e.g. the lower right, and with more space between each line, but yeah, it stumped me at first!

I might better remember times when I was somewhat embarrassingly stumped, like this, or when learning the for loop syntax. My memory is less capable of recalling cool features I shipped.

Anyway, needless to say, Java was quite different to PHP. My PHP book was up to date with the newly released PHP 5.0, but it still took the approach of "we don't need classes most of the time", and outside of a tiny example using a PEAR library, the subject wasn't really covered. So the Java course taught me basic OOP as a side effect of learning Java -- not in a great way, but it taught me. I reinforced it on my own when I got a signed copy (for helping to review a chapter or two) of Ullman's PHP 5 Advanced book, which was published in 2007.

The Java course was also a computer science course, after all, not just a how to program course, so I also learned things like data structures in a more formal way rather than just by accident as a by-product of programming (in PHP "arrays" which are basically hash tables get you very far without having to think about things much). Still, I really didn't like Java by the end. But, I was ahead of everyone else early on, so I was encouraged to keep studying further and ended up taking the AP "B" exam instead of the "A" one. It was significantly harder, and required me to learn actual data structures along with Big-O stuff, and I only got a 3.

I continued my self-study through 11th grade. A lot of PHP still, but my teacher did suggest I give Python a go, and I was on Linux by then, so it was easy to try new languages (I even tried Ruby for a while). My teacher had also gotten me in the habit of at least indenting my code by one space or else he'd doc points... so Python's forced indentation wasn't so bad, and I just overall liked it a lot more than PHP or Java anyway. Very little ceremony -- no necessary parens around your if conditions, no braces (Ruby's forced "end" pissed me off and I still think it's ugly), no dollar sign sigils prefixing variable names, no public/private crap or keyword new and just as nicer OOP model (with metaclasses even, though I didn't really see the point). Python had lots of cool features, and maybe best of all was the "REPL" to do things interactively. (Prior to that, my Java code was compiled with javac and run with java or as an applet -- I wouldn't learn about ant until 2010 -- and my PHP code was executed by either uploading it to my server and running it, or later on I had a local webserver so I could at least run it locally, but it was still with the browser.)

So Python was my third language in my third year of programming.

I especially loved learning about PyGame and made some games. This one for a competition. Game programming is still fun. It was also a fun way to try and solidify some of the things I was learning in math and physics courses. Complex numbers work great for 2D vectors.

I landed my first programming job while I was in my last year of HS (2008-2009) and this really upped my programming skills. I learned about a lot of things: version control (SVN), actual JS beyond simple jquery stuff (though we used a lot of jquery we also invested in ExtJS which still powers this blog...) and even more advanced PHP. (I made my own 'micro-framework' with templates based on what my boss had made and what I was seeing from some of the up-and-coming bigger frameworks, and even Python ones like Flask. It still powers this blog too.) More advanced MySQL too. Learned some stuff about the business side... We built some cool stuff. My resume summarizes it to just two bullet points though: "• Built a PayPal processor, package tracking software, and an email auto-responder Wordpress plugin." and "• Built a Twitter service for helping the user grow a similar-to-them network of followers." I think by the end we were looking into Flex (later Flash builder) for an even more dynamic webapp framework, but I left for college so had very little experience with it.

Still, I'd count JavaScript as my fourth language in 4 years, since while the job was full-stack, it was the first time I was really writing a lot of it instead of just a small bit that was still just progressively enhancing a classic non-AJAX experience. Maybe you could also add SQL here as a 5th language, depending on if you count SQL or not, making my pace better than one per year.

In fact, I had been exposed to Linux in my CS course in 2006, and had switched to Linux at home not long after (Ubuntu for a while, then Gentoo in 2007 and on until present day). I wrote a bunch of small Bash scripts then and since, so perhaps you could add Bash as a 6th language after 4 years, but honestly I suck at Bash and have to look a lot of things up over and over so it's hard to say I "know" it. With the advent of good LLMs I'm unlikely to properly learn it ever now. My philosophy was always "if the Bash script is growing big, rewrite it in a real language" anyway. (Like Python, or even Perl.. These days it's Lisp.)

I'm forgetting some other languages that I would say I learned prior to going off to college in 2009. I wanted to take the non-AP CS course, since it was C++, but I didn't think it deserved a full year of my time, so I ended up taking the second half only... and doubled as a sort of pseudo-TA too. I learned some basic C++ (though it was more like C with classes) from that class and on my own. I also bought Larry Ullman's C book and went through that, so I could say I learned C separately. My teacher had encouraged me to try going through MIT's SICP as well -- I made it about half way (maybe one day I'll do the other half) but that's enough to say you know basic Scheme.

So before 2009 was out, I had learned PHP, MySQL, Java, Python, JavaScript, Bash, C, C++, and Scheme. 9 languages in 4 years isn't bad.

I had also briefly played with but didn't really learn (unless stretching things for resume-buffing purposes) Ruby and Perl (enough to not want to do much in either of them -- Perl less so though, I own the camel book even, but Ruby's "end" still annoys me). I played a little bit with x86 assembly but found it to be insane so didn't get far. I even played with a bit of Common Lisp that long ago, but in retrospect not nearly enough and I only saw it as an inferior/uglier Scheme. It wasn't until 2011 that I really started learning a little Lisp with The Land of Lisp book, but even that wasn't enough and it wasn't until around 2016 or so that I had a "holy crap" moment where I realized I really didn't learn Common Lisp at all and rectified that. I sometimes wonder what could have been if I had a Common Lisp mentor around 2008-2009, but perhaps it's for the best I didn't, since now I only want to program in Lisp and if I had that attitude back then I might have missed out on a lot.

I remember doing a forced "science fair" project where my "I just want to do the minimum effort potato-battery project like my friend said he did the other year please" proposal got rejected. I came back with something that could maybe leverage my many programming languages exposure somehow, so I proposed my own dumb language benchmarks game where I wrote the same programs (one was a Mandelbrot fractal generator) in several languages and measured their performance runtime and memory and things about the source code like line count to make comparisons. Somehow I was able to pass all that crap off as "science". I got some free pizza out of it at least.

Oh, there was also a weird "job" I had for a week (then the company dissolved...) where they were going to teach me Delphi. I don't count that for anything, not even exposure since I saw very little code. (I did buy a cheap thick Delphi book, but I think just for my own curiosity and it was at least a year or two later, and I mostly ended up using it as a monitor stand...)

I'm probably forgetting other things, again don't take this post's contents as exhaustive... (Yeah, just remembered while editing, you could count exposure to TI Basic since I wrote or modified some programs for my TI-89 calculator... Probably still some other things.)

Entering college in 2009, I learned PIC8 assembly (rounding out at 10 langs in 4 years) and properly learned C. PIC assembly wasn't bad, it was kind of fun, and our main application was fun too -- writing an autopilot for an RC car. It had to navigate a little obstacle course in the hallway on its own to pass, it was equipped with an IR sensor on the front and we could read its values (figuring out how to interpret them from datasheets, oscilloscopes, and learning about how ADCs work) and control the motor speed and wheel turning amount.

I say here I learned C properly, every relevant detail of the C89 standard, my professor was fantastic. Ullman's book was good but it didn't cover as much (even though it did cover C99 stuff). I had thought I knew C more or less before the class, and what I knew certainly helped, but after the class I knew C much better. Function pointers are cool. (That post is basically after the first semester, so the start of 2010.) At the start of 2010 for my second semester of the Freshman year, we also had to team up and write a terminal graphics game in pure C. We made a shoot em up. I think I learned git on my own around this time, and it beat the pants off subversion, so I forced my team members to use git for the game project instead of a school-provided svn repo.

That summer of 2010 I needed a job again, and found one, which I kept until 2012. I learned so much there, too, and we did a ton of cool stuff as well. I got used to using a bug tracker finally, we used Jira for most of the time (github issues later on) and it was fine. The languages used were Flex (so, ActionScript + MXML) for the front-end and a lot of Java for the back-end. Our main application was a UI front-end for an open source database, but we also contributed to the database too. Its kernel was in C++ but the bulk of it at higher levels was in Java. I learned Java more properly from this job -- code reviews are great, I hadn't had them before. Also more SQL (and sql scripts, sql functions, etc. etc.) -- proper sql2003 standard sql even, not just the non-standard crap I had learned with MySQL -- and I even had my first exposure to Perforce. (I eventually migrated us over from Perforce and SVN to git, preserving history and issue/bug-tracking details and links.) The job also demanded some JavaScript later on, and even some C++ once, and even some PHP once for a client side-project to help fill the company coffers (where I learned to use the Yii framework and lost most of my anti-framework bias at least for simple CRUD apps that just need to get done).

On my own I also got sucked into learning Clojure, and had a lot of fun there for a while. That seeded the way to Common Lisp later, I think. I got to use Clojure a little bit once for work, even, which was sweet. And before that I evaluated Scala but decided Clojure was better. (Still believe that, but the level of Scala playing is probably even less than my Ruby playing.) I went through a functional programming phase with Clojure mainly but I did get some exposure to Haskell and StandardML as counterpoints. I once seriously considered learning OCaml but never really tried.

I also had a semi-fascination with esoteric langs for a while, which exposed me to a bunch of other languages in brief. I'll group those under one "esoteric" branch. I think around the same time I was also exposed to APL and J, but I never progressed to really learning to read any of it.

Through school, after learning C89 properly I learned C++98 properly (more than it deserves) -- my previous "knowledge" of C++ had barely even touched templates, making the knowledge basically "C with classes" level. I learned a bunch of data structures more properly, too. I learned ARM9 assembly and enough x86 assembly to pass a class, but honestly I'll just lump those two and PIC8 into a general "assembly" category, much like the various SQLs. I learned Verilog and programmed some basic stuff on an FPGA. I learned Matlab and got to see some useful features for class-work, though for a project I rewrote some Matlab code to Python (with numpy) for much higher performance. Whenever possible, I opted to do my assignments with some other language than C++ though, which was the school favorite. Usually Python or Clojure. (I bombed a couple courses in part from my Clojure insistence though -- in that I couldn't do the assignments fast enough on top of everything else and work, and I might have had more success if I just swallowed my disgust and did C++.) I did investigate Forth a little bit, almost bought one of GreenArray's weird chips to try and turn into some sort of project for school. I still think it's cool but I didn't really write anything with it so it's hard to claim I learned it even if I could read a lot of it. I had some exposure to GLSL and HLSL (GPU shaders) and OpenCL too but not really much. Actually that reminds me that even in my high school years I had some exposure to OpenGL and Panda3D, but those aren't really languages, just APIs. If I try to describe all of the frameworks, libraries, stacks, tools, and so on over the last 20 years I'll never finish this post. And I've certainly forgotten about so many things, or wouldn't think to mention them anyway. (Would the unix utility "cut" make the cut?)

So spring 2014 rolls around and I graduated. 9 years of programming (10 if you count HTML, which I don't). Besides the 10 languages from the first 4 years (plus exposure to say 3 more), my next 5 years saw another 4 languages (ActionScript, Verilog, Matlab, Clojure) learned and some level of "exposure" to many more (let's say 5 -- shader and GPU languages, Scala, Haskell, MLs, Forth). 14 learned total, plus 8 more exposed. Not bad I guess, there's a lot of variety in there. I was also "aware" of many more languages, even if I hadn't been properly "exposed" to them or written code in them. (Julia, R, J, APL, C#, esolangs... I'm probably forgetting some.) By this point, very little could surprise me in the language space. By that I think I mean I had neared the plateau of programming concepts -- learning some of those other languages would have taught me new things and new ways of thinking about programming, but not in a revolutionary way that will make me quite a bit better going forward no matter the language. Those revolutionary moments are done earlier on, when you learn your second and third language, a lot after that is pretty small.

(In retrospect Rust was surprising in that you can have memory safety without a GC, but that's a small concept in the grand scheme of things. Similarly with Common Lisp's concept of embedding the compiler and disassembler into the runtime and allowing for function-scoped type and optimization declarations. Similarly small (I predict) would be the impact of having yet another different way of looking at things if I mastered an array language like J.)

After graduation, because I had a job doing real software development for most of college, I sought out not-entry-level roles. I tried selling myself as a "Senior". Ultimately I wasn't hired at that level, and was hired under the "Software Engineer in Test" label even, but later I found that was largely to do with politics (i.e. the team manager could hire one "senior" or two "sdets"). But I asked for $110k/yr and they gave it to me, so I didn't care what they called me. (My last jobs were considerably less well-paid. Think $40k or less, even if it was full time.) After a year of that (and 7 managers as I had unknowingly joined a very volatile team and overarching company organization) I was promoted to "Senior Software Engineer". 3 years of that led to another promotion to "Lead Software Engineer". The next would have been "Principle" -- Lead/Principle is somewhat equivalent to Staff at other places. But I quit in 2020 and have been "retired" since.

My job was entirely Java (and Perforce again... though some git made its way in later on for things, particularly front-end things) and some JS (I was always full-stack but BigCo separates things more, so I touched JS a lot less often). The JS was also usually in the context of one of our bespoke front-end frameworks. Sometimes some PLSQL since we used Oracle for the DB. I snuck in a little CoffeeScript (which is dead as vanilla JS caught up) and Python and Common Lisp towards the end for some small tools and slack bot integrations... but that's it. I was exposed to a tiny bit of Objective-C (which now that I think about it, I did also get some earlier exposure in HS since my teacher mentioned it as an alternative to C++, and he even had a NeXTSTEP cube).

Still, despite not learning new languages really, I still learned a lot about programming (a lot of Big Java things make more sense in Big Java applications, I even finally used Eclipse full time and started appreciating some things from Big IDEs) and a lot about other things, such as surviving life in BigCo and even appreciating some things. I did some stuff I can be happy with, and I can say I've positively impacted tens of thousands of other companies. That's enough good put into the world for a lifetime, probably, so if I get run over tomorrow it's not like I've left the world as a net-negative even if I could be presently working towards being more positive...

I did consider leaving for a Clojure company at one point.. but as I was ramping back up on Clojure, I had that "huh" moment where I realized I didn't know Common Lisp at all. Then I learned Common Lisp, and Clojure's limitations felt as bad as Java's or Python's. (And Java with JRebel actually gets closer to Lisp than Python does.) I made a little headway into getting ABCL integrated with the main Java codebase but I had the sense I'd be fighting an impossible battle getting it accepted so I didn't try very hard, and I quit anyway before things could get really interesting. (My planned selling point was to get it accepted for test-code only, and to show how Lisp's interactivity and restarts system would make our webdriver tests much more pleasant to write and debug.)

By the end of my six years of my last job, you could arguably say I only learned one new language, Common Lisp, bringing the total of "learned" languages to 15 in 15 years, if I'm counting right (and I am grouping some like the SQLs). Sure, I was exposed to a few more in those last 6 years (Go (though technically first exposed in 2011, I've hated it the entire time and minimize my interactions with it more than C++), Swift, Kotlin, Obj-C, Rust, Nim and many other pretenders to the throne of C/C++ for low-level code (and again now that I think about it I was first exposed to D in high school too along with Obj-C...)) but none of those were interesting, especially compared to what I had seen before, and especially compared to Lisp.

Over the 4 years of programming from starting in 2005 to the end of 2009 I think the bulk of impact of programming languages on my skills and way of thinking about programming had already occurred. By 2014 I had 9 years, the biggest change was probably going full-in on functional programming for a while, but still overall the impact of language was fairly small. And by 2020 I had 15 years but the impact of new programming language learning was almost zero, my skill improvements came from refinement rather than novelty. Now that it's 2025, I've again only refined, and haven't bothered teaching myself any new languages, because I have Lisp. (Ok maybe you might count GDScript since I did get into Godot... I don't really believe I won't ever learn more languages again.)

Learning Common Lisp properly was kind of a downer for my motivation in general since I stopped wanting to program in anything else, or even giving anything else a real chance, and after quitting my job in late 2020 I have mostly successfully avoided doing so. Not that I've programmed all that much since 2020 on my own, but what there is, it's mostly Lisp.

Circling back to my belief that programming skill and increasing it is non-linear, I see distinct "phases" where I leveled up. The beginning period of self-teaching and doing (or trying to do) various web site stuff (I had a partial implementation of a forum once even), initial formal education with my AP CS class, my first programming job, the first year or two of college (later years I learned less -- the database course e.g. was a joke, easy A), my second programming job, and my third programming job's first few years.

I'd say that sometime in 2016 was when my skills "peaked". Sure, I was just barely getting into Lisp, so there's all my Lisp knowledge since then, but that's not so skill heavy. My skills haven't declined since then, either, in fact they're probably slightly better, but I don't feel like there's been any phase change between then and now, no drastic change like I can tell there were in the previous phases. I also wouldn't expect merely learning a new language to move that either, my best hope would be to program in a new domain. Again, language-wise, I already had learned over half of the ones I have ever learned within the first 4 years. Perhaps my ability was closer to peaking even way back then. In fact I still remember my youthful arrogance around the time of 2008 and 2009, thinking I could program anything, even an OS kernel, if I wanted to! And had enough time! In PHP even!

...And you know what, that's almost correct. It was wrong, but not horribly so. 3-4 years is really all you need to see the possibilities and limits of your skill -- even if it's a bit exaggerated. Typically if you've advanced beyond the beginner stage and you think you can do it, you probably can, with enough sustained effort. I know, looking back, I actually couldn't have at the time -- not on my own, anyway -- and not in PHP -- but the base skills were there even if many other requirements were not. In college some years later I did make an RTOS kernel. By then my base programming skills had noticeably improved but not a gigantic amount, I think instead I was better at other things like having more sustained effort, being more willing to use (or even learn) the right language for the job (so not PHP), and being able to break things down more into increments. And the largest phase differences I think were from my jobs more so than from my schooling. School isn't very good at teaching you to work in increments -- even a lot of jobs aren't that good, arguably it wasn't until my 2014 job that I got good at that. (Not to say that increments are always the right approach -- sometimes they're not, something that advocates tend to forget, similar to TDD zealots.)

This also tracks with my observation that people at my college who had their first programming experience with the first freshman courses, and persisted to the end, were after 4 or 5 years pretty comparable to me skill-wise even with my 9-10 years experience that included some professional paid work. Of course such skills need refinement -- my own 9-10 still benefited from further refinement too. Having even more skilled hands to guide is important. It's sometimes hard to see when you're the one being guided but if you try guiding someone else you can see a difference in how your efforts can keep them on track, directed, you can reign in their hubris, point out gaps they can work on... this can really only be done in an employed context. Perhaps some voluntary open source collaboration can substitute, or direct mentoring, but not for everything.

This isn't to say that you'll stop learning or refining, and the cumulative refining of skills over several years can perhaps be close to the big phase shift or skill jump that happens earlier on when learning and applying totally new concepts for the first time in the form of second or third programming languages. I certainly have and can look forward to learning a lot more about programming, even with my current experience. There's never an end. But I don't really expect that to translate to a big skill increase beyond my current level, or the level I had in 2016 (which wasn't that much higher than in 2009). Take e.g. Norvig as an example, or Kernighan, or Carmack for a super easy one, I just don't really ever expect to match them. Some might say it's because they have a "je ne sais quoi", but to me I just think their skill level is that much higher and in aspects that I can only approach but probably not exceed. (Perhaps I can win on some aspects, but not the most important ones.) At best I can hope to be able to do anything they can when it comes to programming, functionally, except it will take me a lot longer (if I even finish) and it will look a lot less elegant and I won't be able to explain it as well.

Not being employed for the last 5 years has slowed my programming output considerably. I have no real excuse, I have all the time in the world now to do whatever, but that also means that sustained effort on some programming tasks that are only for fun can often lose out to other things I find fun.

Still, I don't plan to ever stop programming. Even with LLMs, they can do a lot of things for me automatically and that's fun, but it's still not the same if I don't do some of my own coding. Even when they get good enough to surpass doing it manually, I'll still want to code manually much of the time. Programmers who retire into management (or "parallel track" super-distinguished-principle-architect-or-engineering-director-whatever titles) and totally stop their programming output (vs. just reducing it considerably, or at least relegating it to personal projects outside work) give me the ick.

Here's to another 20 years. If we're all still alive.

---

Posted on 2025-11-10 by Jach

Tags: learning, personal, programming

Permalink: https://www.thejach.com/view/id/450

Trackback URL: https://www.thejach.com/view/2025/11/20_years_of_programming

Back to the top