Chapter 8 The Development of Computer Programming Languages

Chapter 8
The Development of
Computer Programming
Languages

570
8.1 The History of Computer
Programming Languages
Ever since the invention of Charles Babbage's
difference engine, computers have required a means of
instructing them to perform a specific task. This means
is known as a programming language. Computer
languages were first composed of a series of steps to
wire a particular program; these morphed into a series
of steps keyed into the computer and then executed;
later these languages acquired advanced features such
as logical branching and object orientation. The
computer languages of the last fifty years have come in
two stages, the first major languages and the second
major languages, which are in use today.

571
In the beginning, Charles Babbage's difference
engine could only be made to execute tasks by
changing the gears which executed the calculations.
Thus, the earliest form of a computer language was
physical motion. Eventually, physical motion was
replaced by electrical signals when the US
Government built the ENIAC in 1942. It followed
many of the same principles of Babbage's engine and
hence, could only be "programmed" by presetting
switches and rewiring the entire system for each new
"program" or calculation. This process proved to be
very tedious.
1942，我国处于民国三十一年，蒋介石任盟军中国
战区最高统帅，中国远征军入缅助英军作战，中国战区
盟军总参谋长史迪威抵重庆就职。

572
• In 1945, John Von Neumann was working at the
Institute for Advanced Study. He developed two
important concepts that directly affected the path of
computer programming languages. The first was
known as "shared-program technique" . This
technique stated that the actual computer hardware
should be simple and not need to be hand-wired for
each program. Instead, complex instructions should
be used to control the simple hardware, allowing it to
be reprogrammed much faster.
1945，我国处于民国三十四年，中国共产党第七次
全国代表大会在延安召开；中国国民党第六次全国代表
大会在重庆召开； 日本政府宣布无条件投降；台湾光
复； 昆明“一二一”惨案发生。

573
• The second concept was also extremely important to
the development of programming languages. Von
Neumann called it "conditional control transfer" .
This idea gave rise to the notion of subroutines, or
small blocks of code that could be jumped to in any
order, instead of a single set of chronologically ordered
steps for the computer to take. The second part of the
idea stated that computer code should be able to
branch based on logical statements such as IF
(expression) THEN, and looped such as with a FOR
statement. "Conditional control transfer" gave rise to
the idea of "libraries," which are blocks of code that
can be reused over and over.

574
8.2 The First Computer Compiler
In 1949, a few years after Von Neumann's
work, the language Short Code appeared . It was
the first computer language for electronic
devices and it required the programmer to
change its statements into 0's and 1's by hand.
Still, it was the first step towards the complex
languages of today. In 1951, Grace Hopper wrote
the first compiler, A-0 . A compiler is a program
that turns the language's statements into 0's and
1's for the computer to understand. This lead to
faster programming, as the programmer no
longer had to do the work by hand.

575
Grace Murray Hopper
Naval officer and
computer scientist
developing the first
compiler and who led
the effort in the 1960s
to develop COBOL

576
• Perhaps her best-known contribution to
computing was the invention of the compiler
(1952), the intermediate program that
translates English language instructions into
the language of the target computer.
• Her work embodied or foreshadowed （预示）
enormous numbers of developments that are
now the bones of digital computing:
subroutines, formula translation, relative
addressing, the linking loader, code
optimization, and even symbolic manipulation
of the kind embodied in Mathematics and
Maple.

577
•It was this kind of positive thinking that Hopper to
invent the first computer "compiler" in 1952. This
revolutionary software facilitated the first automatic
programming of computer language. Before
Hopper's invention, programmers had to write
lengthy instructions in binary code (computer
language) for every new piece of software. Because
binary code consists solely of 0's and 1's, it was
difficult for programmers to get through their timeconsuming
tasks without many frustrating mistakes.
•The compiler was a time and error-saving
breakthrough for the computer world.

