Computer Programming: A Brief History

Item Type Senior Project

Authors Mckay, Samuel

Accessibility Purchase College - State University of New York (PC) is

Statement committed to ensuring that people with disabilities have an
opportunity equal to that of their nondisabled peers to participate
in the College's programs, benefits, and services, including those
delivered through electronic and information technology. If you
encounter an access barrier with a specific item and have a
remediation request, please contact lib.ir@purchase.edu.

Download date 12/03/2024 20:10:39

Link to Item http://hdl.handle.net/20.500.12648/13882

 Computer Programming: A Brief History
By Samuel McKay

Submitted to the Board of Mathematics/Computer Science

School of Natural Sciences

in partial fulfillment of the requirements

for the degree of Bachelor of Arts

Purchase College

State University of New York

December 2018

Sponsor: David Jameson

Second Reader: Irina Shablinsky

Abstract

The idea of the modern computer can be traced back to the work of Alan Turing, a

mathematician from England. Turing wrote a paper published in 1937 which utilized theoretical

“universal computing machines” to solve computational problems. These machines are now known as

Turing Machines. Subsequently, programmable models of computation were created by inventor

Konrad Zuse in the 1940s. In the 1950s, the IBM Corporation had created a model called the IBM 704.

These early models of computers had to be programmed using machine instructions and assembly

language. Breakthroughs in programming began with the language of FORTRAN in 1953, and shortly

thereafter with iterations of ALGOL, COBOL and LISP. Over time, computers got smaller and faster, and

programming languages got more efficient and effective at being useful tools for the creation of

programs, by analyzing and synthesizing properties of prior languages. This essay examines a history of

programming languages beginning with FORTRAN and advancing all the way to Rust.

History

In 1953, John Backus directed a group of computer scientists at IBM in the creation of a new

programming language. This language, called FORTRAN (short for Formula Translation), dealt with the

tedious nature of programming in machine code and assembly language. It allowed programmers to use

more natural syntax and semantics when designing computer programs, and permitted them to do so in

less time with less code. The utility of FORTRAN led to its adoption by many scientists and engineers,

and the practicality of its high-level nature set a precedent for future programming languages. FORTRAN

was released with 32 statements, including a GO TO statement.

 A few years later, ALGOL was conceived by a committee of computer scientists (including

Backus) in Zurich in 1958. The language was formulated to improve upon potential shortcomings of

FORTRAN and introduce new and useful features. ALGOL was very influential in that it specified many

constructs and mannerisms utilized by later languages; many languages are considered to be “ALGOL-

like” for this reason. Some of the features that ALGOL introduced were the delimitation of code into

blocks and functions, features that would become staples of nearly all languages to come.

The Committee on Data Systems Languages (CODASYL) convened in 1959 to create a language

called COBOL, an acronym for Common Business Oriented Language. As the name suggests, the

language was designed to be used by commercial businesses, whose employees would not have had

experience with programming. To this end, a few design considerations were taken into account: the

language had to avoid special symbols and utilize the English language in its syntax, and it had to

operate on large quantities of data. Programs contain four distinct divisions, an identification division to

denote who wrote a program, an environment division to express the idiosyncrasies of the local system,

a data division to mark the kinds of data that the program would process, and a procedure division to

describe the code that would be executed in order to process the data. As a result of its design goals,

the programming language suffered from verbosity and lack of structure. Nonetheless, it found use in

commercial applications, and is still the backbone of many codebases today.

In 1958, John McCarthy invented a language called LISP. It was originally implemented on the

IBM 704 for a project called the Advice Taker. The name LISP derives from “List Processor”, alluding to

LISP’s primary structure, the list. LISP is different from FORTRAN, ALGOL and COBOL in many ways. An

obvious difference is its syntax. In order to represent its lists, Lisp utilizes s-expressions, or symbolic

expressions. Symbolic expressions are built from the concatenation of functions which operate on

symbolic expressions, lists, which themselves may contain symbolic expressions, and atoms. Due to the

nature of symbolic expressions, Lisp is very flexible, and programs may be written which manipulate
programs. Lisp has been revised and adapted into many forms, including Common Lisp and Scheme, but

does not find too much application today.

Smalltalk was created in 1972 at the Learning Research Group of Xerox Parc by a team of

engineers. Based on Simula, the first language to introduce object-oriented programming, Smalltalk took

the concept of the object, and implemented a way for them to communicate. Objects had the capability

