Much more is written about how easy or hard some technology is to learn than about how hard it is to relearn. Maybe this is because people are more eager to write about something while the excitement or frustration of their first encounter is fresh.
Advocates of difficult-to-learn technologies say that tools should be optimized for experienced users, that ease of learning is over-rated because you’re only learn a tool once and use it for much longer. That makes sense if you use a tool continuously. If you use a tool occasionally, however, you might learn it once and relearn it many times.
The ease of relearning a technology should be emphasized more. As you’re learning a programming language, for example, it may be difficult to imagine forgetting it and needing to relearn it down the road. But you might ask yourself
If I put this down for a couple years and then have to come back to it, what language would I wish I’d written it in?
A while back I debated relearning Perl for the kind of text munging projects that Perl was designed for. But not only would I have to relearn Perl once, I’d have to relearn it every time I revisit the code. Perl does not stick in my head without constant use. Awk, on the other hand, is small and simple, and has a lot of the benefits of Perl. You can learn the basics of Awk in a day, and so if you have to, you can relearn it in a day.
Something easy to learn is also easy to relearn.
However, the converse isn’t necessarily true. Some things may be hard to learn but easy to pick back up. For example, I found LaTeX hard to learn but easy to relearn after not using it for several years. A lot of other tools seem almost as hard to relearn every time I pick them up. I think part of what made LaTeX easy to pick back up was its internal consistency. It’s a little quirky, but it has conceptual integrity.
Conceptual integrity
I’ve used Mathematica off and on ever since it came out. Sometimes I’d go for years without using it, but it has always been easy to pick back up. Mathematica is easy to return to because its syntax is consistent and predictable. Mathematica has conceptual integrity. I find R much harder to use because the inconsistent syntax fades from my memory between uses.
Conceptual integrity comes from strong leadership, even a “benevolent dictator.” Donald Knuth shaped TeX and Stephen Wolfram shaped Mathematica. R has been more of an egalitarian effort, and it shows.
The “Tidyverse” of libraries on top of R is more consistent than the base language, due to the Hadley Wickham doing so much of the work himself. In fact, the Tidyverse was initially called the “Hadleyverse,” though Hadley didn’t like that name.
I just ran into this the last two weeks. About 10 years ago I finished up a project that was mostly C++ for the high-performance code, but everything else was Perl, Gnuplot, and Mathematica. I hadn’t touched those three in nearly a decade, but I got a new project that had the same pattern where hooking together those three would be the easiest workflow again. I spent about a day feeling clumsy, but after that everything came back and weird idioms and commands that I hadn’t thought of in ten years just started flowing from my fingers. It was strange how quickly everything came back – even the Perl.
I tend to rarely like my previous work, seeing the flaws more than its successes, and by association, even the tools I used. So when I do need to revisit a prior problem domain or am reconsidering a prior tool set, I typically first marshal my buzzwords and carefully search for how similar things are being done today.
It is so refreshing to use tools that avoid verbosity and enhance clarity, all while encouraging new ways of thinking stimulated by the new environment.
Still, there’s one tool that’s been my go-to for decades: Python. It’s where I explore problems before “getting serious” about them (Python has packages for, well, nearly everything/anything). It’s where my over-evolved Bash scripts go when they need to “grow up” (typically when hacking-in multi-dimensional arrays).
The versatility of Python is part of what first attracted me to this blog: Posts often contain Python snippets that greatly amplify the text, and provide an open door for exploration and experimentation.
This is one thing I always loved about Mathematica – that internal consistency. Mathematica is so large that you’re often relearning things in the form of using a function that you haven’t used for a long time, but the same general principles always hold, so it’s easy to have a quick glance at the function documentation and be off to the races. It made me practically evangelical about Mathematica.
But… I have *never* been able to get comfortable with the graph functionality they introduced in later versions (I think it came in around version 8 or so). They seem to have completely abandoned all the regular principles and I can’t figure out how to do even really basic things with graphs without a lot of effort, and I have to relearn them with nearly as much effort every single time I come back to them. It sticks out, not like a sore thumb, but like a thumb that has been run through industrial chipper/shredder machinery.