578
8.3 FORTRAN Language
In 1957, the first of the major languages appeared in
the form of FORTRAN. Its name stands for Formula
Translating system. The language was designed at IBM
for scientific computing. The components were very
simple, and provided the programmer with low-level
access to the computers innards（内部结构）. Today,
this language would be considered restrictive as it only
included IF, DO, and GOTO statements, but at the
time, these commands were a big step forward. The
basic types of data in use today got their start in
FORTRAN, these included logical variables (TRUE or
FALSE), and integer, real, and double-precision
numbers.

579
FORTRAN, the first high level programming
language, was invented by John Backus for
IBM, in 1954, and released commercially, in
1957. It is still used today for programming
scientific and mathematical applications.
Fortran began as a digital code interpreter for
the IBM 701 and was originally named Speed
coding. John Backus wanted a programming
language closer to human language, which is
the definition of a high level language.

580
• As project leader with IBM
John Backus developed in
the early 1950's with his
team: Fortran. The first
high level programming
language.
• He was also responsible for
the Backus-Naur Form (or
BNF), a standard notation
which can be used to
describe the syntax of a
computer language in a
formal and unambiguous
way.

581
Background
• In 1953, Backus wrote a memo to his boss that
outlined the design of a programming language for
IBM’s new computer, the 704. This computer had a
built-in scaling factor, also called a floating point,
and an indexer, which significantly reduced
operating time. However, the inefficient computer
programs of the time would hamper the 704’s
performance, and Backus wanted to design not
only a better language, but one that would be easier
and faster for programmers to use when working
with the machine.

582
Background
• The challenge Backus and his team faced was not
designing the language, which they felt they could
easily do. Instead, it was coming up with a device
that would translate that language into something
the machine could understand. This device, known
as a translator, would eliminate the laborious handcoding
that characterized computer programming
at the time. It contained an element known as a
parser, which identified the various components of
the program and translated them from a high-level
language (one that people understand) into the
binary language of the computer.

583
• In the fall of 1954, Backus and his team felt
strongly enough about their research to publish
a paper, called “Preliminary Report,
Specifications for the IBM Mathematical
Formula Translating System, FORTRAN.”
• When completed, the compiler consisted of
25,000 lines of machine code, stored on
magnetic tape. A copy of the program was
provided with every IBM 704 installation,
along with a 51-page manual. The first versions
of the program were understandably buggy,
but later versions would refine and eliminate
them.

584
Value
FORTRAN was designed for mathematicians
and scientists, and remains the preeminent
programming language in these areas today. It
allows people to work with their computers
without having to understand how the machines
actually work, and without having to learn the
machine’s assembly language. That FORTRAN
is still in use 40 years after its introduction is
testimony to Backus’s vision.

585
8.4 COBOL
Though FORTAN was good at handling numbers, it
was not so good at handling input and output, which
mattered most to business computing. Business
computing started to take off in 1959, and because of this,
COBOL was developed. It was designed from the ground
up as the language for businessmen. Its only data types
were numbers and strings of text. It also allowed for
these to be grouped into arrays and records, so that data
could be tracked and organized better. It is interesting to
note that a COBOL program is built in a way similar to
an essay, with four or five major sections that build into
an elegant whole. COBOL statements also have a very
English-like grammar, making it quite easy to learn. All
of these features were designed to make it easier for the
average business to learn and adopt it.

586
Background
• In 1952, Grace Murray Hopper began a
journey that would eventually lead to the
language we know as COBOL.
• She began by developing a series of
programming languages that became more and
more like natural language. The language used
phrases to express the operations of business
data processing. FLOWMATIC was the result
of this evolutionary journey.

587
• Through the 1950's, other computing leaders
were also working through the challenge of
creating a practical business language.
IBM had produced a language named
COMMERCIAL TRANSLATOR.
• In 1959, an industry-wide team was assembled
to formulate a common business programming
language. The Conference on Data System
Languages (CODASYL) led by Joe Wegstein of
National Bureau of Standards (now National
Institute of Standards and Technology)
developed a new language, and created the first
standardized business computer programming
language.

588
Development
COBOL (Common Business Oriented
Language) was developed under the auspices of
the U.S. Department of Defense in cooperation
with computer manufactures, users and
universities. The initial specifications for
COBOL were presented in a report of the
executive committee of CODASYL committee
in April of 1960. It was designed to be a
business problem oriented, machine
independent and capable of continuous change
and development.

