History and evolution of OO languages

Tracing the roots of components from OOP

James Durham (jdurham@ion1.com)
Independent multimedia consultant

This timeline explores some of the key events of object-oriented programming and components in the last 50 years in the greater context of general computing history.

This timeline explores some of the key events of components and object-oriented programming in the last 50 years. We could have gone back further to John von Neumann's 1946 proposals that changed computer architecture forever, or perhaps further back to ENIAC, Babbage or even Pascal. However, we decided to begin in 1951 since the birth of the widely publicized UNIVAC seems to spark the commercial engine that drives the modern pursuit of object-oriented programming and development. This commercial revolution of computers, helped along the way a decade later by IBM's 1400 series in 1961, built the momentum for developing programming languages that could encapsulate object-oriented concepts. Besides, starting this timeline in 1951 makes for a nice round number of years for us to cover in this edition.

Throughout this timeline we have inserted key events in hardware, operating system, and Internet development -- usually with an eye on how they affect object-oriented programming and component technology, but sometimes just to add greater background context for OO developments.

In many ways, "object-oriented" concepts have permeated every aspect of computer science today. For instance, while the concepts in OO database discussions may not be the center of talk today, their ideas are encapsulated to a degree in other technologies like CORBA and modern SQL-based databases. A modern relational database is really an advanced object-oriented system. Because it can be hard to put a date to ideas that gradually catch on, we have found some of these relationships hard to track in this timeline -- but we very much welcome suggestions on how to show these relationships better.

TIMELINE

Object-oriented (OO) events are indicated with a light yellow background.

1951