to pass messages to one another. This communication is realized in many future programming

languages via methods and events. The legacy of Smalltalk lives on in many of today’s popular

programming languages such as C++ and Java, and the adaptations of the language by Cincom and

GemTalk find usage by modern companies as large as JPMorgan Chase even in the present day.

Pascal was born in 1970 from a revision to ALGOL 60 by Niklaus Wirth. Wirth’s revisions to

ALGOL 60 included a system for strings as well as syntactic simplification. When Wirth’s changes were

rejected, he designed his own compiler for the new language, called ALGOL W. Soon thereafter, Wirth

continued work on the language, seeking one that could be compiled and run efficiently, and utilize

well-structured code. A potential influence on Wirth’s interest in structured programming was Edgar

Dijkstra’s 1968 paper entitled “Go To Statement Considered Harmful.” In this paper, Dijkstra posits that

the usage of the go to statement leads to code which is harder to reason about, and that the usage of

various control flow structures such as if statements, while loops or procedures allows greater

understanding and predictability in programs. Wirth himself wrote a book, published in 1976, called

Algorithms + Data Structures = Programs, in which he utilized the language of Pascal to teach about the

items contained in the book’s title: algorithms, data structures, and their combination, programs. The

language of Pascal, incorporating the doctrine of structured programming, was used by undergraduate

students; in commercial products such as the Apple II, Apple Lisa and Macintosh; in various applications

including Skype; and in projects such as computer games and embedded systems.
 The language of C was released in 1972, having been developed by Dennis Ritchie at Bell Labs

since 1969. Originally, the C language was intended to be used for the Unix operating system, being

simultaneously developed at Bell Labs. The etymology of its name comes from its succession of the

language B, which was itself derived from BCPL, a tiny language designed for implementing compilers.

The B language came about in the development of the Multics project, which the Unix project was based

upon. The design of C included different ways to access and manage memory, such as with pointers, and

different facilities of I/O management, as would be required by a project such as Unix. The language was

made to be portable, and made to compile efficiently, and as such has found places in various

embedded systems and become a lingua franca for many programmers of the time.

In 1979, Bjarne Stroustrup had begun work on a language called “C with Classes.” C with Classes

was motivated by Stroustrup’s familiarity with a language called Simula, whose introduction of classes

allowed for simulations of various systems. Stroustrup, who was working on the Unix kernel, realized

that the portability and efficiency of C could be combined with the powerful abstract nature of Simula in

order to meet the demands of the complexity of the Unix system. C with Classes was renamed to C++ in

1983, and had included various features beyond a simple intermixing of C and classes, such as function

and operator overloading and better type checking. The C++ language finds itself commonplace in many

applications, and according to the TIOBE Index, is the fourth most popular programming language in use

as of December 2018.

The language Haskell was formed in September 1987 when a group of engineers gathered at the

Functional Programming Languages and Computer Architecture conference in Portland, Oregon. At the

time, there were multiple disconnected functional languages. The conference sought to consolidate

them all into a language that was freely available and useful for a variety of applications, including

teaching and research. By 1999, the Haskell Report and the Haskell language were released. Haskell is a

purely functional language, which means that functions defined in Haskell do not have side effects.
Functions cannot inadvertently modify variables and values found elsewhere in the code, and thus the

language is referentially transparent. Not everything in Haskell can be pure if the language is to do

something, however. In order to handle things like input and output, or randomness, there must be

impure functionality as well. Impurity is addressed by a clever deviation in syntax, and the utilization of a

polymorphic type known as a Monad. Monads in Haskell provide context to functions, and in addition to

sandboxing impurity, are also derived to represent nondeterministic computations, optional types, error

handling, and many more constructs. Another feature that Haskell incorporates is lazy evaluation; code

is not evaluated until its information is required for execution. This allows for the definition of infinite

lists without the necessity of an infinite run time. Haskell’s lazy nature allows the language to employ

concurrency and execute multiple branches of code in parallel, leading to performance benefits. The

language employs many more features such as a strong and extensible type system, list comprehensions

and lambda functions, and sees much application today.

Guido van Rossum started work on Python towards the end of the 1980s, as a scripting language

for the Amoeba operating system. Van Rossum’s design of Python was greatly influenced by a language

he had helped create called ABC, which like BASIC was aimed towards people with little background in

programming. Python adapted many features of ABC and maintained its readability and ease of use.

Python’s semantic and required usage of whitespace for denoting structures in code is one of the

