What James Gosling Says About Java’s Future, Language Design, and Static Typing

Introduction

James Gosling, often called “Dr. Java”, is the Canadian computer scientist who designed the original Java language, its compiler, and virtual machine.

In the early 1990s he led the “Green Project” that created the Oak language for embedded devices, which later evolved into Java.

January 1996 – Sun releases the first Java Development Kit.

February 1997 – JDK 1.1 is released.

December 8, 1998 – J2EE (the second‑generation Java enterprise platform) is launched.

May 2000 – JDK 1.3, JDK 1.4 and J2SE 1.3 are released.

Interview

Grigory: We are building a community of Python, Ruby, Java and Go developers in Russia. Your experience with Java could help our developers improve. Let’s talk about language design.

James: I don’t think I’m a teacher, but I find classes useful. I believe classes are very effective for composition. I have no clear ideas on how to do many things differently; some approaches feel odd.

James: Lisp families adapt elegantly, but their syntax carries almost no semantics. I enjoy using Lisp to manipulate Lisp programs. Some languages let you do this directly, like Groovy’s AST support. Rust’s macro system is interesting, but I wonder if we can do more.

James: In Java, generating code fragments is low‑level but powerful. Tools like Lombok add useful features but also expose weaknesses; many ideas belong in the language core, yet the community’s momentum has slowed.

James: Every major change causes pain in the developer community. With few developers, breaking changes are less problematic, but cost‑benefit trade‑offs must be considered. A disruptive change adds pain but can bring benefits; trivial changes (e.g., swapping brackets) are foolish.

James: JDK 9 introduced one of the few breaking changes: hidden APIs were encapsulated, causing pain for those migrating from 8 to 9, but it also unlocked more innovation and allowed custom runtime images.

James: Fixing bugs can sometimes break existing workarounds; we sometimes choose not to fix a bug to avoid breaking downstream code.

James: Static type systems give IDEs and static checkers a solid scaffold. They reduce obscure errors and enable automated theorem proving for critical code, such as cryptographic algorithms.

James: The need for reliability dictates the value of static typing. For one‑off scripts, dynamic languages are fine; for production systems that must run reliably many times, static typing provides confidence.

James: JIT compilation gives Java (and languages like C# and JavaScript) near‑C performance while keeping a high‑level syntax. Many languages lack JIT, which limits their speed.

James: Static typing helps JIT achieve those performance gains; dynamic languages struggle to get similar results without type annotations.

James: Async/await and coroutines are useful but add complexity and may not provide true parallelism. Languages like Erlang offer alternative concurrency models.

James: Pattern matching, as seen in recent proposals for Python and Ruby, is often just a type‑based case statement. It can be helpful but is sometimes overstated.

Inspect P
    When Image do Show;
    When Vector do Draw;

James: The JVM enforces strong security and memory‑model guarantees, which prevents many classes of bugs that C‑like languages suffer from.

Thank you for the conversation.