589
• Since 1960,COBOL has undergone
considerable updates and improvements. It has
emerged as the leading data processing
language in the business world. The standard
language specification has three levels low,
middle and high so that standard COBOL can
be implemented on computers of varying sizes.
• Despite the attempts at standardization,
variations in COBOL implementations
continue to exist. Most deviations or
"extensions" are intended to take advantage of
hardware or environmental features which
were not defined in the standard definition.

590
• 1968 -- American National Standards Institute
(ANSI) developed a standard form of the
language known as American National
Standard (ANSI) COBOL. This was an attempt
to overcome the incompatibilities of the
different versions of COBOL.
• 1974 -- ANSI published a revised version of
(ANSI) COBOL
• 1985 -- ANSI published another revised
version
• Today -- ISO and ANSI committees have
completed the features of the latest revision of
COBOL 2002.

591
8.5 LISP
In 1958, John McCarthy of MIT created the List
Processing (or LISP) language. It was designed for
Artificial Intelligence (AI) research. Because it was
designed for such a highly specialized field, its syntax
has rarely been seen before or since. The most obvious
difference between this language and other languages
is that the basic and only type of data is the list,
denoted by a sequence of items enclosed by
parentheses. LISP programs themselves are written as
a set of lists, so that LISP has the unique ability to
modify itself, and hence grow on its own. The LISP
syntax was known as “Cambridge Polish,” as it was
very different from standard Boolean logic.

592
•JOHN McCARTHY is
Professor of Computer Science
at Stanford University.
•A pioneer in artificial
intelligence, McCarthy
invented LISP, the preeminent
AI programming language, and
first proposed general-purpose
time sharing of computers.
•He identifies common-sense
rules that determine the
consequences of events and
codifies these rules, along with
other information, as sentences
in the symbolic languages of AI
databases.

593
Background
In 1960, John McCarthy published a
remarkable paper in which he did for
programming something like what Euclid did
for geometry. He showed how, given a handful
of simple operators and a notation for functions,
you can build a whole programming language.
He called this language Lisp, for "List
Processing," because one of his key ideas was to
use a simple data structure called a list for both
code and data.

594
• It seems to that there have been two really clean,
consistent models of programming so far: the C
model and the Lisp model. These two seem points of
high ground, with swampy lowlands between them.
As computers have grown more powerful, the new
languages being developed have been moving steadily
toward the Lisp model. A popular recipe for new
programming languages in the past 20 years has
been to take the C model of computing and add to it,
piecemeal, parts taken from the Lisp model, like
runtime typing and garbage collection.
• When Lisp was first invented, all these ideas were far
removed from ordinary programming practice,
which was dictated largely by the hardware available
in the late 1950s.

595
Characteristic
Computing with symbolic expressions rather than
numbers, representation of symbolic expressions and other
information by list structure in the memory of a computer,
representation of information in external media mostly by
multi-level lists and sometimes by S-expressions, a small
set of selector and constructor operations expressed as
functions, composition of functions as a tool for forming
more complex functions, the use of conditional expressions
for getting branching into function definitions, the
recursive use of conditional expressions as a sufficient tool
for building computable functions, the use of -expressions
for naming functions, the representation of LISP
programs as LISP data, the conditional expression
interpretation of Boolean connectives, the LISP function
eval that serves both as a formal definition of the language
and as an interpreter, and garbage collection as a means of
handling the erasure problem.

596
Towards the end of the initial period, it became clear
that this combination of ideas made an elegant
mathematical system as well as a practical
programming language. Then mathematical neatness
became a goal and led to pruning some features from
the core of the language. This was partly motivated by
esthetic reasons and partly by the belief that it would be
easier to devise techniques for proving programs
correct if the semantics were compact and without
exceptions. The results of (Cartwright 1976) and
(Cartwright and McCarthy 1978), which show that
LISP programs can be interpreted as sentences and
schemata of first order logic, provide new confirmation
of the original intuition that logical neatness would pay
off.

