Evolution of computer

programming languages

Evolution of computer programming

languages
 The first programming languages predate the modern computer. At first, the languages
were codes.
During a nine-month period in 1842-1843, Ada Lovelace translated Italian mathematician Luigi
Menabrea's memoir on Charles Babbage's newest proposed machine, the Analytical Engine.
With the article, she appended a set of notes which specified in complete detail a method for
calculating Bernoulli numbers with the Engine, recognized by some historians as the world's first
computer program. But some biographers debate the extent of her original contributions versus
those of her husband.
The Jacquard loom, invented in 1801, used holes in punched cards to represent sewing loom arm
movements in order to generate decorative patterns automatically.
The first computer codes were specialized for the applications. In the first decades of the
twentieth century, numerical calculations were based on decimal numbers. Eventually it was
realized that logic could be represented with numbers, as well as with words. For example,
Alonzo Church was able to express the lambda calculus in a formulaic way. The Turing machine
was an abstraction of the operation of a tape-marking machine, for example, in use at the
telephone companies. However, unlike the lambda calculus, Turing's code does not serve well as
a basis for higher-level languages — its principal use is in rigorous analyses of algorithmic
complexity.
Like many "firsts" in history, the first modern programming language is hard to identify. From
the start, the restrictions of the hardware defined the language. Punch cards allowed 80 columns,
but some of the columns had to be used for a sorting number on each card. Fortran included
some keywords which were the same as English words, such as "IF", "GOTO" (go to) and
"CONTINUE". The use of a magnetic drum for memory meant that computer programs also had
to be interleaved with the rotations of the drum. Thus the programs were more hardware
dependent than today.
To some people the answer depends on how much power and human-readability is required
before the status of "programming language" is granted. Jacquard looms and Charles Babbage's
Difference Engine both had simple, extremely limited languages for describing the actions that
these machines should perform. One can even regard the punch holes on a player piano scroll as
a limited domain-specific programming language, albeit not designed for human consumption.

The 1940s
In the 1940s the first recognizably modern, electrically powered computers were created.
The limited speed and memory capacity forced programmers to write hand tuned assembly
language programs. It was soon discovered that programming in assembly language required a
great deal of intellectual effort and was error-prone.
In 1948, Konrad Zuse published a paper about his programming language Plankalkül. However,
it was not implemented in his time and his original contributions were isolated from other
developments.
Some important languages that were developed in this period include:
1943 - Plankalkül (Konrad Zuse)
1943 - ENIAC coding system
1949 - C-10

The 1950s and 1960s

In the 1950s the first three modern programming languages whose descendants are still in
widespread use today were designed:
FORTRAN (1955), the "FORmula TRANslator, invented by John W. Backus
Language dedicated to mathematical calculations. Fortran II (1958) introduced SUB-
ROUTINES, FUNCTIONS, LOOPS, a primitive FOR control structure. Identifiers were limited
to six characters.
LISP, the "LISt Processor", invented by John McCarthy
Functional language for list processing. It is purely recursive, and not iterative. There is no
difference between code and data.
COBOL, the COmmon Business Oriented Language, created by the Short Range Committee,
heavily influenced by Grace Hopper.
The committee under the auspices of the Department Of Defense, and manufacturers,
universities and users, worked from may 1959 to april 1960.Grace Murray Hopper, who had
designed Flow-Matic, a compiled language in the 50's, has participated to the committee.Cobol is
a classical procedural language aimed at enterprise management, in wich a program is divided in
4 divisions: identification, environment, data, procedure, and they may be divided in sections. It
was founded on data and a program must describe precisely the hardware and input/ouput data
format.It introduced the RECORD data structure. Programs are documented by the syntax and
are all but ligthweight...
ALGO, Another milestone in the late 1950s was the publication, by a committee of American
and European computer scientists, of "a new language for algorithms"; the Algol 60 Report (the
"ALGOrithmic Language"). This report consolidated many ideas circulating at the time and
featured two key language innovations: arbitrarily nested block structure: meaningful chunks of
code could be grouped into statement blocks without having to be turned into separate, explicitly
named procedures; lexical scoping: a block could have its own variables that code outside the
chunk cannot access, let alone manipulate.
Another innovation, related to this, was in how the language was described: a mathematically
exact notation, Backus-Naur Form (BNF), was used to describe the language's syntax. Nearly all
subsequent programming languages have used a variant of BNF to describe the context-free
portion of their syntax.
Overview:
1951 - Regional Assembly Language
1952 - Autocode
1954 - FORTRAN
1955 - FLOW-MATIC (forerunner to COBOL)
1957 - COMTRAN (forerunner to COBOL)
1958 - LISP
1958 - ALGOL 58
1959 - FACT (forerunner to COBOL)
1959 - COBOL
1962 - APL
1962 - Simula
1964 - BASIC
1964 - PL/I

1967-1978: establishing fundamental paradigms..

