Let's Talk About Programming Languages: A Prose

Foreword

Following on from the previous fictional dialogue chapter, this time I have asked AI to present my understanding of programming languages in the style of a famous essayist. Can you guess who it is? His characteristics are: combining the multiple identities of writer, racing driver, and director, known for his sharp, incisive commentary on current affairs and his uniquely humorous style.

Link to the Wuxia Chapter: Let's Talk About Programming Languages: The Wuxia Chapter

Link to the Novel Dialogue Chapter: Let's Talk About Programming Languages: The Novel Dialogue Edition

"On the Code We've Written, and the Pointers We Can Never Return To"

The world always loves a good categorisation. Just as they enjoy sorting people into winners and losers, and cars into supercars and shopping trolleys, the programming language circle has similarly been carved up into proper classes.

Today, Allow me to have a chat about these languages. This is, in truth, a rather brutal affair. Because talking about languages is like talking about the girls we used to love, or those rubbish old bangers we used to drive back in the day. Behind every single language lies the compromise of an era, and our restless, misplaced youth.

Let us commence from the most fundamental of desires.

The Cost of Speed and Passion: Compiled vs Interpreted

A lot of blokes ask me, what on earth is the difference between an Interpreted language and a Compiled language?

That is quite like asking me the difference between taking the bus and driving a proper racing car.

Python is that bus. You hop on, drop your coin in the slot (write some code), and the driver (the interpreter) ferries you to your destination at a leisurely, meandering pace. You don't need to know how the engine works, nor do you need to worry if the tyres are properly inflated. You could even sit in the back having a hotpot and a sing-song (dynamic typing, write as you please). Its brilliance lies in its sheer comfort, its unhurried nature, and that solid, weighty feeling you get when dealing with Big Data and AI: "I might be slow, but by Jove, I can haul a lot of luggage." But if you try taking this bus out onto a track day at the Nürburgring, people will simply think you've gone mad. Because it's got a GIL (Global Interpreter Lock), which is rather like a strict rule on the bus that only one person is allowed to step off at a time. Absolutely maddening.

And then there's C++. It is that Formula One car with no air conditioning, no ABS, and a seatbelt that might just snap at any moment.

In the realm of AAA gaming titles, such as Black Myth: Wukong, why do they insist on using C++? Why not use those trendy new languages? Because in that world, being a single millisecond late is an absolute sin. C++ allows you to shove your hands straight into the gearbox to fiddle with the cogs (manual memory management). It has no Garbage Collection; there is no nanny following behind to wipe your backside. You new up an object, and you are bloody well responsible for deleteing it. If you forget, the resulting memory leak is as catastrophic as a multi-car pile-up on the motorway.

This sort of language is strictly reserved for lunatics and geniuses. It is tremendously dangerous, yet intoxicatingly fast.

The Middle-Class Compromise: C# and .NET

Then we arrive at C#, my old stomping ground.

If C++ is a death-defying racing driver on the run, C# is a smartly dressed, middle-class professional driving a Tesla.

It is still remarkably quick, boasting a mighty engine (JIT compilation), but it has been fitted with every single airbag available. It comes with garbage collection, strong typing, and some genuinely lovely syntactic sugar. Microsoft has essentially built you a greenhouse, patting you on the back and saying, "Look here, don't fuss about the dirty, grubby underlying mechanics; just focus on your business logic, there's a good chap."

It is a remarkably mature choice. When we were young, we all wanted to crash a C++ car into a wall, thinking that was proper rock and roll; but as we've got older (though we strictly refuse to admit it), we've found that having a self-driving, luxuriously appointed C# parked in the driveway is actually rather brilliant. It's decent, highly efficient, and perfectly suited for building those massive, complex, bread-and-butter enterprise applications that pay the mortgage.

The Front-End Fancy Dress Party: JavaScript and TypeScript

Now, let us turn to the front end. What a delightfully bizarre place this is.

JavaScript (JS) is rather like a phenomenally gifted young hooligan from a council estate. It had a terribly humble upbringing (slapped together in a mere ten days back in the day), has absolutely no manners (weak typing), and can shapeshift at a moment's notice. You think it's a number, and the very next second, it's turned into a string. It used to just crash about causing havoc in the browser, until Ryan Dahl came along and handed it a shotgun (Node.js). Suddenly, it was able to kick the doors down and storm the server side.

The emergence of Node.js was an accident, yet equally a miracle. It essentially proved that a single thread, provided its hands move fast enough (the Event Loop), can juggle thousands of concurrent tasks. It is hopelessly rubbish at sitting down to do maths homework (CPU-intensive tasks), but it is absolutely top-drawer at delivering parcels (I/O-intensive tasks).

However, even hooligans must eventually grow up.

Thus, we were given TypeScript (TS).

TypeScript is simply JavaScript stuffed into a tailored suit. It is Anders Hejlsberg's (yes, the very father of C#) grand attempt to civilise the wild west of the front-end world. It slapped a set of much-needed manners (a type system) onto that lawless beast of a language.

It all looks terribly splendid, but at its core, it is one massive fancy dress party. Because the browser hasn't got a single clue how to read TypeScript. You can write your code looking ever so posh during development, but once it is transpiled, it rips off the suit and is back to being that bare-chested JavaScript yob.

Yet, we all desperately need that suit. Once a project grows beyond a certain size, without that discipline, we would all go utterly mad amidst the chaos of variable types. That is simply the price of growing up; we traded absolute freedom for a bit of health and safety.

The Blokes Fixing Cars in the Shadows: Bash and PowerShell

Finally, we have those characters who are rarely spoken of in polite company.

Bash is that grumpy, oil-stained, old-school mechanic. He lives in the damp basement of Linux and never utters more than three syllables at a time. If you want him to fix something, you have to mutter a string of bizarre incantations (awk, sed, grep). He absolutely detests graphical interfaces and thinks they are toys for infants. If you want to survive on a server, you must learn to read his moods.

PowerShell, on the other hand, is the modern engineer sent down by Microsoft head office. He wanders about with a tablet, going on endlessly about Object-Oriented principles. He tries to tell Bash, "I say, old bean, could we perhaps be a bit more elegant? Instead of tossing around a load of messy strings, how about we pass around objects?"

Bash usually responds by spitting on the floor and carrying on piping his strings.

A Final Word

Truth be told, when you line up all these languages together, you realise it's nothing short of a microcosm of society.

C++ is the solitary hero, shouldering the absolute limits of performance; Python is the friendly, accessible philosopher, bridging the way to an AI future; JavaScript is the agile rogue, occupying every single browser window on earth; whilst C# is the dependable builder, holding up a vast, sprawling empire.

We people who write code are exactly like racing drivers. We swap into different motors for different tracks. Sometimes it's for sheer speed, sometimes it's for stability, and sometimes it's simply because the boss only gave us the keys to that particular car.

In this world, there is no such thing as the 'best' language, only the most suitable tool for the journey at hand.

As long as your code is still running, and as long as that little mouse cursor is still blinking, you are still that bright-eyed lad. No matter which language you use, when you smash that Enter key late at night and see the green "Build Succeeded" light up on your screen, that trivial little burst of joy is utterly universal.

Right, that's that then. I'm off to write some bloody bugs.

A Three-Way Stand-Off: Language Traits and Domains

The Ultimate Comparison: Development vs Scripting Languages

• first edition time: 2026-02-27
  
• last edit time: 2026-02-27