597
8.6 ALGOL
The ALGOL language was created by a
committee for scientific use in 1958. It's major
contribution is being the root of the tree that has
led to such languages as Pascal, C, C++, and
Java. It was also the first language with a formal
grammar, known as Backus-Near Form or BNF
(McGraw-Hill Encyclopedia of Science and
Technology, 454). Though ALGOL implemented
some novel concepts, such as recursive calling of
functions, the next version of the language,
ALGOL 68, became bloated and difficult to use.
This lead to the adoption of smaller and more
compact languages, such as Pascal.
ALGOL (Algorithmic Language) is one of several high
level languages designed specifically for programming
scientific computations. It started out in the late 1950's,
first formalized in a report titled ALGOL 58, and then
progressed through reports ALGOL 60, and ALGOL 68.
It was designed by an international committee to be a
universal language. Their original conference, which took
place in Zurich, was one of the first formal attempts to
address the issue of software portability. ALGOL's
machine independence permitted the designers to be more
creative, but it made implementation much more difficult.
Although ALGOL never reached the level of commercial
popularity of FORTRAN and COBOL, it is considered the
most important language of its era in terms of its influence
on later language development. ALGOL’s lexical and
syntactic structures became so popular that virtually all
languages designed since have been referred to as
"ALGOL - like"; that is they have been hierarchical in
structure with nesting of both environments and control
structures.

599
Significant Language Features
ALGOL was the first second-generation
programming language and its characteristics are
typical of the entire generation. First consider the
data structures, which are very close to first
generation structures. In ALGOL 60 the block
structure was introduced: the ability to create blocks
of statements for the scope of variables and the
extent of influence of control statements. Along with
that, two different means of passing parameters to
subprograms; call by value and call by name.
Structured control statements: if - then - else and the
use of a general condition for iteration control were
also features, as was the concept of recursion: the
ability of a procedure to call itself.
Significant Language Features
•One of the greatest impacts ALGOL 60 had was a result
of its description as found in Naur (1963). A major
contribution of this report was the introduction of BNF
notation for defining the syntax of the language. Overall,
ALGOL is considered to be perhaps the most orthogonal
programming language, meaning it has a relatively small
number of basic constructs and a set of rules for
combining those constructs. Every construct has a type
associated with it and there are no restrictions on those
types. In addition, most constructs produce values. Several
of ALGOL’s other characteristics are listed below:
•Dynamic Arrays - one for which the subscript range is
specified by variables so that the size of the array is set at
the time storage is allocated.
•Reserved Words - the symbols used for keywords are not
allowed to be used as identifiers by the programmer.
•User defined data types - allow the user to design data
abstractions that fit particular problems very closely.

601
Areas of Application
ALGOL was used mostly by research
computer scientists in the United States and in
Europe. Its use in commercial applications was
hindered by the absence of standard
input/output facilities in its description and the
lack of interest in the language by large
computer vendors. ALGOL 60 did however
become the standard for the publication of
algorithms and had a profound effect on future
language development.

602
8.7 Pascal
Pascal was begun in 1968 by Niklaus Wirth.
Its development was mainly out of necessity for
a good teaching tool. In the beginning, the
language designers had no hopes for it to enjoy
widespread adoption. Instead, they
concentrated on developing good tools for
teaching such as a debugger and editing system
and support for common early microprocessor
machines which were in use in teaching
institutions.

603
Niklaus Wirth
For seminal work in
programming
languages and
algorithms, including
Euler, Algol-W,
Pascal, Modula, and
Oberon.
Background and Characteristic
• Pascal grew out of ALGOL. In the 1960s, several
computer scientists worked on extending ALGOL. One
of these was Dr. NiklausWirth of the Swiss Federal
Institute of Technology (ETH-Zurich), a member of the
original group that created ALGOL. In 1971, he
published his specification for a highly-structured
language which resembled ALGOL in many ways. He
named it Pascal after the 17th-century French
philosopher and mathematician who built a working
mechanical digital computer.
• Pascal is very data-oriented, giving the programmer the
ability to define custom data types. With this freedom
comes strict type-checking, which prevented data types
from being mixed up. Pascal was intended as a teaching
language, and was widely adopted as such. Pascal is
free-flowing, unlike FORTRAN, and reads very much
like a natural language, making it very easy to
understand code written in it.

