Important People in Java and Object-Oriented Programming

Analytical Engine · Note G, 1843

From 1834 Babbage designed the Analytical Engine, a general-purpose machine to be programmed with punched cards; it was never completed. In her 1843 notes on the engine, Ada Lovelace set out a step-by-step method for computing Bernoulli numbers (Note G), usually called the first published computer program, and observed that such a machine could work on symbols other than numbers. The engine's separate “store” and “mill” and its repeated sequences of operations anticipate today's memory, processor and loops.

Lambda calculus · 1936

In the early 1930s he developed the lambda calculus, a model of computation built only from defining anonymous functions and applying them; in 1936 he used it to prove an undecidability result independently of Turing, and the Church–Turing thesis carries both names. Functional programming languages descend from his calculus. Java's lambda expressions such as x -> x * x, added in Java 8, take their name from it.

Turing machine · 1936

In “On Computable Numbers” (1936) he defined the Turing machine, showed that a single universal machine can imitate any other machine whose description it is given, and proved that no algorithm can decide in general whether a program halts. The universal machine is the idea of a program treated as data, which stored-program computers realised; a JVM, a program that runs other programs supplied as bytecode, follows the same principle. The halting result is why no Java tool can detect every infinite loop.

Flow diagrams · stored-program design

In the report series “Planning and Coding of Problems for an Electronic Computing Instrument” (1947–48) they planned programs with flow diagrams before writing any code, the forerunner of today's flowcharts. Von Neumann's 1945 “First Draft of a Report on the EDVAC” described a computer that keeps instructions and data in the same memory; nearly every computer, including the one that runs the JVM, follows this design.

A-0 compiler · 1952

In 1952 she wrote A-0, one of the first programs that translated symbolic code into machine code, and she argued that programs should be written in English-like words; her FLOW-MATIC influenced COBOL (1959). Every javac run continues the idea of letting a program do the translation. A 1947 Harvard Mark II logbook page with a moth taped next to a note about a “bug” is associated with her team and helped popularise the word, although engineers already used it.

FORTRAN · Backus–Naur Form

Backus led the IBM team that delivered FORTRAN in 1957, the first widely used high-level language with an optimising compiler. In 1959 he proposed a formal notation for syntax, which Naur adopted and refined in the ALGOL 60 report (1960); it became known as Backus–Naur Form. The Java Language Specification describes Java's grammar in a similar notation, and a message such as ';' expected from javac reports a broken rule of that grammar. Both received the Turing Award (1977, 2005).

Lisp · garbage collection

He created Lisp at MIT in 1958, and in his 1960 paper on the language he described garbage collection: memory that the program can no longer reach is reclaimed automatically. Java relies on the same mechanism; when no reference points to an object any more, the JVM's garbage collector frees it, and Java has no operator for deleting an object by hand. He also coined the term “artificial intelligence” and received the Turing Award in 1971.

Semaphores · structured programming

In 1965 he introduced the semaphore with its P and V operations and posed the dining philosophers problem, the classic picture of deadlock; java.util.concurrent.Semaphore offers the same idea as acquire() and release(). His 1968 letter “Go To Statement Considered Harmful” argued for structured control flow; Java reserves goto as a keyword but gives it no meaning. He also pointed out that testing can show the presence of bugs but never their absence. Turing Award 1972.

Null reference · monitors

While designing ALGOL W in 1965 he added the null reference, which in a 2009 talk he called his “billion-dollar mistake”; every NullPointerException goes back to that decision. His 1974 paper “Monitors: An Operating System Structuring Concept” defined the monitor, a shared object whose procedures run one at a time and whose callers can wait on conditions. Java gives every object a lock of this kind through synchronized, wait() and notify(). He also invented quicksort and received the Turing Award in 1980.

Structured program theorem · 1966

Their 1966 paper “Flow Diagrams, Turing Machines and Languages with Only Two Formation Rules” showed that every flowchart program can be rewritten using only three structures: sequence, selection and iteration. In Java these are consecutive statements, if/switch and while/for; no jump statement is needed to express an algorithm. The result became the theoretical basis of structured programming.

