Learning New Programming Languages

I would­n’t brand your­self as a pro­gram­mer who knows x lan­guage or y frame­work. This mind­set lim­its your op­por­tu­ni­ties. Rather, it’s bet­ter to be able to learn new things on the fly—as “technology is al­ways chang­ing”. Even in my short life­time, I can come up with tech that has bit the dust. Anyone still us­ing Adobe Flash Player?

At the same time, it’s hard to change. If you’ve been cod­ing in the same lan­guage for years, the new thing prob­a­bly feels tran­sient. The re­turn on in­vest­ment is hard to cal­cu­late—what will you get out of it? After all, at some level, most pro­gram­ming lan­guages kinda do the same thing.

Well, a sim­ple an­swer is that it makes you more em­ploy­able. Over time, com­pa­nies are tran­si­tion­ing to newer tech­nolo­gies. These tech­nolo­gies may not be bet­ter per say—but their pop­u­lar­ity makes it eas­ier to find tu­to­ri­als, pack­ages, etc.

Also, once you learn a pro­gram­ming lan­guage or two, it’s easy to pick up more. Granted, it’s smoother to jump be­tween lan­guages from the same par­a­digm—or in­flu­enced from the same pre­de­ces­sor. To a point, this is why I en­cour­age peo­ple to mas­ter the fun­da­men­tals. They travel be­tween lan­guages.

Why?

Of course, there are bet­ter rea­sons to learn new lan­guages than to stuff your re­sume with buzz­words. You can be­come a bet­ter, more well-rounded de­vel­oper.

Some lan­guages are bet­ter at some things than oth­ers. Thus, by know­ing more lan­guages, you’re able more ef­fec­tively judge which one is bet­ter for a given task. Like, I would­n’t use Erlang to do heavy pro­cess­ing with strings, or Python to per­form CPU in­ten­sive cal­cu­la­tions.

In a way, pack­ages are more im­por­tant than the lan­guage. Nowadays, com­put­ers are so com­pli­cated that no one per­son can un­der­stand the sys­tem front to back. And there’s no point to be­ing com­puter-om­ni­scient. We build soft­ware on top of ab­strac­tions—as­sem­bling the prod­uct piece by piece.

Thus, to­day, the lan­guage’s ecosys­tem mat­ters more than its beauty.^[1] Arguably, they are be­com­ing a glue layer for com­bin­ing pack­ages. Without qual­ity, up-to-date pack­ages, the lan­guage is ba­si­cally dead for main­stream use. Consequently, we just aren’t aware of all the code in the sys­tem—that’s fine. Hopefully, some­one else is main­tain­ing that stuff.

Plus, the fu­ture is un­cer­tain. Over the last few weeks, I’ve watched a hand­ful of videos demon­strat­ing the ca­pa­bil­i­ties of GTP-3. Sure, they’re prob­a­bly cherry pick­ing the best ex­am­ples, but it’s still im­pres­sive. Even if the fu­ture still leaves room for the cre­ativ­ity of hu­man pro­gram­mers, we will likely have to shift with the times. AI pow­ered tool­ing is com­ing. I doubt it will re­place the pro­fes­sion any­time soon—real soft­ware is much too com­plex. Yet, we should re­main aware.^[2]

Some Tips

Ok, now that I’ve mo­ti­vated you to learn things, let’s go through some tips.

An ob­vi­ous first step would be to find of­fi­cial doc­u­men­ta­tion for the lan­guage in ques­tion. This doc­u­men­ta­tion will of­ten be found on the lan­guage’s of­fi­cial web­site. While usu­ally good ref­er­ence ma­te­r­ial, the doc­u­men­ta­tion is not al­ways use­ful as learn­ing ma­te­r­ial. Don’t get stuck in the trap of read­ing and try­ing to mem­o­rize lan­guage con­structs. You need to take ac­tion—I like to im­ple­ment small pro­jects, data struc­tures, or some al­go­rithm.

Importantly, the doc­u­men­ta­tion will hope­fully list out the stan­dard li­brary. For me, the hard­est parts of a lan­guage to learn are its li­braries and it’s id­ioms. Some pro­gram­ming lan­guages en­cour­age par­tic­u­lar ap­proaches to solv­ing a prob­lem—you’ll pick up the nu­ances with prac­tice. To help with this, con­sider glanc­ing through other peo­ple’s code. You can get a feel for what to strive for by read­ing well-writ­ten code.

On that note, “Google’s your friend bruh.” There are a mil­lion blogs, tu­to­ri­als, videos, open source pro­jects on the Internet. For those more old school, books ex­ist. Just pick some­thing and stick with it. Implement that tu­to­r­ial and try to change the code.

Also, make sure you’re look­ing at the doc­u­men­ta­tion for the cor­rect ver­sion. The docs for ver­sion two in­stead of three are—well—not help­ful.