The programming language after Kotlin – with the creator of Kotlin

In a world increasingly shaped by artificial intelligence, the question arises: why create a new programming language when AI can seemingly write most of your code? Andre Brela, the visionary creator behind Kotlin, offers a compelling perspective. Kotlin, a language powering billions of Android devices and one of the fastest-growing globally, was born from a pragmatic desire to modernize the Java ecosystem. Today, Brela is embarking on a new frontier with Codespeak, a language built on English, designed for an era where AI plays a central role. This deep dive explores Kotlin's strategic design, its journey to becoming Android's official language, and Brela's bold vision for the future of programming in an AI-driven world.

Key Takeaways

• Kotlin was conceived in 2010 to address Java's stagnation and verbosity, drawing inspiration from languages like Scala, C#, and Groovy.
• Key innovations included null safety, type inference, smart casts, and a focus on reducing boilerplate, making code more readable and robust.
• Seamless interoperability with Java was Kotlin's most significant technical challenge, requiring years of complex engineering to ensure transparent integration.
• Kotlin's adoption dramatically accelerated after Google officially endorsed it as a primary language for Android development in 2017, transforming its trajectory.
• Andre Brela's new project, Codespeak, aims to reduce the amount of code developers write by 10x, using natural language and AI to express intent more efficiently.
• The future of programming will involve humans managing essential complexity with AI tools, necessitating new development environments and robust testing strategies.

The Genesis of Kotlin: Addressing Java's Limitations

In 2010, the landscape of programming languages for the Java Virtual Machine (JVM) was ripe for disruption. Andre Brela, then a PhD student with a background in computer science and developer tools, was approached by JetBrains with a radical proposition: to build a new programming language. His initial reaction was skepticism, believing the world didn't need another language. However, JetBrains engineers presented a compelling case, highlighting the profound issues plaguing the Java ecosystem.

Java's Stagnation and the Need for Evolution

By 2010, Java's evolution had stalled. Java 5, released in 2004, was the last major update, with Java 6 offering no language changes and Java 7 introducing only minor ones. This stagnation created a void, especially when compared to languages like C#, which by then boasted modern features such as lambdas, higher-order functions, and streamlined property access. Java felt "standing still," leaving developers yearning for more expressive and concise tools.

"Java didn't really evolve and hadn't been for for a long time."

Other JVM languages had emerged, notably Scala and Groovy, which JetBrains engineers were familiar with through building development tools. While both offered improvements, they came with their own set of challenges:

• Groovy: Too dynamic for large-scale production environments, leading to difficulties with refactoring and requiring extensive testing. Performance was also an issue, building a dynamic language on a static runtime.
• Scala: Powerful but overly complex, relying heavily on "implicits" and suffering from slow compilers and tooling instability. This made it inaccessible for many mainstream engineers, despite its adoption in large projects like Twitter and LinkedIn.

The JetBrains Advantage and Initial Design

JetBrains recognized an opportunity. With their deep expertise in developer tools and a trusted user base, they believed they could create a language that addressed Java's shortcomings without inheriting the complexities of Scala or the dynamism of Groovy. Brela was persuaded, beginning a journey of whiteboard design and intense discussion.

• The initial focus was to fix common "pains" in Java, such as verbosity and boilerplate code.
• Feedback from experienced JetBrains engineers, deeply familiar with developer workflows, was crucial in shaping features and identifying problems.
• Early ideas included concepts like extensions, a feature borrowed from C#.
• The project started with Brela and a small team working part-time, building an IDE plugin first to experiment with syntax, rather than a full compiler.
• This "interactive" approach allowed for rapid iteration on syntax and early tooling, even before full compilation capabilities were in place.

The name "Jet" was initially used internally but was quickly found to be trademarked. After a "painful" search, the team settled on "Kotlin," named after an island in the Gulf of Finland, chosen for its uniqueness and searchability, despite initial hesitations and minor negative connotations in some languages.

Crafting Kotlin: Influences, Innovations, and Challenges