605
• One of the things that killed ALGOL was the
difficulty of creating a compiler for it. Dr.
Wirth avoided this by having his Pascal
compiler compile to an intermediate, platformindependent
object code stage. Another
program turned this intermediate code into
executable code.
• By the early 1980's, Pascal had already become
widely accepted at universities. Two events
conspired to make it even more popular.

606
• First, the Educational Testing Service, the company
which writes and administers the principal college
entrance exam in the United States, decided to add a
Computer Science exam to its Advanced Placement
exams for high school students. For this exam, it chose
the Pascal language. Because of this, secondary-school
students as well as college students began to learn
Pascal. Pascal remained the official language of the AP
exams until 1999, when it was replaced by C++, which
was quickly replaced by Java.
• Second, a small company named Borland International
released the Turbo Pascal compiler for the IBM
Personal Computer. The compiler was designed by
Anders Hejlsberg, who would later head the group at
Microsoft that developed C# and reintroduced
Managed Code back to the world of computing.

607
8.8 BASIC
• BASIC (standing for Beginner's All Purpose Symbolic
Instruction Code) was written (invented) in 1963, at
Dartmouth College, by mathematicians John George
Kemeny and Tom Kurtzas as a teaching tool for
undergraduates. BASIC is a very limited language and
was designed for non-computer science people.
Statements are chiefly run sequentially, but program
control can change based on IF..THEN, and GOSUB
statements which execute a certain block of code and
then return to the original point in the program's flow.
• BASIC has been one of the most commonly used
computer programming languages, a simple computer
language considered an easy step for students to learn
before more powerful languages such as FORTRAN.

608
John Kemeny
will be remembered for
his contributions to
computing and
mathematics education,
and also for the sweeping
changes he brought to
Dartmouth during his
eleven years as president
of this prestigious Ivy
League college.

609
Tom Kurtz
was the most senior
and distinguished
faculty member,
primary founder, force,
and spirit behind the
Computer and
Information Science
Masters program at
Dartmouth.

610
Background
•The first Basic considered to be a full language
implemented on a microprocessor was Li Chen Wang's
"Tiny Basic", which appeared in Dr. Dobbs.
•Basic was the first product sold by Microsoft corporation,
and also the first major case of software piracy - It was
copied widely even before Microsoft made it available
(Bill Gates lost track of a copy on paper tape during a
computer show).
•The name "BASIC" may have come directly or
indirectly from the science of human languages. Before
the second world war, C. K. Ogden wrote a series called
"Basic English". This was a list of 850 English words
which would serve to describe any other word in English
(perhaps by using more than one).
In 1964, students at Dartmouth College needed
better access to computers and a simple, effective
language to write computer programs. First, John G.
Kemeny, who was the chairman of the Department of
Mathematics, and Professor Thomas Kurtz created the
Dartmouth Time-Sharing System, one of the first timeshare
computer systems in the United States; then they
created BASIC computer language so students could
write programs to run on the General Electric GE-225
mainframe that was the heart of the system. On May 1,
1964, two programs written in BASIC ran
simultaneously on the Dartmouth time-shared system
and both accomplishments would change computing
forever. Ten years later, a version of BASIC written by
Bill Gates and Paul Allen was included on the Altair, the
first personal computer, and after three decades, BASIC
is by far the most popular computer programming
language.

612
• In the early 1960s, John Kemeny believed a new
language was necessary to enable non-science students
to use computers. In addition, for the time-sharing to
be successful, the new language would need to be
simple. Thomas Kurtz; however, felt that a subset of
the FORTRAN or ALGOL languages could be used.
While attempting to change FORTRAN, they realized
the result would in fact be a new language, and the two
men then began work on BASIC.
• True Basic is an ANSI Standard Basic developed by
John Kemeny and Thomas Kurtz, the authors of the
original Basic language. True Basic is a trademark of
True Basic, Inc. and can be obtained through that
company. True Basic is a modern structured language
and may be the most gentle environment for beginning
programmers.