The period from the late 1960s to the late 1970s brought a major flowering of
programming languages. Most of the major language paradigms now in use were invented in this
period:
Simula, invented in the late 1960s by Nygaard and Dahl as a superset of Algol 60, was the first
language designed to support object-oriented programming.
C, an early systems programming language, was developed by Dennis Ritchie and Ken
Thompson at Bell Labs between 1969 and 1973.
Smalltalk (mid 1970s) provided a complete ground-up design of an object-oriented language.
Prolog, designed in 1972 by Colmerauer, Roussel, and Kowalski, was the first logic
programming language.
ML built a polymorphic type system (invented by Robin Milner in 1973) on top of Lisp,
pioneering statically typed functional programming languages.
Each of these languages spawned an entire family of descendants, and most modern languages
count at least one of them in their ancestry.
The 1960s and 1970s also saw considerable debate over the merits of "structured programming",
which essentially meant programming without the use of GOTO. This debate was closely related
to language design: some languages did not include GOTO, which forced structured
programming on the programmer. Although the debate raged hotly at the time, nearly all
programmers now agree that, even in languages that provide GOTO, it is bad programming style
to use it except in rare circumstances. As a result, later generations of language designers have
found the structured programming debate tedious and even bewildering.

The 1980s: consolidation, modules, performance

The 1980s were years of relative consolidation. C++ combined object-oriented and
systems programming. The United States government standardized Ada, a systems programming
language intended for use by defense contractors. In Japan and elsewhere, vast sums were spent
investigating so-called fifth-generation programming languages that incorporated logic
programming constructs. The functional languages community moved to standardize ML and
Lisp. Rather than inventing new paradigms, all of these movements elaborated upon the ideas
invented in the previous decade.
However, one important new trend in language design was an increased focus on programming
for large-scale systems through the use of modules, or large-scale organizational units of code.
Modula, Ada, and ML all developed notable module systems in the 1980s. Module systems were
often wedded to generic programming constructs---generics being, in essence, parameterized
modules.
The 1980s also brought advances in programming language implementation. The RISC
movement in computer architecture postulated that hardware should be designed for compilers
rather than for human assembly programmers. Aided by processor speed improvements that
enabled increasingly aggressive compilation techniques, the RISC movement sparked greater
interest in compilation technology for high-level languages.
1983 - Ada : Inspired by Pascal and Algol W. Is rather heavy. Introduces GENERICITY of
algorithms and a kind of primitive object orientation, but becomes really object oriented later.
Introduces PACKAGES, that are independent modules.
1983 - C++ : Object oriented version of C. Introduces OPERATOR OVERLOADING. Methods
may be inline. Use // for one-line comment, that comes from BCPL, of which C is a successor!
Further, multiple inheritance and template (generic classes or functions) has been implemented.

The 1990s: the Internet age

The 1990s saw no fundamental novelty, but much recombination as well as maturation of
old ideas. A big driving philosophy was programmer productivity. Many "rapid application
development" (RAD) languages emerged, which usually came with an IDE, garbage collection,
and were descendants of older languages. All such languages were object-oriented. These
included Object Pascal, Visual Basic, and C#. Java was a more conservative language that also
featured garbage collection and received much attention. More radical and innovative than the
RAD languages were the new scripting languages. These did not directly descend from other
languages and featured new syntaxes and more liberal incorporation of features. Many consider
these scripting languages to be more productive than even the RAD languages, but often because
of choices that make small programs simpler but large programs more difficult to write and
maintain. Nevertheless, scripting languages came to be the most prominent ones used in
connection with the Web.
Some important languages that were developed in this period include:
1990 - Haskell
1991 - Python
1991 - Java
1993 - Ruby
1993 - Lua
1994 - ANSI Common Lisp
1995 - JavaScript
1995 - PHP
2000 - C#
2008 - JavaFX Script

The future
Scripting languages
Several modern scripting languages offer a simple, natural syntax: NetRexx, Python, Ruby,
Scriptol. Python is the most widely used for now. Ruby is mainly used for the Rail library.
Scriptol has innovative features.
Internet languages
These languages allows to embed code inside HTML page and thus to combine statements and
data. PHP, ASP, JavaScript are the most used ones. The .NET platform will allow any language
to be embedded into HTML.
Markup languages
A recent trend is to turn XML documents into executables.
- XML is embedded into Scriptol sources as a data structure, that is usable by any statement in
the source. This is a next step beyond object oriented programming.
- XUL is a Mozilla project that embeds JavaScript into XML to easily produce GUI (the one of
Mozilla for example). On the Web with Firefox or locally with the XULRunner runtime.
- Microsoft uses XAML to define graphical interfaces, on the Web with the cross-browsers plug-
in Silverlight or locally on .NET.
A new C++ language
C++0x, will be probably C++09. This new version will include as standard a lot of external
libraries. It will have tuples and garbage collector and an extended standard library with regular
expression and threads.
SQL
Thanks to Web applications and dynamic sites of the Web 2.0, SQL trends to be more and more
popular, and so is now a part of modern programming.