reasons that the language is very friendly to new learners of the language. Van Rossum did not like the

lack of extensibility that ABC had offered, so he provided means for others to easily extend the

language. As a result, Python is a very modular language, supporting many third-party libraries and

allowing for proliferation of numerous open source libraries and features. Python’s built-in feature set

includes lists, dictionaries (similar to associative arrays), a dynamic type system and automatic garbage

collection. Although Guido van Rossum has stepped down as Python’s community leader in July 2018,
the language is still very popular and its user-friendliness will see it continue to be used well into the

future.

Work on a language called Oak started in 1991, at the hands of developers James Gosling,

Patrick Naughton and Mike Sheridan. This project was aimed at the digital cable television industry and

the creation of interactive experiences in that domain. Eventually, that project fell through, being too

advanced at the time. The language remained, however. By 1995, with a new name of Java, the

language was incorporated into the Netscape Navigator web browser, and found usage on the Internet

in the form of applets. Java’s syntactic design was purposefully similar to that of C, as it had been

intended for use by systems programmers who would have already been familiar with C. Modularity

permeates the Java language, as classes and objects are its primary structures. In addition to being

object-oriented, the language is secure, multi-threaded and portable, being compiled into Java bytecode

which is interpreted on Java Virtual Machines independent of platform. Although the days of the applet

are gone, Java is one of the world’s most popular programming languages, finding shelter in various

forms within Android development, backend services and embedded systems.

In 2007, a group of engineers at Google, Robert Griesemer, Ken Thompson and Rob Pike started

work on a language by the name of Go. They shared concern regarding the inefficiency of the languages

they were currently using for the development of server software. Computers were becoming

increasingly more performant, and microprocessors were becoming more and more common. The Go

language set out to reap the benefits of the advancing technology, while at the same time maintaining

the features that existing languages like C, Java and Python had already espoused. The result was a

language that is both efficient in compilation and execution, safe, and concurrent by design. It was the

first of a handful of new languages built for new computers in a new age. The language of Go is widely

used internally at Google, and its guise is continuing to expand to new companies and applications in the

present day.
 Graydon Hoare began work on Rust in 2006. Like Go, Rust was born from the ineptitude of

already existing languages regarding their applications to new problems, particularly in the domain of

large-scale systems development. Hoare, an engineer at Mozilla, desired a language that bore the

familiarity of C and the benefits of the features of more modern languages, but was also concurrent,

secure and exhibited memory-safety. In comparison to Go, Rust is a larger language, and enforces

memory safety between threads. Go does not have any explicit means of ensuring that two threads

might not modify the same memory at the same time, and thus might suffer from race conditions. In

Rust, this safety is built into the language. While Rust implements many features in a more robust way

than Go does, it requires more thought and planning by the programmer; it provides more power, but

requires more responsibility to utilize such power. As with many newer languages, Rust is multi-

paradigm, and incorporates aspects of both functional and imperative paradigms. Rust is currently used

in a variety of projects, including Mozilla’s own Servo browser and a storage systems for the popular file-

sharing application Dropbox.

Conclusion

Programming languages have grown very much since the days of FORTRAN, COBOL, ALGOL and

LISP, in tandem with the development of the hardware utilizing them. Over time, problems have

advanced, and programming languages have advanced to tackle them, developing new insights and

adapting old tricks in new forms. A trend in programming language development is the inclusion of

multiple different paradigms, and the intent to reach a wide variety of domains as opposed to being

limited to a select subset. In other words, programming languages are becoming global just like

everything else, and will continue to advance in this way beyond the foreseeable future.
Works Cited

• “The ALGOL Programming Language.” The ALGOL Programming Language, 24 Nov.