613
Language Features
• Extremely easy to learn
• Powerful enough for applications development
• Fully structured, follows modern programming
concepts
• Integrated environment with source, command,
and output windows
• Full-featured editor
• Instructive demo programs included
• User-extensible function set
• Very close to ANSI Standard BASIC
• Versions for most popular operating systems.

614
Microsoft has extended BASIC in its Visual
Basic (VB) product. The heart of VB is the form,
or blank window on which you drag and drop
components such as menus, pictures, and slider
bars. These items are known as "widgets."
Widgets have properties (such as its color) and
events (such as clicks and double-clicks) and are
central to building any user interface today in any
language. VB is most often used today to create
quick and simple interfaces to other Microsoft
products such as Excel and Access without
needing a lot of code, though it is possible to
create full applications with it.

615
8.9 C
• In the 1970s, Dennis Ritchie and Brian Kernighan
of AT&T Bell Laboratories created the C
Programming Language. Ritchie then collaborated
with Ken Thompson to design the UNIX operating
system.
• The development of Unix in C made it uniquely
portable and improvable.
• Because of this, C and Unix go hand in hand. Unix
gives C such advanced features as dynamic
variables, multitasking, interrupt handling, forking,
and strong, low-level, input-output. C is very
commonly used to program operating systems such
as Unix, Windows, the MacOS, and Linux.

616
Dennis M. Ritchie
joined Bell Laboratories
in 1968 after obtaining
his graduate and
undergraduate degrees
from Harvard
University. He assisted
Ken Thompson in
creating Unix, and was
the primary designer of
the C language.

617
Kernighan Thompson
is a computer scientist who
worked at the Bell Labs. His
name became widely known
through co-authorship of the
first book on the C
programming language with
Dennis Ritchie. He authored
many Unix programs.

618
Background
The first version of Unix was written in the low-level
PDP-7 assembler language. Soon after, a language called
TMG was developed for the PDP-7 by R. M. McClure.
Using TMG to develop a FORTRAN compiler, Ken
Thompson instead ended up developing a compiler for a
new high-level language he called B, based on the earlier
BCPL language developed by Martin Richard. Where it
might take several pages of detailed PDP-7 assembly
code to accomplish a given task, the same functionality
could typically be expressed in a higher level language
like B in just a few lines. B was thereafter used for
further development of the Unix system, which made the
work much faster and more convenient.

619
When the PDP-11 computer arrived at Bell
Labs, Dennis Ritchie built on B to create a new
language called C which inherited Thompson's
taste for concise syntax, and had a powerful
mix of high-level functionality and the detailed
features required to program an operating
system. Most of the components of Unix were
eventually rewritten in C, culminating with the
kernel itself in 1973. Because of its convenience
and power, C went on to become the most
popular programming language in the world
over the next quarter century.

620
Value
• C has become successful to an extent far
surpassing any early expectations.
• Despite some aspects mysterious to the
beginner and occasionally even to the adept, C
remains a simple and small language,
translatable with simple and small compilers.
Its types and operations are well-grounded in
those provided by real machines, and for
people used to how computers work, learning
the idioms for generating time- and spaceefficient
programs is not difficult. At the same
time the language is sufficiently abstracted
from machine details that program portability
can be achieved.

621
Equally important, C and its central library
support always remained in touch with a real
environment. It was not designed in isolation to
prove a point, or to serve as an example, but as
a tool to write programs that did useful things;
it was always meant to interact with a larger
operating system, and was regarded as a tool to
build larger tools. A parsimonious, pragmatic
approach influenced the things that went into
C: it covers the essential needs of many
programmers, but does not try to supply too
much.

