I love understanding why things are the way they are. A few weeks ago, I came across one of those talks that bring a bit of history and explanations to try to answer, among other questions: Why are current programming languages like Python, JavaScript, Java, C# so popular? In this article, I have made a summary to share. In short, it is a multimodal effect; let's look at each of these briefly.

They were built for or associated with a revolutionary application/framework

Some languages become popular because they are associated with applications that solve a significant problem and/or meet a great demand. Therefore, the trajectory of these applications and these applications/frameworks becomes linked to the language because it offers the fastest, easiest, or, at the time, the only viable way to use the desired application. It's not that the language is inherently superior or more attractive, but rather that it is the gateway to something users really need or want.

Examples of the above are:

• VisiCalc for the Apple II
• Ruby on Rails for Ruby
• PHP for dynamic HTML, WordPress, and Drupal
• C for systems programming

They have exclusivity on a platform

A language becomes the preferred or often the only viable way to develop in a very large and dominant software or hardware ecosystem. The sheer size of the platform itself is enough to push the language to the top, regardless of its intrinsic design (whether functional, imperative, or object-oriented).

We can see this manifested with

• Objective-C and Swift for Apple; the sheer scale of the Apple platform ensures their popularity
• JavaScript for the web. It became the de facto standard.
• C# for Microsoft Windows. Its success was due to the exclusivity of Microsoft tools on its platform.

They Offer Rapid Adoption and/or Reuse of Existing Code

Some languages have been created with the aim of attracting or offering communities an alternative to their current language in a way that is easy and/or allows them to avoid rewriting their projects. The main argument is that migrating will bring great benefits. In summary, these languages try to leverage developers' familiarity (reducing the learning curve) and lower the barriers to entry.

Let's see how some successful languages have used this strategy:

• CoffeeScript: One of the first languages to thrive with this philosophy.

• Its slogan was "it's just JavaScript".
• It promised that if you were already a JavaScript developer, you could learn it in about half an hour.
• It offered scripts to automatically convert your existing JavaScript code to CoffeeScript, drastically minimizing the migration effort and reinforcing the idea that it was "just" JavaScript.
• This was enough to make it the 11th most popular language on GitHub at its peak.

• TypeScript: A strong example of this strategy.

• It is a strict superset of JavaScript, meaning that valid JavaScript code is, by definition, also valid TypeScript code.
• Migration can be as simple as renaming a file from .js to .ts, and "it is supposed to just work". From there, developers can incrementally add TypeScript features.
• It offers benefits (like static typing) with a minimal perceived cost ("you just have to rename the file"), which has led many people to adopt it.

• C++: The first major success of this strategy.

• It was an "almost superset" of C.
• It allowed C programmers to take their .c files, rename them to .cpp, and start accessing the additional benefits of C++. This facilitated a successful transition and adoption.

• Kotlin: A modern example that, although it is a "substantially different" language from Java, capitalizes on the same idea.

• It emphasizes its "100% interoperability with existing Java codebases" and the availability of scripts to convert Java to Kotlin.
• This reduces the migration effort and the perceived risk for companies and developers with large Java codebases, contributing to its great success.

Marketing

There are languages that have had massive monetary investments behind them, such as Java, where Sun Microsystems invested 500 million dollars in a new marketing campaign just for Java. This resulted in omnipresence across various media, making it a very recognizable element among developers.

On the other hand, JavaScript is the result of riding the wave of Java's popularity. Originally conceived as a functional Lisp based on Scheme, it was forced by Mozilla to adopt a syntax and object-oriented approach similar to Java. Even its name contains "Java"...

Other Secondary Factors

• Job Market Developers are hesitant to learn a language if there are no jobs available that require it, and employers are hesitant to adopt a language if they cannot find developers for it. This reinforces the popularity of languages that are already dominant, as the large volume of existing jobs validates learning them, and the supply of developers reinforces their use by companies.

• Community The community surrounding a language can be a major asset or a liability. A welcoming and collaborative community can attract and retain developers. Additionally, the resources generated by the community are important. A good example is Python, which has tools for almost every use case thanks to its community, especially in the field of artificial intelligence.

• Performance This is considered a secondary concern that influences more the domains of use of a language than its overall popularity. For certain applications, such as systems programming (operating systems, low-level utilities), it is critical to have control over memory, which favors languages like C, C++, and more recently, Rust. However, for many domains, absolute performance is not the decisive factor. Python, for example, is a "perfectly acceptable" language for backend servers, even if it is not the fastest, because performance is often limited by external factors such as the network or the database.

Conclusions

The popularity of programming languages does not depend exclusively on their technical features or inherent superiority, but is strongly influenced by external factors such as association with revolutionary applications or frameworks, exclusivity on dominant platforms, and ease of rapid adoption and reuse of existing code. In addition, strategic marketing, the job market, and the developer community play a fundamental role in consolidating and maintaining their relevance. Although performance is important in certain specific domains, in most cases it is not the decisive factor for overall popularity. Therefore, the adoption of a language is usually a balance between practical needs, ecosystems, and social and business strategies.

References

• Why Isn't Functional Programming the Norm? – Richard Feldman