I came across a discussion on Hacker News about John Carmack’s tweet on variable mutability and immutability in programming languages. Reading through the thread resurfaced a thought that’s lingered in my mind for years—how programming language choices evolve within companies. When companies are small, they pick dynamic languages that let them move fast and build without restrictions. They don’t want shackles like strict type checking or immutability constraints. But as they grow, they inevitably drift toward structure and safety. They want guardrails to prevent someone from accidentally shooting themselves in the foot.
Facebook began with PHP and later built HipHop and HHVM—eventually evolving PHP into Hack to add optional static typing and better performance. Dropbox started with Python and later introduced large-scale static type checking across millions of lines of code. Stripe launched with Ruby and created Sorbet, their own static type checker, to bring type safety to Ruby. The pattern is clear: wild beginnings giving way to domesticated systems.
When you’re just starting out, you don’t deliberate much about programming languages and their nuances. That’s not top of mind—solving a problem is. You pick a language you’re familiar with and start hacking. You optimize for speed and freedom. Once you hit product–market fit and your codebase explodes—with hundreds of developers committing daily—you start craving predictability. But by then, switching languages becomes a stop-the-world exercise. It’s too late. So you adapt. You reinforce the old language, patching and constraining it until it behaves safely enough for scale.
Early in my career, I consulted for a startup built on PHP. When we had to build a new product, I naïvely chose Java. It was an uphill task. The team, used to PHP’s minimal friction, kept stumbling over Java’s verbosity. Back then, you could deploy a PHP “Hello World” site with a single file. Doing the same in Java meant learning the language, a framework, a templating engine, and a server like Tomcat. It was more scalable and robust, yes—but it came with a mountain of overhead. Looking back, PHP was a better fit for that small team and unproven product.
That contrast has stayed with me. Startups are wild—fast, instinctive, and full of creative chaos. As they mature, they become domesticated—structured, cautious, and focused on preserving what they’ve built while still trying to move fast. The transformation is inevitable, not just in culture, but in code.
In 2005, when I started my career, the popular, easy-to-learn languages were mostly dynamic. If you wanted type safety, Java was the de facto choice. But Java wasn’t considered cool—it carried the enterprise tag. Today, the landscape looks very different. Languages like Go, Rust, and Kotlin are popular, accessible, and increasingly used by startups from day one. Perhaps the trend of retrofitting dynamic languages for safety will fade, replaced by languages that balance freedom and discipline from the start. Perhaps the next generation of startups won’t have to choose between the wild and the domesticated.
Abhirama's Blog 