Rosetta Code — unlocking the mysteries of the programming languages that power our world

As a full-stack developer, one of the most valuable skills is being able to choose the right tool for the job. And by tools, I mostly mean programming languages. Each language has its own unique features, strengths, weaknesses, and philosophies that make it more or less suitable for different problems.

Over my career, I‘ve worked with dozens of programming languages, from the mainstream like Java, Python, and JavaScript, to more specialized ones like R, Matlab, and Erlang, to domain-specific languages for stats, styling, and configuration. Learning the basics of a new language is usually not too difficult. The bigger challenge is understanding its ecosystem, design patterns, and best practices – the deeper aspects of its personality.

One of the best resources I‘ve found for getting a taste of different language personalities is Rosetta Code. This community-driven site collects solutions to hundreds of programming tasks in over 800 languages. It‘s a treasure trove for comparing how the same problem is approached in wildly different ways by different languages.

Want to see the classic binary search algorithm implemented in everything from COBOL to Haskell to AppleScript? Rosetta Code has you covered. Curious about the infamous "99 Bottles of Beer" song in Malbolge or Whitespace? Look no further. It even has "Hello World" examples for dead languages like GEORGE and Babbage.

Credit: Monoclecat, CC BY-SA 4.0

Beyond being endlessly entertaining for programming language geeks, Rosetta Code provides real insight into the world of programming language design and evolution. Patterns quickly emerge showing languages borrowing features, improving on older languages, and branching off into new philosophies.

The Cambrian Explosion of Programming Languages

Looking at the history of programming languages, we can see a sort of "Cambrian Explosion" of language development starting from the 1950s to today. The first high-level languages like Fortran, Lisp, Cobol, and Basic established fundamental concepts like variables, loops, functions, and structured programming.

In the 1960-70s, languages like Simula, Smalltalk, C, Pascal, and Prolog explored concepts like object-oriented programming, dynamic typing, pointers, and logic programming. The 1980-90s saw an explosion of new languages building on these ideas, from practical object-oriented languages like C++, Objective-C, Perl, Python, and Java, to functional languages like ML, Haskell, and Erlang.

Since 2000, we‘ve seen a Cambrian explosion of new languages, many building on features from the 1980-90s but with modern twists. C# took the best of Java and C++. Scala and F# brought functional programming to the JVM and .NET. Clojure brought Lisp to the JVM. Ruby and Groovy powered new web frameworks. Lua, JavaScript, and Python became embeddable scripting languages. Go and Rust powered systems programming. The list goes on.

Credit: O‘Reilly

The Power Law of Programming Language Popularity

With all these languages, you might think they would be relatively evenly distributed in popularity. But like most things in life and computing, the distribution of language popularity follows a power law.

Data from the PYPL PopularitY of Programming Language index shows the top 10 languages (Python, Java, JavaScript, C#, PHP, C/C++, R, Objective-C, Swift, and Matlab) account for over 70% of all language tutorial searches in Google.

Credit: PYPL Index, August 2020

This phenomenon of a few dominant languages with a long tail of less popular ones has been remarkably stable over time. As languages gain a critical mass of users and ecosystems of tools and libraries, it creates a positive feedback loop (often called a "network effect") that cements their popularity.

Of course, the top languages do slowly change over the decades. Upstarts occasionally disrupt the status quo. Incumbents fall out of favor as their problem domains become less relevant. Students and educators flock to newer teaching languages. But overall, language popularity is a slow-moving but high-stakes game.

Standing on the Shoulders of Giants

So are all these hundreds of less popular languages failures? Not at all! In fact, they play a crucial role in advancing the art of programming language design.

The history of programming languages is one of continual borrowing, improvement, and cross-pollination of ideas. Nearly every language builds off features pioneered by others, remixing them in unique ways.

C++ took C‘s efficient and portable low-level programming and added object-oriented features and generic programming. Java and later C# drew from C++‘s OOP model but added managed memory and rich standard libraries for application programming. Objective-C extended C with Smalltalk-style messaging. Python and Ruby adopted Perl‘s powerful string processing and built-in regex. Scala and Kotlin compile to Java bytecode while adding functional programming and modern conveniences.

Even many esoteric programming languages, which are not meant for practical software development, have pushed the boundaries of language design in thought-provoking ways. Haskell‘s purely functional, lazy evaluation model has influenced many languages. Erlang‘s actor-model concurrency is the basis for Scala‘s Akka and other distributed computing tools. APL‘s matrix-oriented paradigm is still used in data science. Esolangs like Piet and Shakespeare challenge our very notions of what it means to code.

Rosetta Code‘s side-by-side examples are a perfect place to see this remixing and evolution of language features in action. It‘s not about any one language being the best. It‘s that the best ideas tend to get borrowed and expanded on, like building a cathedral one improvement at a time.

The Evolving Art of Language Design

At the bleeding edge, programming language development is far from a solved problem. Just in the last decade, several notable new languages have emerged that push the boundaries of performance, safety, and ergonomics for specialized domains.

Mozilla‘s Rust, first released in 2010, is a systems language focused on memory safety and concurrency without garbage collection. It features an innovative ownership model, move semantics, and compile-time memory checking to prevent entire classes of bugs. Microsoft‘s TypeScript, released in 2012, is a typed superset of JavaScript that compiles to plain JS for any browser or JS engine. It powers many huge software projects today.

Google‘s Go, first released in 2012 and reaching version 1.0 in 2015, is a statically typed language aimed at simplicity, speed, safety, and modern concurrency patterns. It‘s become popular for cloud and network services. JetBrains‘ Kotlin, which reached 1.0 in 2016, is a drop-in replacement for Java with null safety, data classes, and functional features. In 2019, Google made Kotlin its preferred language for Android development.

Apple‘s Swift, first released in 2014, has rapidly displaced Objective-C for MacOS and iOS programming. It combines the best ideas from many languages with an emphasis on simplicity, safety, and ease of development. Julia, which reached 1.0 in 2018, is a dynamic language designed for high-performance scientific and numerical computing. It aims to match the ease of Python with the speed of C.

What‘s striking about these newer languages is how they‘ve focused on being practical and production-ready for specialized domains. They‘re less about revolutionary new paradigms, and more about combining the best tried-and-true features from other languages with a laser focus on solving real problems.

Conclusion: Language as a Living Art

Programming languages are one of the most powerful tools humanity has ever created. They‘ve reshaped every field of human endeavor, from science to business to art. It‘s not an exaggeration to say they power the modern world.

But learning a programming language, or choosing one for a project, is about much more than just features and benchmarks. It‘s about the history and evolution of ideas, the community and ecosystem around it, and most importantly, the human factors of using it.

Rosetta Code provides a unique window into this vibrant, complex world of programming languages. It demonstrates the sheer diversity of ways the same problem can be approached. It reveals the evolutionary threads between languages, as features get borrowed and remixed over time. And it showcases the unbound creativity of developers to mold languages for any task imaginable.

In the end, the real value of Rosetta Code is not in finding the "best" way to solve a problem. It‘s in broadening our understanding of the tools at our disposal, and perhaps sparking some inspiration for how we can contribute our own ideas to the art of language design.

So whether you‘re a grizzled pro or just learning to code, I encourage you to spend some time browsing Rosetta Code. Follow the threads of language evolution. Marvel at the diverse approaches. And most of all, have fun appreciating the living, breathing art of programming languages.