Kotlin's design philosophy was rooted in pragmatism, not academic novelty. As Andre Brela puts it, the language was built on the "shoulders of giants," deliberately borrowing and adapting proven ideas from other successful languages.

Pragmatism and Core Differentiators

The core idea was to create a "pragmatic language for industry," simplifying complex concepts and avoiding pitfalls identified in languages like Scala. Key areas of focus included:

• Verbosity Reduction: Eliminating boilerplate like `public static void main`, explicit getters and setters, and redundant type declarations (e.g., `List strings = new ArrayList`).
• Type Inference: Reducing repetitive code by allowing the compiler to infer types, making declarations much cleaner.
• Null Safety: A monumental feature inspired by an internal presentation. Kotlin's type system enforces null checks at compile time, preventing the "billion-dollar mistake" of null pointer exceptions without the runtime overhead of "option" types found in some functional languages.
• Elimination of Semicolons: A small but significant syntactic cleanup.

Borrowing from Giants: Scala, C#, and Groovy

Kotlin's design is a testament to intelligent integration rather than pure invention:

• From Scala: Concepts like primary constructors, data classes, `val` (immutable) and `var` (mutable) declarations, and sophisticated generics. Kotlin, however, simplified Scala's powerful but complex "traits" by removing state from interfaces, a decision later mirrored by Java.
• From C#: Crucially, C#'s approach to extensions and a "super pragmatic" parser hack for handling angle brackets (for generics) in expression contexts, avoiding the awkward syntax found in Java or Scala.
• From Groovy: Builders, a pattern for constructing objects, were adapted into Kotlin's type-safe builders, offering syntactic flexibility with compile-time guarantees.
• Smart Casts: Inspired by a lesser-known language called "gou," smart casts automatically infer the type of a variable after an `instanceof` check, eliminating redundant casting.

Features Left Out (and a Major Regret)

Not every promising feature made it into Kotlin, often due to complexity or perceived overlap with existing constructs:

• Pattern Matching: While considered, it was deemed too large a feature, requiring "an entire language in size." The combination of smart casts and destructuring was found to provide "80% of all the good things pattern matching can do."
• Ternary Operator (? :): Brela considers its omission one of his biggest regrets. Because Kotlin makes `if` an expression, the team thought the ternary operator was redundant. However, the `if` expression turned out to be more verbose in many common scenarios, and by the time this was realized, retrofitting the ternary operator into Kotlin's established syntax was no longer feasible.

The Interoperability Imperative and Kotlin's Path to 1.0

Kotlin's success hinged on its ability to coexist seamlessly with Java. This interoperability was "probably the single thing we spent the most time on," requiring intricate engineering to bridge the two ecosystems transparently.

The Complex Dance of Java Interop

The goal was simple but profound: allow Kotlin code to use any Java library and allow Java code to use any Kotlin code, all without friction. This meant:

• Compilation Trickery: Kotlin's compiler, equipped with a Java front-end, first compiles all Kotlin code (which can depend on Java sources) into JVM class files. The Java compiler then reads these Kotlin binaries as if they were standard Java classes.
• Collections Nuance: Java collections are "invariant" and always mutable. Kotlin introduced the concept of "read-only" and "mutable" collections but internally represented Java collections as "platform mutable." When Kotlin exposes its collections to Java, they are again seen as normal, mutable Java collections. This "hack" also extends to making Kotlin's covariant collections appear covariant to Java via `? extends` wildcards.
• Nullable Types Challenge: Java types have no concept of nullability in their type system. Initially, Kotlin treated all Java types as nullable, leading to "horrible" developer experience filled with null checks. The solution involved "platform types"—a sophisticated approach where Kotlin understands that a type originates from Java and might be null, but doesn't force immediate null checks, allowing developers to choose how to handle it.
• Binary Compatibility: To avoid forcing users to update their entire project when a new compiler version introduced a new language feature, Kotlin developed "message from the future." This mechanism allows newer compilers to embed information in binaries, enabling older compilers to gracefully handle incompatible methods while still using the rest of the library.