622
• Finally, despite the changes that it has undergone
since its first published description, which was
admittedly informal and incomplete, the actual C
language as seen by millions of users using many
different compilers has remained remarkably stable
and unified compared to those of similarly
widespread currency, for example Pascal and
Fortran. There are differing dialects of C, but on the
whole, C has remained freer of proprietary
extensions than other languages. Perhaps the most
significant extensions are the `far' and `near' pointer
qualifications intended to deal with peculiarities of
some Intel processors. It succeeded in expressing
programs, even including operating systems, on
machines ranging from the smallest personal
computers through the mightiest supercomputers.

623
• C is quirky, flawed, and an enormous success. While
accidents of history surely helped, it evidently
satisfied a need for a system implementation
language efficient enough to displace assembly
language, yet sufficiently abstract and fluent to
describe algorithms and interactions in a wide variety
of environments.

624
8.10 C++
In the late 1970’s and early 1980’s, a new
programming method was being developed. It
was known as Object Oriented Programming,
or OOP. Objects are pieces of data that can be
packaged and manipulated by the programmer.
Bjarne Stroustroup liked this method and
developed extensions to C known as “C With
Classes." This set of extensions developed into
the full-featured language C++, which was
released in 1983.

625
Bjarne Stroustrup
Professor and holder
of the College of
Engineering Chair in
Computer Science

626
Background
Based on the C programming language,
C++ was designed to be used in a C
programming environment on a UNIX
system. C++ retains most of C's efficiency
and flexibility, incorporates all the
features of C, and also supports features
that are unavailable in the C language.
Many of the added features were
designed to support object-oriented
programming.

627
Dr. Bjarne Stroustrup, author of The C++
Programming Language, designed most of the
new language, with additional contributions
from Brian Kernighan and other Bell Labs
staff. In undertaking the project, Stroustrup
borrowed successful features from other older
languages. As a result, C++ incorporates the
concepts of classes and virtual functions from
Simula67. C++ borrows the idea of operator
overloading from Algol 68. These features are
an important part of the support that C++
provides for object-oriented programming.

628
Versions
Early versions of the language were collectively
known as "C with Classes" and lacked many
details that were added later. According to
Stroustrup, the name C++ was coined by Rick
Mascitti. The name is a play on words since
"++" is the C increment operator and can also
be taken to signify the evolution of changes
from C. Stroustrup also points out that the
language is not called D because it does not
remove any features of C, but rather it is an
extension of C.

629
There are several versions of the C++
language, of which Visual C++ is only
one. Other dialects include Borland C++, Turbo
C++, and Code Warrior (Mac). All of these
software packages enable you to create computer
programs with C++, but they all implement the
C++ language in a slightly different manner. In
an attempt to maintain portability of both the C
and C++ languages, the American National
Standards Institute (ANSI) developed a standard
of consistency for C and C++
programming. While we will be working
primarily with this ANSI standard, we will also
be examining the idiosyncrasies of Microsoft
Visual C++ 6.0.

630
Value
C++ was designed to organize the raw power
of C using OOP, but maintain the speed of C
and be able to run on many different types of
computers. C++ is most often used in
simulations, such as games. C++ provides an
elegant way to track and manipulate hundreds
of instances of people in elevators, or armies
filled with different types of soldiers. It is the
language of choice in today's AP Computer
Science courses.

631
8.11 JAVA
•In late 1970’s, Bill Joy, a vice president at Sun
Microsystems, wanted to design a language that
combined the best features of MESA and C. In an
attempt to re-write the UNIX operating system in 1980's,
Joy decided that C++ was inadequate for the job. A
better tool was needed to write short and effective
programs. It was this desire to invent a better
programming tool that swayed Joy, in 1991, in the
direction of Sun's "Stealth Project" - as named by Scott
McNealy, Sun's president.
•The goal of the Stealth Project was to do research in the
area of application of computers in the consumer
electronics market. The vision of the project was to
develop "smart" consumer electronic devices that could
all be centrally controlled and programmed from a
handheld-remote-control-like device.
Background •Members of the Stealth Project, which later became
known as the Green Project, divided the tasks amongst
themselves. Mike Sheradin was to focus on business
development, Patrick Naughton was to begin work on the
graphics system, and James Gosling was to identify the
proper programming language for the project.
•He began with C++, but soon after was convinced that
C++ was inadequate for this particular project. His
extensions and modifications to C++ , were the first steps
towards the development of an independent language that
would fit the project objectives. He named the language
"Oak" while staring at an oak tree outside his office
window! The name "Oak" was later dismissed due to a
patent search which determined that the name was
copyrighted and used for another programming language.
According to Gosling, "the Java development team
discovered that Oak was the name of a programming
language that predated Sun's language, so another name
had to be chosen."