Simula 67 · classes and inheritance

Starting from simulation problems, they designed Simula; Simula 67 introduced classes, objects created from them, subclasses that inherit from a class, and virtual procedures that a subclass may redefine. These are the core ideas of object-oriented programming: Java's class, new, extends and overridable methods come from them, and C++ began by adding Simula's classes to C. They shared the 2001 Turing Award.

Relational model · 1970

His 1970 paper “A Relational Model of Data for Large Shared Data Banks” proposed storing data as relations, that is tables of rows, and asking for data by values instead of following pointers through the storage structure. Every table created and queried through JDBC is a relation in his sense, and a SQL query states which rows are wanted without saying how they are stored or found, an idea that goes back to his data independence. Turing Award 1981.

Pascal · P-code

He designed Pascal (1970) to teach structured programming. The Pascal-P compilers of the 1970s produced P-code for a simple virtual stack machine, so moving Pascal to a new computer only required writing a small interpreter; Java's bytecode and the JVM use the same strategy to run one compiled program on many platforms. His book Algorithms + Data Structures = Programs (1976) sums up his view of programming. Turing Award 1984.

Smalltalk · object-oriented programming

At Xerox PARC in the 1970s he led the group that created Smalltalk, in which everything is an object and all computation happens by sending messages to objects; he is credited with coining the term “object-oriented programming”. Calling a method such as araba.hizlan(10) in Java is the same picture: a message sent to an object, which decides with its own data and behaviour how to respond. Turing Award 2003.

Information hiding · 1972

His 1972 paper “On the Criteria To Be Used in Decomposing Systems into Modules” argued that each module should hide a design decision that is likely to change, exposing only an interface. This principle of information hiding is what private fields behind public methods implement in Java: the internal representation of a class can be replaced without changing the code that uses it.

C · The C Programming Language, 1978

Ritchie created C at Bell Labs in the early 1970s, and the book he wrote with Kernighan (1978) made the “hello, world” first program famous. Java's surface syntax comes from C: braces and semicolons, for loops, switch with fall-through when break is missing, ++, && and ||, and printf-style format strings. Ritchie shared the 1983 Turing Award with Ken Thompson for Unix.

Monitors · Concurrent Pascal

He proposed the monitor idea in 1972–73, giving it a class notation in his book Operating System Principles (1973), and built it into Concurrent Pascal (1975). In “Java's Insecure Parallelism” (SIGPLAN Notices, 1999) he argued that synchronized is a weaker version of these ideas, because nothing stops unsynchronised methods or non-private fields from being used by several threads at once. Lost updates on a shared counter are exactly this kind of error.

SEQUEL / SQL · 1974

At IBM they designed SEQUEL (1974), an English-like query language for Codd's relational model; because of a trademark conflict it was renamed SQL, and it became an ANSI standard in 1986. Statements such as CREATE TABLE, INSERT and SELECT … WHERE are sent from Java through Statement or PreparedStatement. Boyce, who also gave his name to Boyce–Codd normal form, died in 1974 at 27.

Model–View–Controller · 1979

As a visiting scientist at Xerox PARC in 1978–79 he formulated Model–View–Controller for Smalltalk: the model holds the data, the view shows it, and the controller handles the user's input. Swing uses a modified form of this separation; a JTextField is the view, and the Document obtained with getDocument() is the model that stores the text. MVC is also one of the standard architectural patterns.

Transactions · 1981

He worked out how database transactions are implemented with locking and logging, and in “The Transaction Concept: Virtues and Limitations” (1981) described transactions as atomic, consistent and durable; Theo Härder and Andreas Reuter added isolation and coined the acronym ACID in 1983. In JDBC, setAutoCommit(false), commit() and rollback() make a money transfer happen completely or not at all. Turing Award 1998; he was lost at sea in 2007.

C++ · 1983