1996, 5:15,
web.archive.org/web/20161006113915/http://groups.engin.umd.umich.edu/CIS/course
.des/cis400/algol/algol.html.
• “ALGOL.” Wikipedia, Wikimedia Foundation, 13 Dec. 2018,
en.wikipedia.org/wiki/ALGOL.
• Avram, Abel. “Interview on Rust, a Systems Programming Language Developed by
Mozilla.” InfoQ, InfoQ, 3 Aug. 2012, www.infoq.com/news/2012/08/Interview-Rust.
• Booch, Grady. “Oral History of John Backus.” Computer History Museum, 5 Sept. 2006,
archive.computerhistory.org/resources/text/Oral_History/Backus_John/Backus_John_1.
oral_history.2006.102657970.pdf.
• “C (Programming Language).” Wikipedia, Wikimedia Foundation, 12 Dec. 2018,
en.wikipedia.org/wiki/C_(programming_language).
• “C++.” Wikipedia, Wikimedia Foundation, 12 Dec. 2018,
en.wikipedia.org/wiki/C%2B%2B.
• “COBOL.” Wikipedia, Wikimedia Foundation, 13 Dec. 2018,
en.wikipedia.org/wiki/COBOL.
• Eng, Richard Kenneth. “Who Uses Smalltalk? – Smalltalk Talk – Medium.” Medium.com,
Medium, 14 Dec. 2015, medium.com/smalltalk-talk/who-uses-smalltalk-c6fdaa6319a.
• “Fortran.” Wikipedia, Wikimedia Foundation, 30 Nov. 2018,
en.wikipedia.org/wiki/Fortran.
• “Frequently Asked Questions (FAQ).” The Go Project - The Go Programming Language,
golang.org/doc/faq.
• “Go (Programming Language).” Wikipedia, Wikimedia Foundation, 12 Dec. 2018,
en.wikipedia.org/wiki/Go_(programming_language).
• “Go Success Stories from around the Web.” GitHub,
github.com/golang/go/wiki/SuccessStories.
• “Haskell (Programming Language).” Wikipedia, Wikimedia Foundation, 28 Nov. 2018,
en.wikipedia.org/wiki/Haskell_(programming_language).
• “The History of Java Technology.” Oracle, Oracle,
www.oracle.com/technetwork/java/javase/overview/javahistory-index-198355.html.
• “The Java Language Environment.” Oracle, Oracle, 1997,
www.oracle.com/technetwork/java/intro-141325.html.
• “Java (Programming Language).” Wikipedia, Wikimedia Foundation, 14 Dec. 2018,
en.wikipedia.org/wiki/Java_(programming_language).
• Jones, Simon Peyton. “The Haskell 98 Report.” Preface, Sept. 2002,
www.haskell.org/onlinereport/preface-jfp.html.
• Kabutz, Heinz. “Once Upon and Oak...” Artima, 15 July 2003,
www.artima.com/weblogs/viewpost.jsp?thread=7555.
• Kincaid, Jason. “Google's Go: A New Programming Language That's Python Meets
C++.” TechCrunch, TechCrunch, 10 Nov. 2009, techcrunch.com/2009/11/10/google-go-
language/.
• “Lisp (Programming Language).” Wikipedia, Wikimedia Foundation, 4 Dec. 2018,
en.wikipedia.org/wiki/Lisp_(programming_language).
• McCarthy, John. Recursive Functions of Symbolic Expressions and Their Computation by
Machine, Part I. Apr. 1960, web.archive.org/web/20131004232653/http://www-
formal.stanford.edu/jmc/recursive.pdf.
• Mitchell, Robert L. “Cobol: Not Dead Yet.” Computerworld, Computerworld, 4 Oct. 2006,
www.computerworld.com/s/article/266156/Cobol_Not_Dead_Yet.
• “Pascal (Programming Language).” Wikipedia, Wikimedia Foundation, 27 Nov. 2018,
en.wikipedia.org/wiki/Pascal_(programming_language).
• “Python (Programming Language).” Wikipedia, Wikimedia Foundation, 13 Dec. 2018,
en.wikipedia.org/wiki/Python_(programming_language).
• “Rust (Programming Language).” Wikipedia, Wikimedia Foundation, 13 Dec. 2018,
en.wikipedia.org/wiki/Rust_(programming_language).
• “Smalltalk.” Wikipedia, Wikimedia Foundation, 4 Dec. 2018,
en.wikipedia.org/wiki/Smalltalk.
• Stroustrup, Bjarne. “Bjarne Stroustrup's FAQ.” Stroustrup,
www.stroustrup.com/bs_faq.html.
• Timmer, John. “A Fast Look at Swift, Apple's New Programming Language.” Ars Technica,
Ars Technica, 5 June 2014, arstechnica.com/gadgets/2014/06/a-fast-look-at-swift-
apples-new-programming-language/.
• “TIOBE Index for December 2018.” TIOBE Index | TIOBE - The Software Quality
Company, Dec. 2018, www.tiobe.com/tiobe-index/.
• Venners, Bill. “The Making of Python: A Conversation with Guido Van Rossum, Part
I.” Artima, 13 Jan. 2003, www.artima.com/intv/pythonP.html.