Ask someone who invented Java, and almost everyone says "James Gosling." That's true, but incomplete — he didn't build it alone. And if you ask "who owns Java today," a surprising number of developers still say Sun Microsystems, a company that hasn't existed since 2010.
Let's fix both of those gaps, then go through the actual list of features that make Java, Java — the ones that show up in almost every interview, explained properly instead of just named.
The people behind Java (not just Gosling)
In 1991, three people started the project at Sun Microsystems, not one:
- James Gosling — the lead architect, often called "the father of Java"
- Patrick Naughton — the engineer whose frustration with Sun's tools actually kicked off the project in the first place
- Mike Sheridan — handled the business side, figuring out what market this project should actually target
Together they were known as the Green Team. And ownership has changed since then too: Oracle Corporation acquired Sun Microsystems in 2010 for $7.4 billion, and has owned and maintained Java ever since. If your mental model still says "Sun Microsystems owns Java," that's about 15 years out of date.
The 16 features that actually define Java
Every one of these gets mentioned in Java courses, but usually just as a name on a list. Here's what each one actually means, in plain terms.
| # | Feature | What it actually means |
|---|---|---|
| 1 | Simple | No manual pointers, cleaner syntax than C++ |
| 2 | Object-Oriented | Everything is built from classes and objects |
| 3 | Platform Independent | Same code runs on any OS via the JVM |
| 4 | Secure | No direct memory access, sandboxed execution |
| 5 | Robust | Strong memory management, structured exception handling |
| 6 | Portable | The same program moves between systems without changes |
| 7 | High Performance | The JIT compiler translates hot code into native instructions |
| 8 | Multithreaded | Built-in support for running multiple tasks at once |
| 9 | Distributed | Built-in support for networked applications (RMI, web services) |
| 10 | Dynamic | Classes can be loaded at runtime, not just compile time |
| 11 | Architecture Neutral | Not tied to any specific CPU or hardware design |
| 12 | Interpreted | Bytecode is executed by the JVM, not run directly on hardware |
| 13 | Automatic Memory Management | Garbage collection reclaims memory you're no longer using |
| 14 | Rich API | A huge standard library ships with the language itself |
| 15 | Compiled and Interpreted | Code compiles to bytecode first, then the JVM interprets/JIT-compiles it |
| 16 | Strong Community Support | Decades of libraries, frameworks, and answered Stack Overflow questions |
A few of these are worth slowing down on, because they get misunderstood constantly.
Secure — what this actually protects against
"Secure" doesn't mean "immune to bugs." It means Java removes an entire category of bugs by design. In C, you can point directly at a memory address and read or write whatever's there — that's how buffer overflows and a huge share of classic security vulnerabilities happen. Java doesn't let your code touch memory addresses directly at all. Combined with the JVM's bytecode verifier (which checks code for illegal operations before running it), this is why Java became a popular choice for running code you don't fully trust, like early web applets.
Dynamic — the one people usually get wrong
This doesn't mean "dynamically typed" — Java is actually statically typed (you declare variable types up front). "Dynamic" here refers to class loading: Java can load new classes into a running program at runtime, instead of requiring every class to be known and linked at compile time. This is the same mechanism that lets a Java application load a plugin, or a server reload part of itself without a full restart.
Distributed — why this used to be a bigger deal than it sounds
Java shipped with RMI (Remote Method Invocation) built in — the ability to call a method on an object running on a completely different machine, almost as if it were local. In the mid-90s, this was a genuinely big deal; most languages didn't have anything like it built into the standard library. It's part of why Java became the default choice for a lot of early enterprise, networked software.
Write once, run anywhere — the quick version
This is covered in full depth in an earlier piece I wrote on why Java was created, but the short version: your .java file compiles to bytecode (.class), and the JVM — a different build for each OS — is what actually runs that bytecode. Same file, any machine, as long as a JVM exists for it.
MyProgram.java → compile (javac) → MyProgram.class (bytecode) → JVM → runs on Windows, Linux, or Mac
Quick answers, if this comes up in an interview
- "Who created Java, and who owns it now?" → "James Gosling led the team, alongside Patrick Naughton and Mike Sheridan, at Sun Microsystems in 1991. Oracle acquired Sun in 2010 and has owned Java since."
- "What does 'Java is secure' actually mean?" → "It removes direct memory access and pointer arithmetic, and the JVM verifies bytecode before running it — this eliminates whole categories of bugs common in languages like C."
- "Isn't Java dynamically typed since it's called 'Dynamic'?" → "No — Java is statically typed. 'Dynamic' refers to loading classes at runtime, not variable typing."
- "What's the difference between 'Compiled' and 'Interpreted' for Java, since it's supposedly both?" → "Java source compiles to bytecode first (compiled), then the JVM runs that bytecode by interpreting it and JIT-compiling the frequently used parts (interpreted + just-in-time compiled)."
The short version
Java wasn't a solo project — Gosling, Naughton, and Sheridan built it together, and Oracle has owned it since 2010, not Sun. The 16 features you'll see listed everywhere aren't just buzzwords: each one solves a specific, real problem from the pre-Java era, from memory-corruption bugs (secure) to "my code only runs on one machine" (platform independent, portable, architecture neutral). Knowing the reason behind each one is what separates reciting a list from actually understanding the language.
Further reading
- OpenJDK — the official open-source home of the JDK
- Oracle Java — Oracle's official Java site
- Computer History Museum — James Gosling profile — a well-sourced look at the Green Team's early years
Top comments (0)