Chapter 12: Programming Languages
Learning Objectives:
In this chapter, we are going to discuss the following topics:

History of Programming languages

Why do we need Programming Languages?

Generations of Programming Languages

Programming languages categories

Examples of Programming Languages
Learning outcomes:
At the end of this chapter, students will be able to:
1. Describe the history of programming languages and its evolution to the present stage
2. Explain the need for programming languages
3. Identify the different generations of programming languages
4. Categorize programming languages
5. Provide examples of programming languages
12.1
History of Programming languages
There were significant events in history that lead up to where we are today with Programming
Languages.
1949: Short Code
The first computer language actually used on an electronic computing device. The programmer
was required to, by hand, change its statements into 0's and 1's for the processor to
understand.
1951 - 1957: FLOW-MATIC & the First Compiler
Grace Hopper develops the first computer compiler which is called A-0, in 1951. Hopper
produces specifications for a common business language. Flow-Matic provides the foundations
for the specification of the language COBOL (COmmon Business-Oriented Language).
1952: Autocode
Alick E. Glennie, at the University of Manchester, devises a programming system called
AUTOCODE, a rudimentary compiler.
1957: The Development of FORTRAN I
The first major language appears in the form of FORTRAN, short for FORmula TRANslating
system. FORTRAN was designed by IBM for scientific computing. The components were very
simple, and provided the programmer with low-level access to the computers innards. It
included the IF, DO, and GOTO statements, which were a major step forward when it was
released. Data-types in use by today's languages got their start in FORTRAN. These included the
logical variables (TRUE or FALSE), and numerical variables (integer, real, and double-precision
numbers).
1958: The Development of FORTRAN II & III
Adding the capability for separate compilation of program modules, FORTRAN II was a
significant improvement, allowing assembly language modules to be 'linked loaded' with
FORTRAN modules. Although it was never released, FORTRAN III made it possible to use
assembly language code right in the middle of FORTRAN code.
1958: LISP
John McCarthy of MIT creates the LISt Processing (LISP) language. It was designed for Artificial
Intelligence (AI) research, and because of which, had syntax which had rarely been seen before
or since its introduction.
1958: ALGOL 58
Created originally in 1958 by a committee for scientific use, ALGOL was the first blockstructured language that appears. A later version, ALGOL 60, was released in 1960 and would
serve as the root of the family tree that will ultimately produce other languages such as Pascal,
C, C++, and Java.
1959: COBOL
Although FORTRAN was good at handling numbers, it was not so good at handling input and
output, which mattered to most business computing. When business computing began to take
off in 1959, COBOL was developed to fill the need that FORTRAN could not. Created by the
Conference on Data Systems and Languages (CODASYL), COBOL was developed from the
ground up as the language for business men. COBOL statements have a very English-like
grammar, making it quite easy to learn, especially for the business men for which it was
designed.
1960: APL
Kenneth Iverson invented APL--A Programming Language. It is an interpreted mathematical
language characterized by its terse syntax and bizarre non-ASCII character set. It is very strong
in all forms of arithmetic and matrix manipulation According to its fans, its expressive power
allows a skilled programmer to create complex applications in a very short time. Sometimes,
entire complex mathematical analyses can be coded in a couple of lines of code. However, APLs
unconventional structure and odd character set make it challenging to learn and master. Today,
APL is used mainly in niches in the scientific, financial, and econometric communities
1961: FORTRAN IV
FORTRAN IV was released in 1961 and it improved things like the implementation of the
COMMON and EQUIVALENCE statements, and eliminating some machine-dependant language
irregularities. A FORTRAN II to FORTRAN IV translator was used to retain backward
compatibility with earlier FORTRAN programs.
1962: SNOBOL
Designed by three people at Bell Laboratories: (D.J. Farber, R.E. Griswold, and F.P. Polensky,
SNOBOL (StriNg-Oriented symBOlic Language) is a special purposed language developed to
provide a powerful means of doing character string manipulation. Accordingly SNOBOL has a
collection of powerful operations for doing string pattern matchings. The most common early
application of SNOBOL was to write text editors. Because of the dynamic nature of SNOBOL and
its interpreter implementation, it is now considered too slow for such applications. Infact
SNOBOL is now close to being completely unused.
1963: PL/I
PL/I (Programming Language 1) is a large, complex block-structured language invented by IBM
in 1963, and first released in 1964 in conjunction with the influential System/360 line of
computers. PL/I was intended to be THE all-around language for mainframe system and
application development, and therefore it had a very large feature set. PL/I was widely used by
the IBM community
1964: BASIC
The Beginners All-purpose Symbolic Instruction Code (BASIC) was designed in 1964 by two
graduate students at Dartmouth, John Kennedy and Thomas Kurtz, to be an easy first language
for programming neophytes, especially those who weren't "computer-science" oriented.
Though the first version was compiled, most Basic systems were interpreters. Original Basic had
a simple syntax that included a line number for every source line. Control structure mostly
consisted of GOTO ### and GOSUB ###; simple conditional and bounded loop constructs were
also available. Original Basic provided numeric, string, and array datatypes, but no structures or
objects.
1966: FORTRAN 66
The new ASA standard was published in 1966, and was known accordingly as FORTRAN 66. This
was a very important step that made it worthwhile for vendors to produce FORTRAN systems
for every new computer, making FORTRAN an even more popular HLL.
1966: Logo
Logo is a functional language designed to teach programming and problem-solving principles to
children. It is a functional language, related to Lisp, with a simple syntax and a graphicsoriented feature set. The Logo language provides a set of built-in procedures, a means to create
new procedures, a simple data framework with symbols, numbers, and lists, and simple control
structures. Logo is a simple language to learn, but amazingly functional. Many elementary
schools have used Logo to teach children how to think about really controlling computers (not
just point-n-click). Many of the sites listed below have links to these educational projects.
1967: BCPL
BCPL is an operator-typed language; the data types of variables are defined by the operators
applied (rather than being declared for the variable, as in Algol). Data items were untyped cells
labeled with identifiers. Data types supported by BCPL included integers, reals, bit patterns, I/O
streams, various kinds of references, and vectors. Strings could only be used as constants. The
language supported simple control constructs like loops and conditionals, as well as means to
declare subroutines and functions. The BCPL system library, which evolved along with the
language, provided I/O support and very simple memory management. Early versions of BCPL
were machine native compilers, but nearly all recent versions have been translators. In other
words, the BCPL compiler translates the BCPL code to an abstract machine language called
INTCODE. The INTCODE data is then interpreted by a simple, fast virtual machine (typically
coded in assembly language, C, or a mixture of the two).
1970: Forth
A Forth program is a sequence of words such that each word is independent, and causes some
specified action. Even constants are words: the word "12" is just a command to push the
number 12 onto the data stack. Sequences of words can be grouped as procedures, and
employed to build up modular programs. In order for this to work, of course, operators and
operands must be given in reverse polish order (operands followed by operator). All data
manipulation takes place on the data stack, so Forth offers several operations for manipulating
the stack. Forth implementations vary in the range of data types they provide, but most provide
a conventional set of numeric and string types, plus arrays. Forth offers regular control
structures: If-Else, While-Do, and For-Next, albeit with peculiar ordering of the keywords. Most
dialects of Forth provides simple file handling and I/O support. Meant to be extensible at every
level, Forth programmers can define new words, and implement them in Forth itself, in some
other high-level language, or in machine code. Click to view a sample Forth program
1970: Smalltalk
Developed at Xerox PARC, led by Alan Kay, Smalltalk is a dynamic object-oriented language
which was originally designed as an experiment, but evolved into a powerful application
development language. Smalltalk is a pure object-oriented language
1970: Icon
A decendent of SNOBOL known as Icon is first introduced. It is a procedural language with highlevel semantics for string and data aggregate processing. Icon is normally interpreted, but there
is also a translator that generates compilable C code from Icon code. Icon was originally
implemented for UNIX, but has been ported to VMS, MS-DOS, 32-bit MS-Windows, OS/2, and
the Macintosh.
1971: Pascal
Pascal is a simple block-structured language originally designed for computer science
education. Pascal features strong type checking, simple I/O facilities, a good set of primitive
data types, arrays, fixed and variant records, conventional control structures, and simple
dynamic memory management. In most programming areas, Pascal has been superseded by
newer, object-oriented languages, such as C, C++, and Java.
1971: B
With its roots based in BCPL (see 1967), B is a new computer language designed and
implemented at Murray Hill, New Jersey, by Dennis M. Ritchie and K. L. Thompson. B is suited
for non-numeric computations, typified by system programming, which usually involve many
complex logical decisions, computations on integers and fields of words, especially characters
and bit strings, and no floating point. Unfortunately B is short lived, as within a year it spawns C,
which will eventually incorporate everything that B already does.
1971: sh
The developement of sh, aka Bourne Shell, is no different from other shell scripting languages.
Created in 1971 by Steve Bourne, the shell has been included on all Unix and Linux systems, and
more-or-less complete versions are available for many other systems. Eventually, this would
become part the development of Perl in 1987. The Bourne shell scripting language was one of
the original command languages for the Unix operating system. It is a simple interpreted
language, but widely used for automating complex tasks and assembling multi-step
functionality from individual Unix tools. It offers extensive special syntax and features for
running programs and handling their I/O. One of the most influential of these constructs was
the "pipe", a simple syntax for connecting the output of one program to the input of another.
1972: Prolog
The first implementation of Prolog, developed by Alain Colmerauer and Phillip Roussel appears
after work had begun in 1971. A Prolog program can accomplish amazing things with a very
short amount of code. The logic paradigm is a very powerful one for certain problem domains,
but unsuitable for some others. PROLOG stands for PROgramming in LOGic.
1972: C
Developed by Dennis M. Richie while working at Bell Labs in Murray Hill, New Jersey, the
language of C, a fairly low-level block structured language with good support for system
programming. It had fair arithmetic support, simple data structures, subroutines, conventional
flow control constructs, naked memory pointers, simple but useful I/O facilities, and a powerful
macro preprocessor. Richie had developed C for the new Unix system being created around the
same time, and because of this, Unix and C go hand in hand. However, C would not be limited
to just Unix as language would become widely used in PC, Mac, mainframe, and other
computing environments. Based in two lesser known languages of B (see 1971) and BCPL (see
1967), C signified the next major step in programming languages as it also seemed to improve
on the already popular Pascal.
1975: Tiny BASIC
A relatively unknown language called Tiny BASIC is released by Bob Albrecht and Dennis Allison
(implementation by Dick Whipple and John Arnold). It runs on a microcomputer with just 2 KB
of RAM. A 4-KB machine is sizable, which left 2 KB available for the program.
1975: Scheme
Developed at MIT, Scheme, a dialect of LISP, was created with functional and procedural
language aspects. Unlike original LISP, Scheme is lexically scoped, but like LISP it is dynamically
typed. Scheme is used to teach computer science principles, as well as for writing various
compilers, AI systems, and many other kinds of programs.
1975: The Microsoft Empire Takes Shape
With the release of their own version of BASIC (see 1964), Bill Gates and Paul Allen being the
company known today as Microsoft. They sell it to MITS (Micro Instrumentation and Telemetry
Systems) on a per-copy royalty basis. MITS is producing the Altair, an 8080-based
microcomputer at the time.
1975: RATFOR
B.W. Kerninghan describes RATFOR which stands for RATional FORTRAN. It is a preprocessor
that allows C-like control structures in FORTRAN. RATFOR is used in Kernighan and Plauger's
"Software Tools," which appears a year later.
1977: MUMPS
The ANSI standard for MUMPS (Massachusetts General Hospital Utility Multi-Programming
System) is released. Soon after it becomes standardized and commercialized, people started
calling it 'M' because it was cooler and didn't evoke an unpleasant disease. MUMPS (aka M) is a
procedural, interpreted language with extensive features for event-driven programming, text
handling, and database manipulation.
1978: Awk
Awk is an interpreted string-processing language developed at Bell Labs. It quickly assumed its
place as the utility language of choice for small UNIX data transformation and parsing
programs. Awk offered powerful regular expression pattern matching, handy line-oriented
program structure, and enough conventional language features to let you get your work done.
Awk did not support any kind of modularity nor type checking. Awk remains moderately wellknown in the UNIX community, but has been largely superseded by the more powerful Perl
programming language in 1987.
1979: Rexx
Originally invented as a sophisticated command language for IBM mainframe environments
(MVS, CMS), Rexx has gained some popularity as a programming language with expressive
power and convenience. In the Windows environment it competes with Visual Basic, Java, Perl,
and Tcl. In the UNIX environment is competes with Perl, Tcl, Java, and various shells. On IBM
OS/2 Rexx is probably the most popular scripting language.
1980: Modula 2
Originally conceived by Niklaus Wirth in 1977, Modula 2 was officially released in 1980. It is
designed to support the construction and maintenance of real application software systems,
unlike its predecessor Pascal. Modula 2's support for concurrency and dynamic memory
management are also better than Pascal, allowing the programmer more flexibility.
1980: C with Classes
With OOP (Object Oriented Programming) developing in the late 70's, Bjarne Stroustrup
develops a set of languages, collectively referred to as "C With Classes". These are extensions to
C which was released in 1972, providing advanced features such as dynamic variables,
multitasking, interrupt handling, forking, and strong, low-level input/output. "C With Classes"
server as the breeding ground for C++ which would be released in 1983.
1982: The Foundation of Adobe and PostScript
PostScript is a threaded interpreted language with stack-based semantics. While usable for
general-purpose computation, PostScript was specially designed to drive graphic devices,
initially printers, and has a large set of operators for rendering onto a page. In terms of syntax
and semantics, PostScript resembles Forth: operators use data from a stack, and place their
results back on the stack. PostScript data types include floating-point numbers, strings, fonts,
files, vectors, and symbols. Defined procedures are simply code sequences stored in
dictionaries.
1983: Ada
Originally designed for the US Dept. of Defense, with intentions to support large-scale
programming and promote software reliability, Ada is released in 1983. Named in honor of Lady
Ada Lovelace (1815-1852), a friend and confidante of Charles Babbage, Ada is a blockstructured language with many object-oriented programming features that include: nested
procedures, nested packages, strong typing, multi-tasking, generics, exception handling, and
abstract data types. Ada is a fairly complex language that has a conventional but very rich
Pascal-like syntax, with many specialized features. The best aspects of Ada are its support for
generics (templates), its support for task synchronization, and its very good exception handling.
Its worst features are its complex syntax, and the poor performance of the code generated by
most early compilers.
1983: C++
In July of 1983, the first implementation of C++ appears. The name is coined by Rick Mascitti.
C++ is a fairly complicated object-oriented language derived from C. The syntax of C++ is a lot
like C, with various extensions and extra keywords needed to support classes, inheritance and
other OO features. C++ was originally developed as an extension to C, but quickly evolved into
its language. Despite some of the flaws it has inherited from C, C++ is a very popular language
for application development on Unix systems and PCs.
1983: C Compilers
In late 1983 and early 1984, Microsoft and Digital Research both release the first C compilers
for microcomputers.
1986: Actor
Charles Duff releases Actor, an object-oriented language for developing Microsoft Windows
applications
1986: Eiffel
An object-oriented language intended for general application programming, Eiffel is designed in
large part to support program safety and orderly software development, whose goals were also
embraced by the Ada community. Superficially similar to C, the syntax of Eiffel offers a broad
range of OO programming features: inheritance, polymorphism, assertions, exception handling,
packaging, generics, and strong type checking.
1987: Perl
"Perl" stands for "Practical Extraction and Reporting Language," a reference to the purpose for
which the Perl interpreter was originally created: system administration and data reduction. It
is an interpreted scripting language with extensive facilities for data manipulation and rapid
application development. Perl is basically block-structured, but also supports object-oriented
programming. Perl is very popular in the UNIX community, and gaining acceptance in the
Microsoft Windows developer community. There is only one Perl language system; written in C
to be very portable, it runs on all UNIX platforms, 32-bit Windows, VMS, and many other
systems. Perl is free. Books, tutorials, and on-line resources for Perl are widely available, and
generally of good quality.
1988: Oberon
Oberon is a procedural, block-structured language with many object-oriented features. It was
designed for computer science education, but is also suitable for general-purpose application
programming. Oberon has a Pascal-like syntax, but its semantics are richer than Pascal's. An
Oberon system consists of the Oberon language compiler along with a comprehensive
operating environment.
1990: J
Kenneth Iverson and Roger Hui present J at the APL90 conference in 1990. J programming is
normally conducted as an interactive session. J is a interpreted mathematical/functional
programming language very closely related to APL. Basically, it is a dialect of APL with the same
functionality, but employing the ASCII character set instead of APL's original unique character
set.
1991 - 2001: The Arrival of the Internet Languages
By the mid 90's, the Internet had become part of our society. With the start of the new
millennium, the Internet is as common as the television, and with it comes new languages
designed specifically for its use.
1991: Java
Designed by research staff at Sun Microsystems, Java is a simple, portable object-oriented
language. The feel of the Java language is fairly similar to that of C++, but it also borrows ideas
from Modula-3, Mesa, and Objective-C. According to its designers, Java was intended to be
object-oriented, robust, secure, architecture neutral, portable, high-performance, threaded,
and dynamic.
1991: Python
Python is an interpreted, object-oriented language. It is intended to be highly effective, easy to
use, and extensible. The syntax of Python is very simple and statement-oriented. Block
structure is specified with indentation. Considered a good language to use for certain kinds of
web programming, the standard library of Python supports HTTP and CGI services, as well as a
Windows-specific library support ActiveX scripting (so that you can use powerful Python for
active server pages instead of the intentionally weak VBScript). Python can be extended by
adding C/C libraries, and it can also be embedded in an application to serve as its extension
language.
1991: Visual Basic
As a language, Visual Basic has evolved enormously since its commercial introduction in 1991
by Microsoft. Visual Basic is an advanced structured dialect of Basic that is intended for
application development. The "Visual" in the name Visual Basic does not really refer to the
language, but to the development environment. The VB integrated development environment
that Microsoft distributes has extensive facilities for on-screen design of graphical user
interfaces: dialog boxes, window interfaces, menus, etc. It also provides a rich but complicated
interface for code management and debugging. GUI programs are easy to write in Visual Basic,
and the development environment provides copious support for coding the necessary event
handling subroutines.
1992: Dylan
Developed by Apple Computer in 1992 by their advanced technology east lab, Dylan (DYnamic
LANguage) is a dynamic object-oriented language with both procedural and functional features,
intended for application development and system programming. It was originally intended for
the Macintosh, but has been ported to many other computers. Implementations of Dylan are
available for most platforms including Unix, Macintosh, and Windows. Dylan has been
implemented as an interpreter, as a C front-end, and as a native compiler.
1993: Ruby
Based on earlier less known programming languages, Ruby was first a teaching language
created in the late 1960's based on Markov processes. It eventually developed into a hardware
specification language based on higher-order functions during the mid 1980's. The Ruby OOP
language is the 3rd programming language to bear that name. Ruby is an interpreted scripting
language, fully object-oriented and designed for easy extensibility. The syntax of Ruby is simple
but bears a strong resemblance to Perl.
1994: JavaScript
Invented by Netscape Communications for adding dynamic behavior to web pages, JavaScript
was originally called 'LiveScript'. Sun Microsystems, developer of Java, took an interest in this
powerful script and, along with Netscape, made some adjustments to re-introduce the script
under the new name of JavaScript. Unlike Java, which can be used to develop entirely
standalone applications, JavaScript works primarily with Web pages. JavaScript is a loosely
typed scripting language with object-oriented and block-structuring features. The syntax of
JavaScript is similar to that of C or Java, but simpler and not as rich. Primitive data types include
integers, reals, strings, and a associative arrays. Javascript is loosely typed, any variable can
contain data of any type, and conversion is mostly automatic. The language definition includes
extensive facilities for controlling and manipulating parts of web pages, especially HTML forms.
Each version of Netscape Navigator has brought a new version of JavaScript, and later versions
also include a complicated security model for restricting the hostile capabilities of scripts
embedded in web pages. Microsoft web browser also support Javascript, but under the name
"JScript".
1995: VBScript
Although VBScript was first developed in 1995, the first release of VBScript (v2.0) was part of
Microsoft's Internet Explorer 3.0 which came out in 1997. VBScript has no language-defined I/O
facilities, so that any I/O that it supports must be provided by object classes supplied from the
controlling application environment. In a web browser client, these objects are not available,
but in a web server environment they are. VBScript (Visual Basic Scripting Edition) is a subset
dialect of Visual Basic. It is an interpreted, procedural language intended for creating
application extension scripts and for adding interactivity to web pages.
12.2
Why do we need Programming Languages?
A programming language serves several purposes. We can instruct the computer what to do in
a human-readable form. Programming languages allow the programmer to structure the
instructions into functions, procedures, etc. This also allows the program to be broken into
"chunks" which can be developed by a group of developers. It also provides portability,
whereby the low-level instructions of one computer will be different from that of another
computer. A high-level language hides that.
A programming language is important because it defines the relationship, semantics and
grammar which allow the programmers to effectively communicate with the machines that
they program. Just as French allows French people to communicate with each other and
German allows German people to communicate with each other. Learning a programming
language is something that you do in order to communicate with a machine. Just like a German
person would learn the French language in order to communicate with a French person.
12.3
Generations of Programming Languages
The first and second generation languages (1950-60)
These languages also called the machine and assembly languages. Developments in early 1950
brought us machine language without interpreters and compilers to translate languages. Microcode is an example of the first generation language residing in the CPU written for doing
multiplication or division. Computers then were programmed in binary notation that was very
prone to errors. A simple algorithm resulted in lengthy code. This was then improved to
mnemonic codes to represent operations.
Symbolic assembly codes came next in the mid 1950's, the second generation of programming
language like AUTOCODER, SAP and SPS. Symbolic addresses allowed programmers to
represent memory locations, variables and instructions with names. Programmers now had the
flexibility not to change the addresses for new locations of variables whenever they are
modified. This kind of programming is still considered fast and to program in machine language
required high knowledge of the CPU and machine's instruction set. This also meant high
hardware dependency and lack of portability. Assembly or machine code could not run on
different machines. Example, code written for the Intel® Processor family would look very
different for code written for the Motorola 68X00 series. To convert would mean changing a
whole length of code.
The third generation languages.
Throughout the early 1960's till 1980 saw the emergence of the third generation programming
languages. Languages like ALGOL 58, 60 and 68, COBOL, FORTRAN IV, ADA and C are examples
of this and were considered as high level languages. Most of these languages had compilers and
the advantage of this was speed. Independence was another factor as these languages were
machine independent and could run on different machines. The advantages of high level
languages include the support for ideas of abstraction so that programmers can concentrate on
finding the solution to the problem rapidly, rather than on low-level details of data
representation. The comparative ease of use and learning, improved portability and simplified
debugging, modifications and maintenance led to reliability and lower software costs. Third
generation languages often followed procedural code, meaning the language performs
functions defined in specific procedures on how something is done.
The fourth generation languages
Features evident in fourth generation languages quite clearly are that it must be user friendly,
portable and independent of operating systems, usable by non-programmers, having intelligent
default options about what the user wants and allowing the user to obtain results fasts using
minimum requirement code generated with bug-free code from high-level expressions
(employing a data-base and dictionary management which makes applications easy and quick
to change), which was not possible using COBOL or PL/I. Standardization however, in early
stages of evolution can inhibit creativity in developing powerful languages for the future.
Examples of this generation of languages are IBM's ADRS2, APL, CSP and AS, Power Builder,
Access.
The fifth generation languages
The 1990's saw the developments of fifth generation languages like PROLOG, referring to
systems used in the field of artificial intelligence, fuzzy logic and neural networks. Complex
processes like understanding speech would appear to be trivial using these fast inferences and
would make the software seem highly intelligent. In fact, these databases programmed in a
specialized area of study would show a significant expertise greater than humans. Also,
improvements in the fourth generation languages now carried features where users did not
need any programming knowledge. Little or no coding and computer aided design with graphics
provides an easy to use product that can generate new applications.
The sixth generation
It is uncertain at the moment. With fast processors, like in fifth generation computers, able to
have multiple processors operating in parallel to solve problems simultaneously will probably
ignite a whole new type of language being designed. The current trend of the Internet and the
World Wide Web could cultivate a whole new breed of radical programmers for the future, now
exploring new boundaries with languages like HTML and Java. What happens next is entirely
dependent on the future needs of the whole computer and communications industry.
12.4
Programming languages categories
Programming languages can be categories in various ways but a more practical way of
classifying languages is to classify them by problem-domain or in other words, context. So we
will have languages classified as:

System Languages

Architectural Languages

Application Languages
System Languages
These languages are best used to build operating systems, hardware drivers etc. they are fast
and gives you low level (close to the core) access to the computer. These languages are used
when speed is critical. These languages include:

C

C++

Assembler
Architectural Languages
These languages are best used to build frameworks that support (make easy) application
building. They are not as fast (at run-time) as system level languages, but they provide a higher
level of abstraction that makes writing software quicker and more productive. These languages
include:

Java

C#
Application Languages
These languages are best used to build the actual business applications like web shopping
carts/stores, connecting to databases and creating the screens for users to interact with the
database. These languages include:

PHP

Ruby

Perl

Python
These languages all allow for extremely fast development. Programmers are freed from the
low-level details that you have to contend with when working with architectural and system
level languages. The fact that they’re all scripting languages (that don’t need to be compiled,)
adds to the ease of use and speed of development.
12.5
Examples of Programming Languages
There are many examples of programming languages and some of them have already been
described in the previous sections. If you want to know more about any of them or new ones,
you may click on the following links.




















A-0
Ada
ALGOL
Alphard
ALTRAN
APL
AspectJ
Assembly
Autocode
AWK
B
BASIC
BCPL
BLISS
C
C#
C++
CAML
CLOS
COBOL
















































Concurrent Prolog
CPL
CSP
dBASE II
Design System Language
Dylan
ECMAScript
Eiffel
Euler
FLOW-MATIC
Forth
FORTRAN
FP
GAP
Haskell
HTML
HyperTalk
Icon
IPL
ISWIM
Java
JavaScript
LISP
LOGO
MATH-MATIC
Mathmatica
Miranda
ML
Modula
Modula-2
Objective C
OPS5
Parlog
Pascal
Perl
PHP
Plantalkül
PL/I
PostScript
Pov-Ray
Prolog
Python
RATFOR
REBOL
Relational Language
RPG
Ruby
SASL











Scala
Scheme
Scriptol
Short Code
Simula
SmallTalk
SNOBOL
SQL
Standard ML
UML
UNIX shell script
Summary:
There were significant events in history that lead up to where we are today with Programming
Languages. It started in 1949 when Short Code was invented. It is the first computer language
actually used on an electronic computing device. The programmer was required to, by hand,
change its statements into 0's and 1's for the processor to understand.
Programming languages allow the programmer to structure the instructions into functions,
procedures, etc. This also allows the program to be broken into "chunks" which can be
developed by a group of developers. Since we started, there are now five generations of
Programming Languages. The first and second generation languages (1950-60) are languages
which also called the machine and assembly languages. The second generation of programming
languages used symbolic addresses allowed programmers to represent memory locations,
variables and instructions with names. The third generation languages were considered as high
level languages. The fourth generation languages quite clearly are that it must be user friendly,
portable and independent of operating systems and usable by non-programmers. The fifth
generation languages like PROLOG, referring to systems used in the field of artificial
intelligence, fuzzy logic and neural networks.
Programming languages can be classified as: System Languages, Architectural Languages and
Application Languages. System Languages are used when speed is critical. Architectural
Languages are best used to build frameworks that support (make easy) application building.
Application Languages are all scripting languages (that don’t need to be compiled,) adds to the
ease of use and speed of development.
Exercises
Fill in the blanks:
1. ….. are best used to build the actual business applications like web shopping carts/stores,
connecting to databases and creating the screens for users to interact with the database.
2. ….. are not as fast (at run-time) as system level languages, but they provide a higher level of
abstraction that makes writing software quicker and more productive.
3. …. are used when speed is critical.
4. ….. generation languages quite clearly are that it must be user friendly, portable and
independent of operating systems, usable by non-programmers.
5. Languages like ALGOL 58, 60 and 68, COBOL, FORTRAN IV, ADA and C are examples of the
…. generation languages.
6. A ….. is important because it defines the relationship, semantics and grammar which allow
the programmers to effectively communicate with the machines that they program.
7. …. is an interpreted, object-oriented language. It is intended to be highly effective, easy to
use, and extensible. Its syntax is very simple and statement-oriented.
8. ….. was developed from the ground up as the language for business men. Its statements
have a very English-like grammar, making it quite easy to learn, especially for the business
men for which it was designed.
Answers:
1.
2.
3.
4.
5.
6.
7.
8.
Application languages
Architectural languages
System languages
Fourth
Third
programming language
Python
COBOL
Short essay questions:
1. Describe the history of programming languages and its evolution to the present stage
2. Why do we need to use programming languages?
3. Describe the different generations of programming languages
4. Describe the different categories of programming languages
5. Provide 3 examples of programming languages and write short notes about them – why
they are invented, the area which they are best used and their acceptance in the
software development industry.