"If someone offers you a job to create a system that interoperates transparently with another huge system you don't control, ask for a lot of money."

This massive undertaking extended the development timeline far beyond initial expectations. Brela famously joked, "Every time I was asked when we were going to release Kotlin, I would say one year from now." What began in autumn 2010 culminated in the 1.0 release in February 2016 – a journey of over five years. The team grew from four part-time individuals to approximately 25 at release, eventually reaching over 100 people by 2020.

Release Cadence and Compatibility Management

Releasing a language requires a unique development process, including "bootstrapping" (writing the compiler in its own language) and meticulous compatibility management. Kotlin adopted several practices:

• Code Reviews and Issue Tracking: Standard practices like comprehensive code reviews and an open issue tracker were vital for collaboration and community feedback.
• Backwards Compatibility Focus: Unlike Scala, which often broke compatibility, Kotlin prioritized stability for its 1.0 release. This involved extensive design reviews to anticipate future changes and "prohibit things that might block that."
• Migration Tools: For pre-1.0 milestone builds, automatic migration tools were provided to help users adapt to language changes, a practice Brela credits Kotlin with popularizing.
• Experimental Features: A disciplined approach to marking experimental features with specific package names, warnings, and compiler flags ensured users were aware of potential breaking changes.

Kotlin's Android Revolution and Ecosystem Growth

Initially, Android was not even on Kotlin's radar. The focus was on server-side and desktop Java developers, mirroring IntelliJ IDEA's primary user base. However, an organic surge of interest from the Android community, coupled with strategic timing, catapulted Kotlin to unprecedented popularity.

An Unexpected Android Embrace

The discovery of Kotlin's potential on Android began with a simple user inquiry in the early days, asking if Kotlin worked on the platform. After initial toolchain crashes and debugging, the team realized Android's strict adherence to JVM specifications ironically made it an excellent "testing environment" for Kotlin's bytecode quality. More importantly, Brela identified a critical market dynamic:

• Java's Android Frustration: Android developers were largely "stuck with old Java" because updating the JVM on billions of devices was incredibly difficult. Even when Java 8 introduced modern features, they were not readily available to the Android ecosystem, leading to significant developer frustration.
• The Swift Precedent: Apple's successful transition from Objective-C to Swift on iOS provided a clear example of how a dated language could be replaced by a modern, developer-friendly alternative within a major platform.
• IntelliJ's Role: Google's decision to switch Android Studio's developer tooling from Eclipse to the IntelliJ platform further smoothed Kotlin's path, as JetBrains already had a robust Kotlin plugin.

Kotlin's inherent advantages—conciseness, null safety, and modern features—resonated deeply with Android developers. Brela's initial personal goal was 100,000 users, a milestone Kotlin was on track to achieve organically in 2016. However, a pivotal moment was fast approaching.

The Google IO Tipping Point

In early 2017, Google reached out to JetBrains, expressing interest in officially supporting Kotlin at Google I/O. This surprise announcement, just three months away, triggered a "heroic effort" from both sides to prepare for the monumental shift.

"It was amazing to see how happy people were at Google IO when the announcement happened."

The announcement at Google I/O 2017 was a watershed moment. It solidified Kotlin's position as a first-class language for Android development, leading to an immediate and massive surge in adoption. Within that year, Kotlin's user base skyrocketed into the millions. This event underscored Brela's long-held belief:

"I knew that the easiest way for a language to succeed is to be part of a platform."

The Google partnership also necessitated the creation of the Kotlin Foundation and a temporary trademark transfer to Google, ensuring the language's long-term stewardship and independence. Kotlin had found its platform, forever changing its trajectory.

Codespeak: Redefining Programming in the AI Era

After leaving JetBrains in 2020, Andre Brela turned his attention to a new challenge: programming in the age of AI. His latest project, Codespeak, represents a radical reimagining of how developers interact with computers, driven by the capabilities of large language models (LLMs).