At Bell Labs in 1979 he began “C with Classes”, adding Simula's classes to C; it was renamed C++ in 1983. Java took much of C++'s syntax for classes, constructors and the access modifiers public, private and protected, but deliberately left out multiple inheritance of classes, operator overloading and explicit pointers. In Java a class extends one class and may implement several interfaces instead.

Abstract data types · substitution principle

With Stephen Zilles in 1974 she described abstract data types, defined by their operations rather than their representation, and built them into the CLU language. Her 1987 OOPSLA keynote “Data Abstraction and Hierarchy” stated what is now called the Liskov substitution principle: an object of a subtype must be usable wherever an object of its supertype is expected; she formalised it with Jeannette Wing in 1994. A correct is-a relationship, and a polymorphic array that calls the same method on every element, both rely on this rule. Turing Award 2008.

Design by Contract · Eiffel

In the mid-1980s he designed the Eiffel language around Design by Contract: every routine states a precondition that the caller must satisfy and a postcondition that it guarantees, and a class states an invariant. His book Object-Oriented Software Construction (1988) also formulated the open–closed principle: modules open for extension, closed for modification. Java has no built-in contracts, so preconditions of public methods are usually checked by throwing IllegalArgumentException, and internal assumptions with assert.

Booch method · UML

His book Object-Oriented Analysis and Design with Applications (1991) introduced the Booch method and its notation for classes and their relationships. At Rational Software he began unifying his method with James Rumbaugh's in 1994, Ivar Jacobson joined in 1995, and the result, the Unified Modeling Language, was adopted by the Object Management Group in 1997. A UML class box (name, attributes, operations) and the hollow-triangle arrow for inheritance are the usual way to draw class hierarchies.

OMT · UML

At General Electric's research centre he led the development of the Object Modeling Technique, presented in Object-Oriented Modeling and Design (1991); it described a system with an object model of classes and associations and a dynamic model of state diagrams. He joined Rational in 1994 to merge OMT with the Booch method into UML. UML state diagrams are the standard way to draw the life cycle of a thread through states such as NEW, RUNNABLE, BLOCKED and TERMINATED.

Use cases · OOSE

Working on telephone-switching software at Ericsson, he developed use cases, which describe a system by what its users do with it; he presented them at OOPSLA 1987 and built the OOSE method around them (book, 1992). His company Objectory joined Rational in 1995, and use-case diagrams became part of UML. Starting from what the user needs before choosing classes, and deriving tests from those needs, follows the same line of thought.

UTF-8 · 1992

In September 1992 they designed UTF-8, the encoding of Unicode in which ASCII characters stay one byte and other characters take two to four bytes. A Turkish letter such as ş needs two bytes in UTF-8; reading a UTF-8 file with the wrong character set is why such letters can appear garbled. Inside Java a char is a 16-bit UTF-16 unit, so text read from a file is decoded, and the charset can be given explicitly. Thompson also co-created Unix, and both later co-designed the Go language.

Design Patterns · 1994

Their book Design Patterns: Elements of Reusable Object-Oriented Software (1994), whose authors became known as the “Gang of Four”, catalogued 23 patterns in creational, structural and behavioural groups. Several appear directly in Java's library: wrapping a stream in a BufferedReader is the Decorator pattern, Iterator is Iterator, a Comparator is a Strategy, event listeners follow Observer, and an abstract class that fixes the steps of an algorithm is a Template Method.

Java · 1995

In 1991 Sun's Green project began a language for consumer devices called Oak, designed by Gosling; renamed Java, it was announced in May 1995 and JDK 1.0 followed in January 1996. He wrote the original compiler and virtual machine: javac translates source into bytecode, and the JVM runs that bytecode on any platform, summed up in the slogan “write once, run anywhere”. With Bill Joy and Guy Steele he wrote The Java Language Specification (1996).

The Java Virtual Machine Specification · 1996

Their book The Java Virtual Machine Specification (1996) defined the .class file format, the bytecode instruction set and bytecode verification independently of any single implementation. Because of this specification, a class file compiled once can run on different JVMs such as HotSpot or OpenJ9, and javap -c shows the same instructions everywhere. Lindholm was later specification lead of JSR 133, the revision of the Java memory model.