633
"It's surprisingly difficult to find a good
name for a programming language, as
the team discovered after many hours of
brainstorming. Finally, inspiration struck
one day during a trip to the local coffee
shop" Gosling recalls. Others have
speculated that the name Java came from
several individuals involved in the project:
James gosling, Arthur Van hoff, Andy
bechtolsheim.

634
There were several criteria that Oak had to meet in
order to satisfy the project objective given the
consumer electronics target market. Given the wide
array of manufacturers in the market, Oak would have
to be completely platform independent, and function
seamlessly regardless of the type of CPU in the device.
For this reason, Oak was designed to be an interpreted
language, since it would be practically impossible for a
complied version to run on all available platforms. To
facilitate the job of the interpreter, Oak was to be
converted to an intermediate "byte-code" format
which is then passed around across the network, and
executed/interpreted dynamically.

635
Additionally, reliability was of great concern. A
consumer electronics device that would have to be
"rebooted" periodically was not acceptable. Another
important design objective for Oak would then have to
be high reliability by allowing the least amount of
programmer-introduced errors. This was the
motivation for several important modification to C++.
The concepts of multiple-inheritance and operator
overloading were identified as sources of potential
errors, and eliminated in Oak. Furthermore, in contrast
to C++, Oak included implicit garbage collection
thereby providing efficient memory utilization and
higher reliability. Finally, Oak attempted to eliminate
all unsafe constructs used in C and C++ by only
providing data structures within objects.

636
• Another essential design criterion was security. By
design, Oak-based devices were to function in a
network and often exchange code and information.
Inherently, security is of great concern in a networked
environment, especially in an environment as network
dependent as the conceived Oak-based systems. For
this reason, pointers were excluded in the design of
Oak. This would theoretically eliminate the possibility
of malicious programs accessing arbitrary addresses
in memory.
• If Oak were to be widely accepted and used within the
consumer electronics industry, it would have to be
simple and compact, so that the language could be
mastered relatively easily, and development would not
be excessively complex.

637
• To demonstrate how this new language could power
the future of digital devices, the Green Team
developed an interactive, handheld homeentertainment
device controller targeted at the digital
cable television industry. But the idea was too far
ahead of its time, and the digital cable television
industry wasn't ready for the leap forward that Java
technology offered them.
• As it turns out, the Internet was ready for Java
technology, and just in time for its initial public
introduction in 1995, the team was able to announce
that the Netscape Navigator Internet browser would
incorporate Java technology.

638
Value
• Now, nearing its tenth year, the Java
platform has attracted over 4 million
software developers, worldwide use in
every major industry segment, and a
presence in a wide range of devices,
computers, and networks of any
programming technology.
• In fact, its versatility, efficiency, platform
portability, and security have made it the
ideal technology for network computing.

639
• The Java programming language has been
thoroughly refined, extended, tested, and
proven by an active community of over four
million software developers.
• Today, you can find Java technology in
networks and devices that range from the
Internet and scientific supercomputers to
laptops and cell phones, from Wall Street
market simulators to home game players and
credit cards -- just about everywhere.

640
Programming languages have been under
development for years and will remain so for many
years to come. They got their start with a list of steps to
wire a computer to perform a task. These steps
eventually found their way into software and began to
acquire newer and better features. The first major
languages were characterized by the simple fact that
they were intended for one purpose and one purpose
only, while the languages of today are differentiated by
the way they are programmed in, as they can be used
for almost any purpose. And perhaps the languages of
tomorrow will be more natural with the invention of
quantum and biological computers.