Shrinking Code with Human Intent

Brela sees AI as an opportunity to achieve what Kotlin did at a lower level: significantly reduce boilerplate and make programs more "to the point." The goal of Codespeak is to shrink the amount of information a programmer needs to tell the computer by "about 10x."

• Leveraging LLMs: Codespeak is designed as a programming language based on English, using LLMs "heavily" as a "bag of libraries."
• Informal Query Language: Since LLMs are trained on natural language and have seen "all the code in the world," the most effective way to extract information from them is through informal queries. Codespeak aims to integrate this informal query language directly into the programming experience.
• Focus on Intent: Instead of spelling out every line of an algorithm, Codespeak allows developers to communicate intent at a higher level, much like a human explains a task to another human.

Brela argues that designing new formal languages specifically for LLMs is misguided. LLMs are strongest with languages they've been extensively trained on (like Python, Java), not newly invented ones. Instead, Codespeak aims to "discover" its optimal syntax by analyzing existing code and finding the shortest English descriptions that can generate equivalent implementations, ensuring maintainability over time.

The Future of Software Engineering with AI

The rise of AI coding agents like Cursor and Cloud Code marks the early days of a new era. However, Brela identifies a critical problem with current agent interactions: the "chat history is lost." Developers communicate intent in natural language to the agent, which generates code. But this intent, the dialogue, disappears, leaving only the machine-readable code for human teammates.

Codespeak seeks to elevate everything to the human language level, making the intent itself part of the codebase. This shift will necessitate fundamental changes in how software is developed:

• New Development Environments: Tools will evolve from traditional IDEs to specialized environments built from the ground up to integrate deeply with AI agents and preserve intent.
• Enhanced Review Tools: The sheer volume of AI-generated code demands better tools for review and verification, moving beyond manual code inspection to ensure quality and security.
• Automated Testing: With agents generating vast amounts of code, robust automated testing becomes paramount. The challenge lies in ensuring tests effectively verify intent and are themselves reliable.
• Focus on Essential Complexity: While AI may eliminate "accidental complexity" (boilerplate, trivial implementations), "essential complexity" (what the software needs to do) will remain. Engineers' roles will evolve to managing, organizing, and navigating this inherent complexity.

Advice for Developers in an AI World

Brela offers poignant advice for developers navigating this transformative period:

• Ignore the Hype: Many "suboptimal decisions" (like not hiring junior developers) driven by AI hype will eventually be rolled back as the industry matures.
• Invest in AI Tools: Learning to effectively use AI coding tools and mastering "prompt engineering" is a valuable skill, even if it's not yet formalized.
• Embrace Complexity: The future still belongs to engineers who can build and manage complex systems. Their role will be to communicate intent and handle the inherent challenges of software.
• For New Grads: Focus on becoming incredibly productive with AI tools, or dive deep into "hardcore" technical areas to develop rare, marketable expertise. Curiosity and a desire to understand "under the hood" will always be valuable.

Brela firmly believes that humans will remain in charge, making decisions and defining the intent of software. Codespeak is a tool for humans, designed to empower them to manage complexity more effectively in an AI-powered future.

Conclusion

Andre Brela's journey from creating Kotlin to envisioning Codespeak mirrors the evolution of software development itself. Kotlin was a pragmatic response to Java's limitations, a masterclass in building on the "shoulders of giants" to create a more concise, safer, and developer-friendly language. Its success on Android underscores the power of a platform and the relentless pursuit of developer experience.

Now, with Codespeak, Brela challenges us to rethink the very nature of programming in an AI-first world. By elevating intent and leveraging natural language, he seeks to reduce the burden of explicit code, allowing engineers to focus on the essential complexity of what they want to build, rather than the ceremonial details of how. The future of programming, as he sees it, is not one where AI replaces humans, but where AI empowers humans to be dramatically more productive and creative, managing complex systems with tools that speak our language.