JUnit · 1997

Beck had written SUnit, a testing framework for Smalltalk; on a flight to the OOPSLA 1997 conference he and Gamma wrote the first version of JUnit, pair programming and writing the tests first. JUnit made automated unit tests with assertions such as assertEquals a routine part of Java development and gave rise to the xUnit family. Beck also introduced Extreme Programming (1999) and described test-driven development in Test-Driven Development: By Example (2002); Gamma later led the Java development tools of Eclipse.

Collections Framework · Effective Java

He led the design of the Java Collections Framework introduced in Java 1.2 (1998): the interfaces List, Set and Map, their implementations such as ArrayList and HashMap, and the Collections algorithms. He also designed the java.math package and the assert statement. His book Effective Java (2001; third edition 2018) collects rules such as overriding hashCode whenever equals is overridden and favouring composition over inheritance.

GJ (Generic Java) · 1998

Their GJ design, presented at OOPSLA 1998, added type parameters to Java by erasure: the compiler checks List<String> and then removes the type arguments, inserting casts where needed, so the result runs on existing JVMs. GJ was chosen as the basis of JSR 14, and generics arrived in Java 5 (2004). Erasure explains why new T[10] and List<int> are not allowed. Odersky's GJ compiler became the basis of javac from JDK 1.3; Odersky later created Scala, and Wadler is one of the designers of Haskell.

QuickCheck · 2000

Their tool QuickCheck (ICFP 2000) introduced property-based testing for Haskell: instead of listing example inputs, the programmer states a property, for instance that reversing a list twice gives the original list, and the tool checks it on hundreds of random inputs. Later versions also shrink a failing input to a small counterexample. The idea has been carried to many languages, including Java libraries such as jqwik and junit-quickcheck.

SQLite · 2000

In 2000 he started SQLite, a serverless database engine that keeps a whole database in a single file and is released into the public domain; its developers describe it as the most widely deployed database engine. Because it needs no separate server, a Java program only needs the JDBC driver and a connection URL such as jdbc:sqlite:okul.db to create tables and run SQL.

java.util.concurrent · 2004

His book Concurrent Programming in Java (1997) collected design patterns for threads, and his freely available concurrency library grew into JSR 166, which he led. The result is the java.util.concurrent package of Java 5 (2004): thread pools behind ExecutorService, ReentrantLock, blocking queues such as ArrayBlockingQueue, CountDownLatch, Semaphore and the atomic classes. He later added the fork/join framework in Java 7.

Java memory model · FindBugs

Around 2000 he showed that Java's original memory model was flawed and, with Jeremy Manson and Sarita Adve, designed the revised model adopted through JSR 133 in Java 5. It defines what volatile and synchronized guarantee about when one thread sees another thread's writes. He is also a co-author of FindBugs, a static analyser for Java bytecode whose successor is SpotBugs, and the inventor of skip lists (1990).

Computational thinking · 2006

Her 2006 essay “Computational Thinking” in Communications of the ACM argued that decomposition, abstraction and algorithmic thinking are basic skills for everyone, not only for programmers. Breaking a problem into methods and classes, and hiding details behind an interface, are the same skills applied in Java. With Barbara Liskov she also gave the formal definition of behavioural subtyping (1994).

Java Concurrency in Practice · Java 8 lambdas

He is the lead author of Java Concurrency in Practice (2006, with Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes and Doug Lea), the standard guide to thread safety and visibility. As Java Language Architect at Oracle he was specification lead of JSR 335, which brought lambda expressions and the streams library in Java 8 (2014). He then led Project Amber, the source of records, switch expressions, sealed classes and pattern matching.

Module system · six-month releases

As Chief Architect of the Java Platform Group he was specification lead of Java SE 7, 8 and 9. He led Project Jigsaw, the module system of Java 9 (2017), which split the JDK into modules and added module-info.java as a level above packages. In 2017 he proposed releasing a new Java version every six months, starting with Java 10 in March 2018; this is why features such as the new switch are tied to version numbers like Java 14.