Entry
OOP: History: What were the origins of object oriented programming? [Alan Kay / Smalltalk]
May 16th, 2005 06:30
Knud van Eeden,
----------------------------------------------------------------------
--- Knud van Eeden - 24 October 2001 - 08:44 am ----------------------
OOP: History: What were the origins of object oriented programming?
[Alan Kay / Smalltalk]
---
The basis of Object Oriented Programming can be found in the
programming language Simula (originally used for simulations for the
Norwegian army), created by Ole-Johan Dahl (Norway) and Kristen Nygaard
(Norway).
---
This language and its ideas influenced e.g. Alan Kay (USA) (who
developed Smalltalk), and Bjarne Soustrup (Denmark) (who developed C++)
===
About Alan Kay:
===
[Internet: source: http://www.google.com: search for '"alan kay"
biography': http://ei.cs.vt.edu/~history/GASCH.KAY.HTML]
While studying at the University of Utah he learned to use the
innovative SketchPad program developed by Ivan Sutherland and began
programming in Simula. Borrowing ideas from these and other programs,
as well as from his background in Biology, he formulated his
"biological analogy." Kay postulated that the ideal computer would
function like a living organism; each "cell" would behave in accord
with others to accomplish an end goal but would also be able to
function autonomously. "Cells" could also regroup themselves in order
to attack another problem or handle another function.(3)
===
[Internet: source: http://www.google.com: search for '"alan kay"
smalltalk biology': http://www.rheingold.com/texts/tft/11.html]
Papert called these simulated universes "microworlds," and used
LOGO-created microworlds to teach logic, geometry, calculus, and
problem-solving to ten-year-olds. Part of the fascination of a good
video game lies in the visual impact of its microworld representation
and the amount of power given to the player to react to it and thus
learn how to control it. In Smalltalk, every object was meant to be a
microworld.
...
Starting from concepts set forth in LOGO and in Simula, Kay began to
devise a new metaphor in which the string of one-at-a-time instructions
is replaced by a multidimensional environment occupied by objects that
communicate by sending one another messages. In effect, he started out
to build a computer language that would enable the programmer to look
at the host computer not as a serial instruction follower, but as
thousands of independent computers, each one able to command the power
of the whole machine.
===
Alan Kay by Scott Gasch
**
Alan Kay, Springfield, MA; Alan Kay is one of the inventors of the
Smalltalk programming language and one of the fathers of the idea of
Object
Oriented Programming. He is the conceiver of the laptop computer and
the
architect of the modern windowing GUI.
===
-----------------------------------------------------------------------
-
"The best way to predict the future is to invent it."
--Alan Kay
-----------------------------------------------------------------------
-
===
Education: Alan Kay
B.S., Mathematics and Molecular Biology, University of Colorado, 1966;
M.S., Electrical Engineering, University of Utah;
Ph.D., Computer Science, University of Utah, 1969;
---
Professional Experience
Professor, Stanford Artificial Intelligence Laboratory, 1970;
Group Leader, Xerox Palo Alto Research Center, 1972
Programmer, Atari, 1983
Apple Fellow, Apple Computer, 1984
===
[magazine: source: PC Magazine - september 4 - 2001 p. 187 'the
perfect architecture']
He inspired the most important innovation in the history of software,
and no one knows his name. He was a programmer stationed at Denver's
Randolph Air Force base sometime in the late 1950's, writing assembly
language code and feeding it on spools of magnetic tape to a Burroughs
220 vacuum tube computer. That worked well enough. What was virtually
impossible, though, was to move data from the Burroughs machine at the
base to computers at other air training command installations. No
operating systems or standard file formats existed, so a person could
not e-mail a Microsoft Word document or hand an Excel file on a disk to
a colleague and expect it to be readable by any machine. Raw data could
be copied from the Burroughs onto tape, but other computers would not
be able to make sense of the jumble of ones and zeroes. The anonymous
programmer came up with an ingenious solution. He transformed the
Burroughs data files into mini-programs, little sufficient modules of
code. Inside each of these, he included both the data and the
procedures needed to manipulate that data. He then hid the data and
code behind a simple interface, which lets the computer understand the
module, without knowing anything about how the inside was formatted. In
this way, a module could supply not only the data to disparate
machines, but also a means of decoding it. All the computer needed to
know was how to decipher the simple outer interface. When Alan Kay
first used this file system as a new recruit at Randolph in 1961, he
knew it was clever, but he did not completely appreciate its importance
until several years had passed, well after the programmer's name had
been lost to history. "I did not get the big grog until 1966", says
Kay, now well known in computer circles as a cofounder of Xerox's
seminal Palo Alto Research Center (PARC), where the overlapping-windows
interface, Ethernet, laser printing, and the laptop were invented. Kay
caught on, though, when he realized that this innovative file system
could not only open up the lines of communication between machines, but
also improve the way entire software applications were designed.
Within six years, in Kay's hands at Xerox PARC, this idea evolved into
object oriented programming, the revolutionary computing concept that
is the foundation for most of today's high-level software development
languages, including C++ and Java.
Mimicking the Randolph system, this new approach involved dividing into
a series of modules, which Kay called 'objects', each one a little
nugget of data and instructions that performs a specific task, and each
fronted by a little interface.
Lots of objects plugged together formed complete applications.
One object never knew what went on inside another, but through the
interfaces, objects collectively completed tasks they could not on
their own.
Thanks to object oriented programming, a friend can send you an Excel
spreadsheet as an e-mail attachment, and your computer knows what to do
with it.
---
The biological imperative
Kays favorite metaphore for his programming language, which eventually
was named Smalltalk, is a BIOLOGICAL SYSTEM.
The most obvious parallel is the human body, which is divided into
trillions of cells, each performing its own specialized task.
Like objects in software produced with object-oriented programming,
human cells do not know what goes on inside one another, but they can
communicate nevertheless, working together to perform more complex
tasks. "This is an almost foolproof way of operating", Kay says.
By mimicking biology in this way, we can minimize many of the problems
inherent to the construction of a complex computing system. A developer
can focus on one simple module at a time, making sure it works
properly, and move on to the next. Not only is building a system this
way easier, but the system will be much more reliable. And when it does
break down, it is simpler to fix, because problems are typical
contained within individual modules, which can be repaired and replaced
quickly. By contrast, a monolithic system is like a massive mechanical
clock containing innumerable turning gears, none of which has its own
internal logic or communicates information. Each gear functions
unintelligently and only in relation to other gears. The design is
hopelessly flawed. "When you are building gear clocks, eventually you
will reach a certain level of complexity and it falls in on itself",
says Kay.
That he would view his programming language in terms of molecular
sciences and not electronic engineering is apt, because that comparison
in many ways sums up the remarkable development of computing in the
past 60 years. Although it may not be immediately apparent, from the
days of the first computer to now, developers have made greater and
greater use of biological concepts (think about neural networks for
example).
Whether the first room-filling machines, minicomputers, personal
computers, PDAs, Microsoft Word, or the Internet, each generation has
created even more complex systems by piecing together ever simpler
subsets.
===
[Internet: source: http://www.google.com: search for 'What were the
origins of object oriented programming?':
http://www.ddj.com/articles/2001/0101/0101a/0101a.htm]
---
Objects: The Center of Change
As this new class of programmers rapidly learned what was already
known, programming as a discipline continued to progress. While there
were many important innovations in software development overall,
perhaps the most significant over the past 25 years was the widespread
adoption of object-oriented programming.
Object-oriented programming has many roots, both in computer science
and elsewhere. Object-oriented languages can be traced back to the
1950s with Lisp and the late 1960s with Simula. Alan Kay, who coined
the term "object-oriented programming" as a researcher at Xerox PARC,
found some inspiration for his Smalltalk language from cell biology and
the works of the philosopher/mathematician Leibniz.
Most importantly, Kay was motivated to create Smalltalk and the
principles of object-oriented programming by a larger goal: pervasive
personal computing. In 1971, Kay predicted that personal computers
would be widespread and networked, and that for this to happen,
software had to meet three characteristics _ zero replication time and
cost, high development time and cost, and low change time and cost.
Certainly, all three characteristics were desirable for all software,
even in a world without personal computers. However, personal computers
made such characteristics urgent necessities.
Smalltalk (and object-oriented programming in general) was a way to
achieve these goals. In theory, programs would be easier to write
because they were modeled on things that were easier to understand.
Smalltalk, in fact, was designed as a programming language for
children. Additionally, programs would be easier to read, and hence,
easier to maintain, vastly reducing the largest costs associated with
software.
Personal computers made graphical user interfaces important because
they improved the interaction between people and machines.
Object-oriented languages like Smalltalk enabled the widespread
adoption of these interfaces. How many programmers ever have to code a
button or a scrollbar from scratch today? And would graphical user
interfaces be as common as they are if more programmers did have to
create and integrate these widgets and their behavior from scratch?
These early graphical widgets eventually led to more general software
components, with the hope that fully functional applications could be
wired together using prewritten objects and minimal coding. While no
one has completely achieved this ambitious goal yet, software today
requires far less coding than its complexity would seem to indicate.
Object-oriented application frameworks such as the Microsoft Foundation
Classes _ love them or hate them _ are largely responsible.
Most importantly, object-oriented programming helped lay the foundation
for many advances in software engineering, from testing techniques to
programming methodologies. Perhaps the most important recent innovation
is design patterns, which were defined and documented in the early
1990s by a number of specialists in the field of object-oriented
design.
Their observation was simple: Software design, even with the benefit of
objects, is complex, and programmers can learn many things from those
who do design well. With this in mind, these researchers began
exploring and analyzing well-designed object-oriented software, and
cataloging the patterns that they discovered. Many of the most common
patterns are recorded in the now classic book
'Design Patterns: Elements of Reusable Object-Oriented Software'
---
---
Book: see also:
---
[book: author = Gamma, Erich / Helm, Richard / Johnson, Ralph /
Vlissides, John - title = Design Patterns: Elements of Reusable Object-
Oriented Software -
http://www.amazon.com/exec/obidos/ASIN/0201633612/qid=1003955249/sr=8-
7/ref=sr_8_129_7/104-7786752-4767928]
---
---
Internet: see also:
---
How Object-Oriented Programming Started
http://heim.ifi.uio.no/~kristen/FORSKNINGSDOK_MAPPE/F_OO_start.html
---
Ole-Johan Dahl
http://en.wikipedia.org/wiki/Ole-Johan_Dahl
---
Kristen Nygaard, Object-Oriented Creator
http://www.sacpcug.org/archives/0208/niobits.html
----------------------------------------------------------------------
