What Do The Most Popular Programming Languages Reveal About Engineering Teams Today?

The software industry is going through some major shifts. Every company has to do more with less, while still moving incredibly fast. The result is that more engineering teams are choosing efficient growth, over growth at all costs. Among scalability and efficiency, safety has become a top requirement for developers when it comes to choosing programming languages and tools. This is what I’ve observed after analyzing the 25 most popular programming languages on CircleCI. 

Teams are balancing product-market fit with scalability and safety, ultimately choosing tools that allow them to collaborate effectively while enabling guardrails that prevent as many errors as possible. 

Here’s my take on the most significant language trends over the past three years and what they say about the changing priorities of developers. 

Rust Jumped into the Top 25 Most Popular Languages

As a system language with excellent memory management, Rust is designed to replace a language like C, and devs who want to write secure and safe code love it. It’s a language that makes it very easy for developers to collaborate and do a lot in a short amount of time. When teams want a language that can act as a robust service as well as scale, they turn to Rust. I think we’ll start to see more and more teams choosing Rust for these exact reasons in the coming years, particularly in the systems tooling space 

TypeScript Surpassed JavaScript as the Most Popular DevOps Language

As a scalable, human-readable language that facilitates collaboration and accelerates development, TypeScript’s popularity shows that more engineering teams are prioritizing rapid onboarding and collaboration across projects by making it easier to read, refactor, and share code. TypeScript is similar to JavaScript but with less unpredictability. It’s easier to validate and less messy, giving developers more confidence. 

Major tools have been written in TypeScript like React and VS code — each of these has many collaborators and collaboration scaling is easier with typed language. TypeScript hasn’t released new frameworks as often as JavaScript, which prevents devs from having to frequently relearn everything on updated versions. Ultimately, there are more guardrails in place on TypeScript than on JavaScript. 

Our own teams use TypeScript and recently created an open-source library, the CircleCI Config SDK, that allows devs to write and manage their YAML files in more manageable languages like TypeScript and JavaScript. This makes it easier for teams to dynamically build their CI configuration at run-time and saves a lot of hassle. 

HashiCorp’s Configuration Language Jumped into the Top 10

HCL provides teams the flexibility they need to provision and manage cloud environments at scale. HCL’s developer-friendly syntax combined with the speed and standardization benefits of infrastructure-as-code tools allows engineering teams to achieve incredibly fast deployment workflows and debugging. When teams need to manage change at this scale, HCL enables them to do so successfully. 

We use HCL at CircleCI because they added all sorts of guardrails to their V2, making it easier for our teams to understand the desired outcome of what we’re trying to do. In fact, it shares many of the benefits seen with TypeScript and even Rust — adding more type-checking and safety makes contribution and validation more straightforward. With a language like HCL, our continuous integration becomes more reliable and effective because we know we can find any problems way earlier in the process. HCL enables us to move fast without making mistakes because those checks and balances are in place. 

Gherkin Brings Behavior-Driven Development into the Top 20

Behavior-driven development (an off-shoot of test-driven development) breaks down traditional barriers between product owners and developers by establishing shared expectations around product behavior, without specifying exactly how features should be implemented behind the scenes. 

The growing popularity of Gherkin again shows that more teams are prioritizing cross-team collaboration and user experience from the outset of the development process. Gherkin allows teams to not only understand the behavior of the final product but define the desired behavior. Traditionally, a lot of time and energy is spent on figuring out how software was intended to behave. You need to know this before entering a refactor. Gherkin puts that mentality upfront. 

Playing It Safe

Large portions of the software industry are maturing, likely accelerated by the current macroeconomic climate. The shift towards programming languages with clear guardrails (type checking, memory safe) in place is not too dissimilar from the trend of engineering organizations going from a monolith to microservices — both allow for better resource optimization and collaboration among teams. 

More leaders are beginning to understand that they can’t pause their business for a year to improve processes but they still need precautions in place. These language trends make it clear that teams are figuring out how to accelerate growth efficiently while maintaining a necessary level of safety.