J. Presper Eckert and John Mauchly build the first general-purpose commercial computer that attracts widespread attention, the UNIVAC. (http://www.computer.org/history/development/1951.htm)

1953

IBM ships its first electronic computer, the IBM 701.

1954

IBM ships the first mass-produced computer, the IBM 650 magnetic drum calculator.

1956

John McCarthy develops the basics behind the LISP ("LISt Processing," later also known as standing for "Lots of Idiotic, Silly Parentheses") programming language during a Dartmouth Summer Research Project on Artificial Intelligence. Lisp has gone on to become one of the major foundational languages that has shaped programming and computer science. Though not originally object-oriented, it would eventually become so with the emergence of CLOS (Common Lisp Object System) in 1988.

1957

The United States forms the Advanced Research Projects Agency (ARPA).

John Backus and his team at IBM develop the first FORTRAN compiler. FORTRAN was one of the first (if not the first) high-level programming languages, and one of the reasons why OO languages like C++ evolved -- because people wanted to get away from such languages.

1958

IBM introduces the first computer to use the transistor as a switching device, the IBM 7090, hastening the demise of vacuum tube technology in computers.

Seymour Cray builds the first fully transistorized computer for Control Data Corporation, the CDC 1604.

1959

Doug Englebart initially develops such theoretical concepts as windows, mouse, multitasking, and even remote procedure calls.

L. R. Johnson coins the term "architecture" in reference to the IBM 7000 series mainframes which are introduced in 1959.

1960

COBOL is developed as the first standardized business computer programming language. COBOL would be the most popular/prolific language until 1980.

1961

IBM introduces the highly successful 1400 series mainframes. Their success makes the case for general-purpose computers rather than specialized systems.

1962

Ole-Johan Dhal and Kristen Nygaard develop the Simula programming language at the Norwegian Computing Center (NCC) in Oslo between 1962 and 1967. Simula is based somewhat on the ALGOL 60 programming language. In many ways, this is where it all begins: Simula is pretty much the first object-oriented programming language ever. Together with the representational systems in AI in the 1960s (which give birth to later frame-based knowledge representations) a very large portion of modern OO development techniques are derived.

1964

John Kemeney and Thomas Kurtz initially develop BASIC (Beginner's All-purpose Symbolic Instruction Code) programming language at Dartmouth College.

IBM announces the first computer using integrated circuits.

1965

DEC introduces the PDP-8, the first commercially successful minicomputer.

1967

The first paper is published about the Advanced Research Projects Agency Network (ARPANET).

1968

Edsger Dijkstra pens his famous letter entitled "GO TO Statement Considered Harmful" -- perhaps the first stone cast in the battle against spaghetti code.

Doug Englebart publicly unveils his revolutionary concepts at the Joint Computer Conference in San Francisco.

1969

The U.S. Department of Defense commissions ARPANET.

1970 (cca)

Alan Kay coins the terms "object-oriented" and "object-oriented programming."

1971

The first e-mail program is developed.

Niklaus Wirth of the Technical University of Zurich introduces the Pascal programming language. Pascal eventually forms the basis for many subsequent languages such as Modula-2, Modula-3 and Object Pascal, the popular object-oriented language in Borland Delphi. The work of Wirth and other fathers of structured programming (like Edsger Dijkstra, see also the entry for 1968) founds the modern discipline of software engineering.

First commercially available microprocessor and first floppy disk are released.

1972

Dennis Ritchie develops the initial version of C at Bell Laboratories.

Bell Laboratories begins development of the UNIX operating system, using C.

Nolan Bushnell develops PONG.

1973

Xerox develops Smalltalk, one of the first object-oriented languages, in the Learning Research Group at Xerox's Palo Alto Research Center (Xerox PARC). Alan Kay is credited as the originator of the major elements of the language which is based on Simula, LISP and SketchPad with theories based on biological concepts such as "cells" communicating with each other.

Robert Metcalfe presents ideas about the Ethernet method of network connection while at the Xerox Palo Alto Research Center. The basic idea of "Internetting" is born.

Donald Knuth lays down the foundations of modern software engineering in a number of now-classic works.

1974

The first Article on the Transmission Control Program (TCP) is published.

The first public packet switching network is deployed.

1975

The first microcomputer, the Altair, is introduced. (The same year, Bill Gates and Paul Allen write their BASIC compiler for the Altair).

The first supercomputer, the Cray-1, is introduced.

Marvin Minsky introduces "frames" in artificial intelligence (AI) programming, which are an ancestor of modern "objects" in later languages such as C++.

First International Conference on Very Large Data Bases (VLDB) is held in Framingham, Massachusetts. During the conference, such concepts as database abstraction and multi-level architectures for relational databases are discussed, laying the groundwork for modern client/server databases.

Guy Lewis Steele Jr. and Gerald Jay Sussman invent Scheme programming language (based on LISP) while at MIT.

1976

Digital Equipment Corporation introduces its popular minicomputer, the VAX 11/780.

Steve Wozniak and Steve Jobs begin producing Apple computers in a garage, with the highly successful Apple ][ shipping shortly after.

1977

USENET is established.

The personal computer revolution begins with the launch of the affordable Apple ][, Commodore PET (Personal Electronic Transactor) and the Tandy Radio Shack TRS-80 in the same year.

1978

Brian W. Kernighan and Dennis M. Ritchie publish The C Programming Language, after years of development. While not object-oriented itself, C heavily influences or forms the basis of many modern OO programming languages such as C++, Objective C, Java, and C#.

Dan Bricklin and Bob Frankston develop the first electronic spreadsheet, called VisiCalc, for the Apple computer. VisiCalc is perhaps the world's first "killer app."

Niklaus Wirth enhances and expands on his Pascal programming language and introduces Modula-2.

1979

The U.S. Government publishes the preliminary specification of the Ada programming language. Originally named "green" for the color of the cover of the report in which it was first described, it is later named for the first programmer, Ada Augusta King.

Mike Cowlishaw develops the initial version of REXX (Restructured Extended Executor) programming language at IBM.

1980

Bjarne Stroustrup invents object-oriented extensions to C and calls the new language "C with Classes" while at Bell Laboratories. These object-oriented features were inspired in part by earlier object-oriented languages such as Simula-67.

Grady Booch develops a design process for Ada -- referred to as Booch Diagrams -- that evolves and is eventually applied to other object-oriented languages.

Winchester hard drive is introduced (today known as the "hard drive").

1981

IBM introduces the IBM Personal Computer based on the Intel 8088 Microprocessor running at 4.77 MHz.

IBM ships PC-DOS 1.0 with the IBM PC. Microsoft ships MS-DOS shortly afterwards and licenses MS-DOS.

1982

Sun Microsystems introduces its first workstation, the Sun 100.

TCP/IP protocol suite becomes the standard for "the Internet."

The computer is named Time magazine's Man of the Year.

Object-oriented concepts with databases gain prominence as they are discussed at conferences such as the Eighth International Conference on Very Large Data Bases (VLDB) in Mexico City, Mexico.

1983

A committee is formed by the American National Standards Institute (ANSI) to standardize C.

Stroustrup's "C with Classes" is renamed "C++."

The Ada language standard is adopted by the U.S. government and by the American National Standards Institute (ANSI).

1984

Apple introduces the Macintosh, the first mainstream computer with a graphical user interface (GUI).

Richard Stallman founds the GNU Project.

Domain Name Server (DNS) is introduced.

The number of hosts on the Internet exceeds 1000.

1985

Digital Research releases GEM (Graphics Environment Manager), beating Windows to market.

Microsoft releases first version of Windows (version 1.0).

The Commodore Amiga and Atari ST ship. Both feature advanced GUIs and multimedia capabilities and are touted as "color Macintoshes."

The first commercial CD-ROM drives ship based on Sony and Philips technology.

Bjarne Stroustrup publishes The C++ Programming Language, thus allowing C++ to beat out Objective-C and other contenders. It emerges as the dominant object-oriented language in the computer industry.

Bertrand Meyer introduces Eiffel programming language.

1986

The National Science Foundation Network (NSFNET) is created, forming a backbone for network connectivity. Several similar networks around the world eventually combine with this network to create the foundation for the modern Internet.

Intel ships the 80386 chip.

Network News Transfer Protocol (NNTP) is introduced.

The International Organization for Standards (ISO) develops and standardizes Standard Generalized Markup Language (SGML).

First Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA) is held in Portland, Oregon.

International Workshop on Object-Oriented Database Systems (OODBS) is held in Pacific Grove, California.

1987

IBM and Microsoft announce OS/2 1.0.

Microsoft ships Windows 2.0, which can utilize the protected mode of Intel's 80286 processor, thus breaking the DOS memory barrier.

William Atkinson, an engineer at Apple, designs HyperCard, an interactive rather than language-based programming tool with strong user-interface features. This revolutionary concept helps lay the foundation for visual component-based programming and rapid application development (RAD).

Larry Wall develops and releases Perl 1.0 (Practical Extraction and Report Language) scripting language.

Digital Equipment Corporation and Olivetti develop the Modula-3 programming language to correct some of the deficiencies of Pascal and Modula-2.

The number of hosts on the Internet exceeds 10,000.

1988

The second Edition of Kernighan and Ritchie's The C Programming Language is published, incorporating the latest standards of the proposed ANSI C specification.

John Ousterhout develops Tcl (Tool Command Language) while at University of California, Berkeley.

The first issue of the Journal of Object-Oriented Programming (JOOP) is published.

IBM's OS/2 1.1 with Presentation Manager ships. It is the first OS/2 with a GUI.

1989

Tim Berners-Lee's proposal regarding information management and networks is written and circulated at CERN (the European Particle Physics Laboratory).

The Object Management Group (OMG) is founded. It is committed to developing vendor independent specifications for the software industry. (The consortium includes about 800 members as of the year 2000.) The OMG begins development of specifications for Common Object Request Broker Architecture (CORBA). CORBA is essentially middleware between applications and communications that provides interoperability between systems and data.

The ANSI C standard is finally adopted.

The Internet Engineering Task Force (IETF) is established.

The number of hosts on the Internet exceeds 100,000.

1990

Microsoft releases Windows 3.0 operating system, the first popular version of Windows. It offers significant improvements including Program Manager, File Manager and improved stability. It immediately dominates the market.

Microsoft releases first version of Visual Basic, ushering in a concept that eventually comes to be known as Rapid Application Development (RAD). Programming with visual objects becomes a mainstream concept.

A project based on Berners-Lee's proposal of 1989 is started. The name World Wide Web is conceived and the first WWW WYSIWYG (What You See Is What You Get) browser/editor is produced on a NeXT computer. Berners-Lee develops initial version of HTML and other key WWW concepts.

ARPANET ceases to exist.

The Object Management Group (OMG) defines the Object Management Architecture (OMA) to describe how applications could interoperate based on object-oriented concepts. The OMA defines the major parts that make up a CORBA installation. The term "ORB" (Object Request Broker) gains prevalence.

Guido van Rossum develops Python, an interpreted, interactive, object-oriented programming language.

Baezner, Lamoe and Unger describe Sim++, a distributed, discrete-event simulation language.

1991

Sun Microsystems develops the Java programming language as part of a research project to create software for consumer electronic devices like TVs and VCRs. It contains many object-oriented programming features similar to C++.

The first CERN seminar on the WWW is held.

WWW is announced in the CERN newsletter, and a WWW browser is demonstrated at Hypertext '91 in San Antonio, Texas.

Wide Area Information Servers (WAIS) and Gopher are introduced.

The Trojan Room Coffee Pot camera is put up at Cambridge University's Computer Laboratory, the first client/server application written to use the lab's then-new RPC mechanism.

Guido van Rossum releases Python to USENET.

1992

The first major specification of Common Object Request Broker Architecture (CORBA) version 1.1 is made available based on a joint proposal by DEC, HP, Hyperdesk, NCR, ODI, and SunSoft.

IBM's OS/2 2.0 begins shipping. The release includes IBM's Systems Object Model (SOM), a multi-platform and language-neutral object model compliant with CORBA 1.1.

An alliance of companies including Apple, IBM and Lotus begin developing OpenDoc. OpenDoc is a multi-platform and language-neutral object model based somewhat on IBM's SOM.

Microsoft releases the Windows 3.1 operating system.

The first GUI client for X is completed.

The number of hosts on the Internet exceeds 1 million.

1993

The first release of Marc Andreessen's Mosaic is unveiled at the National Center for Supercomputing Applications (NCSA).

WWW is presented at Online Publishing '93, Pittsburgh, PA.

Microsoft releases the initial version of Windows NT, after Microsoft and IBM separate their development efforts from OS/2.

Microsoft ships the first version of Component Object Model (COM). COM competes with OpenDoc and CORBA, but is not CORBA-compliant. COM forms the basis of -- or is directly related to -- other Microsoft technologies such as Object Linking and Embedding (OLE), ActiveX, Distributed COM (DCOM), and others.

Microsoft gains the reputation of the confusing practice of naming and renaming similar technologies based on marketing needs.

OpenDoc is licensed by the Component Integration Laboratories (CILabs). CILab's initial supporters include Apple, IBM, Novell, Oracle, SunSoft, Taligent, WordPerfect, and Xerox. Their goal is to develop object-oriented interoperability across all major platforms.

IONA (formerly part of Trinity College) ships its ORBIX product, which enables distributed computers and software systems to work together collaboratively. Other major Object Request Broker (ORB) software developers also begin to market their products.

The Trojan Room Coffee Pot is put on the Web. It is believed to be the first image on the WWW.

1994

The first draft of the proposed ANSI standard for C++ is released.

Linux 1.0 is released by Linus Torvalds, launching the modern "open source" movement.

Mosaic Communcation Corp. (later to become Netscape) is formed by Marc Andreessen, James Clark et al.

The first International WWW Conference is held at CERN, Geneva.

Sun's Java becomes noticed when the HotJava browser is released.

Perl 5 is released. It is a major rewrite of previous versions, and the first to add OO capabilities to the popular scripting language.

Rasmus Lerdorf creates the initial version of Hypertext Preprocessor (PHP), an open-source server scripting language similar to C.

Initial CORBA 2.0 specification is released; it specifies how ORBs from different vendors can interoperate.

IBM releases OS/2 Warp 3.0.

The Unified Modeling Language (UML) takes its initial form as the main object-oriented design and analysis methodologists (Grady Booch, Ivar Jacobson, and Jim Rumbaugh) join forces to define a method for specifiying, visualizing and documenting the elements of an object-oriented system. The UML standard builds on Booch, OMT and OOSE methods and is developed under the auspices of the Open Management Group (OMG).

The W3 Consortium is formed, and the first meeting is held at MIT in December.

1995

NSFNET ceases to be the main U.S. backbone and is replaced by network providers.

WWW becomes the service with the greatest traffic.

The Apache Group is organized and the Apache HTTP Server Project is founded to develop open-source web server software based on NCSA's httpd server. Apache uses modules rather than components, but the ideas are similar in many ways.

Sun Microsystems officially launches Java to the public with free client software.

Micosoft releases the 32-bit Windows 95 operating system, a major milestone for Windows and a significant upgrade from 3.x. Win32, the API in Windows 95 and NT, includes further enhancements to OLE, based originally on Microsoft's COM.

Microsoft's Visual Basic gains widespread use with VBX (Visual Basic Custom Control) technology. VBX components are eventually replaced by ActiveX controls and components, which are based on evolving COM technology.

Microsoft releases the first version of its DirectX software development kit.

Borland releases Delphi 1, a Rapid Application Development (RAD) programming environment. It is the first mainstream object-oriented visual development tool with an optimizing native-code compiler and scalable database engine. Delphi is based on an object-oriented version of Pascal called "Object Pascal." Borland quickly follows the release of Windows 95 with a 32-bit version of Delphi, becoming the first 32-bit RAD tool. http://www.borland.com

Microsoft introduces the term Distributed COM (DCOM), replacing the short-lived term Network OLE, which is based on OLE/COM with networking capabilities.

IBM introduces SOMobjects.

1996

Sun releases Java Development Kit (JDK) 1.0.

The first JavaOne developer conference is held. JavaBeans technology-based components are announced along with Java Media APIs, servlets and other similar technologies.

Microsoft coins the term ActiveX at the Internet Professional Developers Conference (Internet PDC) in March.

Microsoft ships Windows NT 4.0. It features the Windows 95 user interface and numerous bundled server processes, notably its Internet Information Server (IIS) Web server.

Microsoft publishes specifications for the Distributed Component Object Model (DCOM), which is closely tied to ActiveX.

Sun announces the availability of Java Objects Everywhere (JOE), an interfacing technology between Java/Web front ends and CORBA application services for complex Web-based applications.

Sun introduces the Java Database Connectivity (JDBC) API specification, the first standardized effort to integrate relational databases with Java programs.

Microsoft releases Internet Explorer 3.0, which begins to make up significant ground on Netscape's Navigator.

IBM releases Domino (version 4.5 of the Notes server product) which allows developers to quickly build, deploy and manage Notes applications over the Internet.

Allaire releases ColdFusion, an application server with Cold Fusion Markup Language (CFML) that integrates server-side, Web-oriented scripting, allowing developers to build advanced Web/database applications. This sparks a trend of many application server tools from many vendors.

The KDE project is founded.

NeXT pushes Web Objects.

1997

Sun ships its JavaBeans Development Kit.

Sun ships JDK 1.1, which includes Remote Method Invocation (RMI), a set of protocols that enable Java objects to communicate remotely with other Java objects. It is a relatively simple protocol that shares similarities with CORBA and DCOM and works only with Java objects.

Sun announces Enterprise JavaBeans (EJB) technology.

Sun ships its Java Web Server 1.0 product.

IBM releases an object-oriented version of the REXX programming language called Object REXX.

Microsoft releases Internet Explorer 4.0 and gains dominance in browser technology.

Microsoft ships Internet Information Server (IIS) 3.0 with integrated Active Server Pages (ASP) that have object-oriented, server-side scripting capabilities featuring VB Script, JavaScript, and integration with COM components for Web applications.

The GNOME project begins.

1998

Sun releases Java SDK 2.0.

W3C publishes recommendations for Extensible Markup Language (XML) 1.0.

Microsoft launches Windows 98.

Microsoft ships Internet Information Server (IIS) 4.0 with Active Server Pages (ASP) 2.0 and integrated Microsoft Transaction Server (MTS) 2.0. MTS is an object-oriented middleware technology that allows, among other things, applications to scale across systems to support a large number of users.

Microsoft announces the first iteration of COM+.

The ANSI C++ standard is published.

BEA launches BEA ME (soon to be known as WebLogic Enterprise), the first object transaction monitor.

Netscape releases source code for its Navigator Web browser and makes it freely available to the public. The Mozilla Organization coordinates how this source code is developed. The Mozilla Project includes XPCOM, a "lightweight cross-platform COM work-alike."

The first stable (1.0) release of K Desktop Environment (KDE) for Linux is released at the beginning of the year.

GNOME 0.99 is released at the end of the year, and 1.0 enters code freeze.

EiffelBase libraries are released as open source.

1999

Sun Jini, Sun's technology for object-oriented distributed computing applications, is announced.

Sun unveils JavaServer Pages (JSP) technology and licenses JavaServer Pages framework to Apache.

Sun ships J2EE (Java 2 Platform Enterprise Edition). The Java 2 platform integrates RMI (Remote Method Invocation) over IIOP (Internet Inter-ORB Protocol), Java IDL (Interface Definition Language), Java ORB and CORBA support.

GNOME 1.0 is released at the first Linuxworld Conference and Expo in San Jose; work begins on Bonobo, the GNOME component architecture.

2000

1 GHz mainstream computers with CPUs from AMD and Intel are widely available.

Microsoft releases Windows 2000 and Internet Information Server (IIS) 5.0 with ASP 3.0.

Microsoft officially changes the name of its middle-tier, run-time environment from MTS to COM+ to reduce confusion. With the release of Windows 2000, key elements of COM/DCOM and MTS have been integrated into this new run time.

Sun releases J2SE (Java 2 Platform Standard Edition) v.1.3 platform and gains industry support from Apple with Mac OS X.

Sun acquires StarOffice, then "componentizes" it using a new component architecture dubbed UNO (Universal Network Objects). Plans are to integrate OpenOffice with GNOME's Bonobo.

KDE 1.90 Beta includes KParts, the KDE component object model. KDE 2.0 is released.

SOAP (Simple Object Access Protocol) is released.

Web services initiatives are announced throughout the industry: IBM introduces Web services, HP introduces e-speak, Sun introduces ONE, Microsoft introduces .NET.

Microsoft announces C#.

IBM ships WebSphere with support for Java servlets, JavaServer Pages, XML, EJB components, and CORBA. This is a good example of the growing trend of Web server appliances and application servers that make use of the latest object-oriented technologies and standards.

Microsoft ships Windows Me.

Official CORBA 2.4 specification is released.

Larry Wall and Nathan Torkington announce plans for a complete rewrite for Perl 6.

The StarOffice source hits the Net at OpenOffice.org.

Ajuba Solutions is acquired by Interwoven, and decides to discontinue Tcl development. Tcl development is turned over to the Tcl core team, and Interwoven releases TclPro as open source.

Mozilla 0.6 is released.

2001

Borland ships Kylix, the first native rapid application development tool for Linux. It is modeled on Delphi and C++ Builder and features CLX components/objects, which include many visual, nonvisual, database, and networking components.

Trojan Room Coffee Pot is taken down.

CORBA 3.0 is due out.

Bonobo will be included in the GNOME 1.4 final release.

Resources

About the author
James Durham is a multimedia guru who began programming in C and developing advanced content on the first Sun workstations and the original PIXAR Image Computer. He currently develops for Linux, Windows and MacOS and specializes in C++, Delphi and PHP, among others. He produces multimedia content such as video and animation with a speciality in the "most open-source and cross-platform" of all media -- music. His four-fold approach to problem-solving comprises: 1) a great deal of creativity, 2) a sound technical understanding, 3) a bit of money and 4) a sense of humor.
You can reach him at jdurham@ion1.com.