Programming language:

A programming language is an artificial language designed to express computations that can be

performed by a machine, particularly a computer. Programming languages can be used to create
programs that control the behavior of a machine, to express algorithms precisely, or as a mode of
human communication.

Many programming languages have some form of written specification of their syntax (form)
and semantics (meaning). Some languages are defined by a specification document. For
example, the C programming language is specified by an ISO Standard. Other languages, such as
Perl, have a dominant implementation that is used as a reference.

The earliest programming languages predate the invention of the computer, and were used to
direct the behavior of machines such as Jacquard looms and player pianos. Thousands of
different programming languages have been created, mainly in the computer field, with many
more being created every year. Most programming languages describe computation in an
imperative style, i.e., as a sequence of commands, although some languages, such as those that
support functional programming or logic programming, use alternative forms of description.

Definitions

A programming language is a notation for writing programs, which are specifications of a

computation or algorithm. Some, but not all, authors restrict the term "programming language" to
those languages that can express all possible algorithms. Traits often considered important for
what constitutes a programming language include:

 Function and target: A computer programming language is a languageused to write computer

programs, which involve a computer performing some kind of computation or algorithm and
possibly control external devices such as printers, disk drives, robots, and so on. For example
PostScript programs are frequently created by another program to control a computer printer or
display. More generally, a programming language may describe computation on some, possibly
abstract, machine. It is generally accepted that a complete specification for a programming
language includes a description, possibly idealized, of a machine or processor for that language.
In most practical contexts, a programming language involves a computer; consequently
programming languages are usually defined and studied this way. Programming languages differ
from natural languages in that natural languages are only used for interaction between people,
while programming languages also allow humans to communicate instructions to machines.

 Abstractions: Programming languages usually contain abstractions for defining and manipulating
data structures or controlling the flow of execution. The practical necessity that a programming
language support adequate abstractions is expressed by the abstraction principle; this principle
is sometimes formulated as recommendation to the programmer to make proper use of such
abstractions. Expressive power: The theory of computation classifies languages by the
computations they are capable of expressing. All Turing complete languages can implement the
same set of algorithms. ANSI/ISO SQL and Charity are examples of languages that are not Turing
complete, yet often called programming languages .[10][11]
Markup languages like XML, HTML or troff, which define structured data, are not generally
considered programming languages. Programming languages may, however, share the syntax
with markup languages if a computational semantics is defined. XSLT, for example, is a Turing
complete XML dialect. Moreover, LaTeX, which is mostly used for structuring documents, also
contains a Turing complete subset.

The term computer language is sometimes used interchangeably with programming language.
However, the usage of both terms varies among authors, including the exact scope of each. One
usage describes programming languages as a subset of computer languages. In this vein,
languages used in computing that have a different goal than expressing computer programs are
generically designated computer languages. For instance, markup languages are sometimes
referred to as computer languages to emphasize that they are not meant to be used for
programming. Another usage regards programming languages as theoretical constructs for
programming abstract machines, and computer languages as the subset thereof that runs on
physical computers, which have finite hardware resources. John C. Reynolds emphasizes that
formal specification languages are just as much programming languages as are the languages
intended for execution. He also argues that textual and even graphical input formats that affect
the behavior of a computer are programming languages, despite the fact they are commonly not
Turing-complete, and remarks that ignorance of programming language concepts is the reason
for many flaws in input formats.

Specification
Main article: Programming language specification

The specification of a programming language is intended to provide a definition that the

language users and the implementors can use to determine whether the behavior of a program is
correct, given its source code.

A programming language specification can take several forms, including the following:

 An explicit definition of the syntax, static semantics, and execution semantics of the language.
While syntax is commonly specified using a formal grammar, semantic definitions may be
written in natural language (e.g., as in the C language), or a formal semantics (e.g., as in
Standard ML and Scheme specifications).
 A description of the behavior of a translator for the language (e.g., the C++ and Fortran
specifications). The syntax and semantics of the language have to be inferred from this
description, which may be written in natural or a formal language.
 A reference or model implementation, sometimes written in the language being specified (e.g.,
Prolog or ANSI REXX]). The syntax and semantics of the language are explicit in the behavior of
the reference implementation.

Implementation
Main article: Programming language implementation

An implementation of a programming language provides a way to execute that program on one

or more configurations of hardware and software. There are, broadly, two approaches to
programming language implementation: compilation and interpretation. It is generally possible
to implement a language using either technique.

The output of a compiler may be executed by hardware or a program called an interpreter. In

some implementations that make use of the interpreter approach there is no distinct boundary
between compiling and interpreting. For instance, some implementations of BASIC compile and
then execute the source a line at a time.

Programs that are executed directly on the hardware usually run several orders of magnitude
faster than those that are interpreted in software.[citation needed]

One technique for improving the performance of interpreted programs is just-in-time

compilation. Here the virtual machine, just before execution, translates the blocks of bytecode
which are going to be used to machine code, for direct execution on the hardware.

History

A selection of textbooks that teach programming, in languages both popular and obscure. These are
only a few of the thousands of programming languages and dialects that have been designed in history.

Main articles: History of programming languages and Programming language generations

Early developments

The first programming languages predate the modern computer. The 19th century had
"programmable" looms and player piano scrolls which implemented what are today recognized
as examples of domain-specific languages. By the beginning of the twentieth century, punch
cards encoded data and directed mechanical processing. In the 1930s and 1940s, the formalisms
of Alonzo Church's lambda calculus and Alan Turing's Turing machines provided mathematical
abstractions for expressing algorithms; the lambda calculus remains influential in language
design.

In the 1940s, the first electrically powered digital computers were created. The first high-level
programming language to be designed for a computer was Plankalkül, developed for the German
Z3 by Konrad Zuse between 1943 and 1945. However, it was not implemented until 1998 and
2000.

Programmers of early 1950s computers, notably UNIVAC I and IBM 701, used machine
language programs, that is, the first generation language (1GL). 1GL programming was quickly
superseded by similarly machine-specific, but mnemonic, second generation languages (2GL)
known as assembly languages or "assembler". Later in the 1950s, assembly language
programming, which had evolved to include the use of macro instructions, was followed by the
development of "third generation" programming languages (3GL), such as FORTRAN, LISP,
and COBOL. 3GLs are more abstract and are "portable", or at least implemented similarly on
computers that do not support the same native machine code. Updated versions of all of these
3GLs are still in general use, and each has strongly influenced the development of later
languages. At the end of the 1950s, the language formalized as ALGOL 60 was introduced, and
most later programming languages are, in many respects, descendants of Algol. The format and
use of the early programming languages was heavily influenced by the constraints of the
interface.

overall structure:

    Programming languages can be implemented with compilers, assemblers, and interpretters. A

compiler converts high level source code into executable object code (also called binary code or
machine code). An assembler converts assembly language source code into executable object
code. An interpretter translates either source code or tokens into machine code, one instruction at
a time, as the program is run. Object oriented programming (as well as the implementation of
some kinds of data structures) blurs the line between compilers and interpretters.

    nature: The two most common kinds of programming languages are procedural and object
oriented.

    format: The two basic formats for programming languages are free form and column. Older
programming languages were typically designed to fit into the columns of Hollerith “punch”
cards, with specific fields being reserved for specific purposes. Modern programming langauges
are free form in the sense that there are no specific columns that various items must line up in.

lexical elements

    character set: There are two character sets to consider: the source code character set and the
execution character set. The source code character set is the set of characters allowed for writing
source code programs. The execution character set is the set of characters recognized and used
by running programs. These may be the same character set, but usually are different (usually
there are more characters allowed in the execution character set and some languages have
mechanisms for specifically handling multiple execution character sets. The source code
character set can vary for different parts of the language. Some programming languages have
case sensitive source code character sets (that is, identifiers that differ only in case are considered
to be different identifiers), while other programming languages have case insensitive source code
character sets (that is, identifiers that differ only in case are considered to be the same identifier).

    Very few programming languages require a specific character encoding for the execution
character set. Some of the common character encodings in use include ASCII, EBCDIC, and
UniCode. A common cross-platform programming error is to assume a specific character set. For
example, the expression ('Z' - 'A' + 1) will produce the number of letters in the alphabet (26)
when either ASCII or UniCode is used, but will produce the answer 41 when EBCDIC is used
(because the letters of the alphabet are not encoded consecutively in EBCDIC). Another common
error regards the use of the high eight bit characters in ASCII, which are typically different on
each different operating system.

    white space: White space is any blanks (or space characters) in the source code. Some
programming languages define additional characters as white space. These may include
horizontal tab, vertical tab, end of line, form feed, carriage return, and line feed. In some
programming languages, comments are treated as white space. White space is sometimes
compacted into a single space character by the compiler. White space may be optional or
required (and whether it is optional or required can vary at different parts of the source code).

    line termination: Some modern programming languages ignore line returns, while others use
them as dividing lines between instructions (sometimes with a special character to indicate that
an instruction continues on more than one line and sometimes with a special character to allow
more than one instruction per line).

    line length: Some programming languages have fixed line lengths, while others have variable
line lengths. Fixed line lengths typically occur with programming languages that use columns.

    multibyte characters: Some programming languages have special multibyte encodings for
some characters. It is common to have an escape character(s) to allow programmers to indicate
special characters (such as non-printable characters, line breaks, characters reserved as special
symbols, etc.) in character or string constants. Some programming languages have special
character sequences for encoding required characters on older hardware that doesn’t support all
of the required source code character set. Some programming languages include have special
sequences for encoding multi-byte characters (such as non-Roman alphabets).

    comments: Every programming language except for machine language (writing in raw binary
opcodes) has some system for comments (and comments are sometimes even interspersed as
ASCII data between raw binary machine code). Comments are used to to make programs self-
documenting for future human maintenance or modification (most of the life of any successful
software is in maintenance, not initial programming). Comments are either removed or replaced
with white space.

    tokens: Tokens are the basic lexical building blocks of source code. Characters are combined
into tokens according to the rules of the programming language. There are five classes of tokens:
identifiers, reserved words, operators, separators, and constants.

    identifiers:

    reserved words:

    operators: Operators are tokens used to indicate an action to be taken (usually arithmetic
operations, logical operations, bit operations, and asignment operations). Operators can be
simple operators (a single character token) or compound operators (two or more character
tokens).

    separators: Separators are tokens used to separate other tokens. Two common kinds of
separators are indicators of an end of an instruction and separators used for grouping.

    constants:
control structures:

    There are three basic kinds of control structures: sequences, branching, and loops. Corrado
Böhm and Guiseppe Jacopini presented the proof of the Structured Theorem (which states that
any logic problem can be solved with only sequence, choice (IFTHENELSE), and repetition
(DOWHILE) structures) in “Flow Diagrams, Turing Machines and Languages with Only Two
Formation Rules”, Communications of the ACM, No. 5, May 1966, pp 366-371.

sequential structures:

    Sequential structures are structures that are stepped through sequential. These are also called
sequences or iterative structures. Basic arithmetic, logical, and bit operations are in this category.
Data moves and copies are sequences. Most register and processor control operations are
sequences. Some computer scientists group subroutines and functions as a special kind of
sequence, while others group them as a special kind of branching structure.

branching structures:

    Branching structures consist of direct and indirect jumps (including the infamous “GOTO”),
conditional jumps (IF), nested ifs, and case (or switch) structures.

loop structures:

    The basic looping structures are DO iterative, do WHILE, and do UNTIL. An infinite loop is
one that has no exit. Normally, infinite loops are programming errors, but event loops and task
schedulers are examples of intentional infinite loops.

objects:

    Object oriented programming does not fit neatly into the three basic categories, because the
three basic categories of control structures describe procedural programming. The internal
implementation of at least some methods will use the three basic structures, but this is hidden
from other objects.

machine code:

    Machine code can be written using the three basic structures, although on some particular
processors it may not be possible to write all of the structures as atomic code. Atomic means all
as one unit. On some processors it may be necessary to construct some structures with a series of
machine instructions instead of with a single machine instruction.

exception processing:

    Exception processing also doesn’t fall into the three basic categories. Normally, exception
processing only occurs in low level assembly or machine language programming. Some high
level languages provide “on conditions”, or the ability to designate routines to be run when an
exception or other special event occurs. The actual code that runs during the exception can be
written with just the three basic structures.

misc structures:

    There are some kinds of structures that don’t neatly fall into the above categories. Böhm-
Jacopini’s theory states that only the three basic structures are necessary, but obviously other
structures do exist. Use of these other structures is generally contraindicated (you will almost
certainly regret the decision to use them).

data structures:

    All information in binary digital computers is actually stored as a series of binary ones and
zeros. Those sequences of binary data are interpretted by the processor, by software, or by
humans as having some other meaning (numbers, characters, logic states, or complex data
structures).

PROGRAMMING LANGUAGES:
 A-0  history: Grace Hopper started work on A-0 in 1951

 A-0 (also known as AT-3), the first compiler, was created in 1952 by Grace Murray Hopper. She
later created A-2, ARITH-MATIC, MATH-MATIC, and FLOW-MATIC, as well as being one of the
leaders in the development of COBOL. Grace Hopper was working for Remington rand at the
time. Rand released the language as MATH-MATIC in 1957.

MATH-MATIC was released by the Rand Corporation in 1957. The language was derived from
Grace Murray Hopper’s A-0.

FLOW-MATIC, also called B-0, was created in 1957 by Grace Murray Hopper.

 Ada     history: Originally intended by the U.S. military as a unified language for
embedded systems, government bureaucrats attempted to make it an all-purpose language.

    Ada was first released in 1983 (ADA 83), with major releases in 1995 (ADA 95) and
2005 (ADA 2005). Ada was created by the U.S. Department of Defense (DoD),
originally intended for embedded systems and later intended for all military computing
purposes.

    Ada is named for Augusta Ada King, the Countess of Lovelace, the first computer
programmer in modern times.

“Ada is a computer language. It was the result of the efforts of numerous people, four of
whom stand out: Jean D. Ichbiah, William E. Carlson, David Fisher, and William A.
Whitaker. Together they recognized the need for a common computer language for the
 U.S. Department of Defense, to replace the over 400 different computer languages and
dialects previously in use there, and worked to develop this single one. Ada is a powerful
language, allowing types, subprograms, input-output facilities for numerous devices,
parallel processing, exception handling, and many other functions. Please note that it is
named for Countess Augusta Ada Lovelace, daughter of Lord Byron, and is therefore not
an acronym.” —Language Finger, Maureen and Mike Mansfield Library, University of
Montana.

SYNTAX: Hello World example

with Ada.Text_IO;
use Ada.Text_IO;

procedure HelloWorld is
begin
   Ada.Text_IO.Put_Line("Hello World");
end HelloWorld;

ALGOL history: Originally created in 1960 as an abstract language for describing

algorithms.

    IAL (International Algebraic Logic) started in 1958 as the project later renamed ALGOL 58.
The theoretical definition of the language was published. No compiler available.

    ALGOL (ALGOrithmic Language) was released in 1960. Major releases in 1960 (ALGOL
60) and 1968 (ALGOL 68). ALGOL was originally intended for scientific computations.

    ALGOL is the first block-structured labguage and is considered to be the first second
generation computer language. This was the first programming language that was designed to be
machine independent.

    ALGOL was a highly influential programming language. Most modern programming

languages are descendants of ALGOL.

    ALGOL became the most popular programming language in Europe in the mid- and late-
1960s.

    ALGOL introduced such concepts as: block structure of code (marked by BEGIN and END),
scope of variables (local variables inside blocks), BNF (Backus Naur Form) notation for defining
syntax, dynamic arrays, reserved words, IF THEN ELSE, FOR, WHILE loop, the := symbol for
assignment, SWITCH with GOTOs, and user defined data types.

    ALGOL W was created in 1966 by Niklaus Wirth. ALGOL W included RECORDs, dynamic
data structures, CASE, passing parameters by value, and precedence of operators.
    ALGOL 68 in 1968 introduced the =+ token to combine assignment and add, UNION, and
CASTing of types. It included the IF THEN ELIF FI structure, CASE structure, and user-defined
operators.

    “ALGOL was invented by an international committee — actually by several: the Association

for Computing Machinery (ACM) and the Gesellschaft fur angewandte Mathematik und
Mechanik (GAMM); and since 1958 has been overseen by the International Federation for
Information Processing (IFIP). Intended to be a language between machine level and
sophisticated programming languages, ALGOL serves programmers by translating programming
statements via algebra into machine code; thus it was early called “automatic programming.” The
name ALGOL is an acronym for “Algorithmic Language.” There are various dialects including
ALGOL 60 and ALGOL 68.” —Language Finger, Maureen and Mike Mansfield Library,
University of Montana

SYNTAX: Hello World example

BEGIN
   OUTSTRING(2, "Hello World");
END.

Alphard  history: Alphard (named for the brightest star in Hydra) was designed by
William Wulf, Mary Shaw, and Ralph London of Carnegie-Mellon University in 1974. A Pascal-
like language intended for data abstraction and verification. Make use of the “form”, which
combined a specification and an implementation, to give the programmer control over the
impolementation of abstract data types.

    “Alphard is a computer language designed to support the abstraction and verification

techniques required by modern programming methodology. Alphard’s constructs allow a
programmer to isolate an abstraction, specifying its behavior publicly while localizing
knowledge about its implementation. It originated from studies at both Carnegie-Mellon
University and the Information Sciences Institute.” —Language Finger, Maureen and Mike
Mansfield Library, University of Montana.

 ALTRAN history: ALTRAN, a variant of FORTRAN, was released in 1968.

APL history: APL (A Programming Language) was published in the 1962

book A Programming Language by Kenneth E. Iverson and a subset was first released in 1964.
The language APL was based on a notation that Iverson invented at Harvard University in 1957.
APL was intended for mathematical work and used its own special character set. Particularly
good at matrix manipulation. In 1957 it introduced the array. APL used a special character set
and required special I/O devices (special keyboards, printer heads, etc.).

    APL\360 implemented in 1964

nature: mathematical language

 AspectJ  history: AspectJ (Aspect for Java) was created at the Palo Alto Research
Center in 2001.

 Autocode history: Autocode, a symbolic assembler for the Manchester Mark I

computer, was created in 1952 by Alick E. Glennie. Later used on other computers.

 AWK history: Autocode, a symbolic assembler for the Manchester Mark I

computer, was created in 1952 by Alick E. Glennie. Later used on other computers.

nature: text processing language; interpreted

 B history: B (derived from BCPL) developed in 1969 by Ken Thompson of

Bell Telephone Laboratories for use in systems programming for UNIX. This was the parent
language of C.

BASIC history: BASIC (Beginner’s All-purpose Symbolic Instruction Code) was

designed as a teaching language in 1963 by John George Kemeny and Thomas Eugene Kurtz of
Dartmouth College. BASIC was intended to make it easy to learn programming. The first BASIC
program was run at 4 a.m. May 1, 1964.

    Tiny BASIC created by Dr. Wong in 1975 runs on Intel 8080 and Zilog Z80 computers.

    “BASIC was one of the first computer languages invented. It was developed by John G.
Kemeny and Thomas E. Kurtz, two mathematics professors at Dartmouth College in 1964, with
the aim of providing their students with an easily learned language that could still handle
complicated programming projects. The acronym stands for Beginner’s All-purpose Symbolic
Instruction Code. Since then there have been many revisions and versions of it. Just as with other
popular computer languages, there is a version of BASIC for just about every brand of computer,
and most of these differ slightly. Additionally, QBasic is a version of BASIC written by
Microsoft to incorporate structured programming into BASIC, and to take advantage of other
capabilities of modern personal computers. QBasic has most of the features of standard BASIC
plus many enhancements. There is another dialect called Visual BASIC, plus its offshoot, VBA,
or Visual Basic for Applications. VBScript is a subset of VBA, designed to be ‘light.’” —
Language Finger, Maureen and Mike Mansfield Library, University of Montana

nature: procedural language; block-structured

SYNTAX: Hello World example

10 PRINT "Hello World"

BCPL  history: BCPL (Basic CPL) was created in 1969 in England. Intended as
a simplified version of CPL, includes the control structures For, Loop, If Then, While, Until
Repeat, Repeat While, and Switch Case.

history: CPL (Combined Programming Language) was created in 1967 at

Cambridge and London Universities. Combined ALGOL 60 and functional language. Used
polymorphic testing structures. Included the ANY type, lists, and arrays.

    “BCPL was an early computer language. It provided for comments between slashes. The name
is condensed from “Basic CPL”; CPL was jointly designed by the universities of Cambridge and
London. Officially, the “C” stood first for “Cambridge,” then later for “Combined.” --
Unofficially it was generally accepted as standing for Christopher Strachey, who was the main
impetus behind the language.” —Language Finger, Maureen and Mike Mansfield Library,
University of Montana.

nature: procedural language; block structured

 BLISS history: BLISS was a systems programming language developed by W.A.

Wulf, D.B. Russell, and A.N. Habermann at Carnegie Mellon University in 1970. BLISS was a very
popular systems programming language until the rise of C. The original compiler was noted for
its optimizing of code. Most of the utilities for DEC’s VMS operating system were written in
BLISS-32. BLISS was a typeless language based on expressions rather than statements.
Expressions produced values, and possibly caused other actions, such as modification of storage,
transfer of control, or looping. BLISS had powerful macro facilities, conditional execution of
statements, subroutines, built-in string functions, arrays, and some automatic data conversions.
BLISS lacked I/O instructions on the assumption that systems I/O would actually be built in the
language.

nature: systems language

C history: C was developed from 1969-1972 by Dennis Ritchie (with assistance by

Brian W. Kernighan) of Bell Telephone Laboratories for use in systems programming for UNIX.

    “C is a computer programming language. It was developed out of the construction of the
UNIX operating system. It has a modular programming structure and is thus useful in object
oriented programming, as well as in developing graphical user interfaces. C++ is a superset of C.
Other dialects include Small-C and Visual C.” —Language Finger, Maureen and Mike Mansfield
Library, University of Montana.

nature: systems langauge; procedural language

SYNTAX: Hello World example

#include <stdio.h>

main()
{
   printf("Hello World\n");
}

 C# history: C# was created by Anders Hajlsberg of Microsoft in 2000. The main

language of Microsoft’s .NET.

nature: object oriented language

 C++ Note: C++ is a superset of C

nature: object oriented language; procedural language

history: An extension of C to provide object oriented programming

constructs.

    C++ was developed in 1983 by Bjarne Stroustrup at Bell Telephone

Laboratories to extend C for object oriented programming

SYNTAX: Hello World example

#include <iostream.h>

int main(int argc, char *argv[])

{
   cout << "Hello World" << endl;
   return 0;
}

 CAML history: CAML (Categorical Abstract Machine Language) was created by

Suarez, Weiss, and Maury in 1987.
CLOS nature: object oriented language

history: CLOS, an object oriented version of LISP, was developed in

1988

COBOL  history: COBOL (COmmon Business Oriented Language) was created in May
1959 by the Short Range Committee of the U.S. Department of Defense (DoD) for business
programming. The CODASYL committee (COnference on DAta SYstems Languages) worked from May
1959 to April 1960. Official ANSI standards included COBOL-68 (1968), COBOL-74 (1974), COBOL-85
(1985), and COBOL-2002 (2002). COBOL 97 (1997) introduced an object oriented version of COBOL.
COBOL programs are divided into four divisions: identification, environment, data, and procedure. The
divisions are further divided into sections. Introduced the RECORD data structure. Emphasized a verbose
style intended to make it easy for business managers to read programs. Admiral Grace Hopper is
recognized as the major contributor to the original COBOl language and as the inventor of compilers.

 nature: procedural language

 ANSI version of COBOL defined in 1968.

SYNTAX: Hello World example

IDENTIFICATION DIVISION.
PROGRAN-ID. HelloWorld.
AUTHOR. Milo.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
INPUT-OUTPUT SECTION.

DATA DIVISION.
FILE SECTION.
WORKING-STORAGE SECTION.
LINKAGE SECTION.

PROCEDURE DIVISION.
DISPLAY "Hello World".
STOP RUN.

 Concurrent Prolog history: Concurrent Prolog was created in 1983 by

Shapiro. Based on Prolog.

history: Prolog (PROgramming LOGic) was created in 1972 in France by Alan Colmerauer with
Philippe Roussel. Introduces Logic Programming.

nature: logic language

SYNTAX: Hello World example

?- write('Hello World'), nl.

 CPL history: CPL (Combined Programming Language) was created in 1967 at

Cambridge and London Universities. Combined ALGOL 60 and functional language. Used
polymorphic testing structures. Included the ANY type, lists, and arrays.

CSP  history: CSP was created in 1978 by C.A.R. Hoare.

    “C.A.R. Hoare wrote a paper in 1978 about parallel computing in which he included a
fragment of a language. Later, this fragment came to be known as CSP. In it, process
specifications lead to process creation and coordination. The name stands for Communicating
Sequential Processes. Later, the separate computer language Occam was based on CSP.” —
Language Finger, Maureen and Mike Mansfield Library, University of Montana.

 dBASE II history: dBASE II was created in 1980 by Wayne Ratliff at the Jet
Propulsion Laboratories in Pasadena, California. The original version of the language was called
Vulcan. Note that the first version of dBASE was called dBASE II.

 Design System Language history: Design System Language, a forerunner

of PostScript, was created in 1976. The Forth-like language handles three dimensional
databases.

 Dylan history: Dylan was created in 1992 by Apple Computer and others.
Dylan was originally intended for use with the Apple Newton, but wasn’t finished in time.

nature: object oriented language

SYNTAX: Hello World example

define method hello-world()

   format-out("Hello World\n");
end method hello-world;

hello-world();
  ECMAScript  history: ECMAScript (named for the European standards group
E.C.M.A.) was created in 1997

Eiffel history: Eiffel (named for Gustave Eiffel, designer of the Eiffel Tower)
was released in 1986 by Bertrand Meyer. Work started on September 14, 1985.

    “Eiffel is a computer language in the public domain. Its evolution is controlled by Nonprofit
International Consortium for Eiffel (NICE), but it is open to any interested party. It is intended to
treat software construction as a serious engineering enterprise, and therefore is named for the
French architect, Gustave Eiffel. It aims to help specify, design, implement, and change quality
software.” —Language Finger, Maureen and Mike Mansfield Library, University of Montana.

nature: object oriented language

 Euler history: Euler was created in 1966 by Niklaus Wirth

 FLOW-MATIC history: FLOW-MATIC, also called B-0, was created in 1957 by

Grace Murray Hopper. Based on A-0.

Forth history: Forth was created by Charles H. Moore in 1968. Stack based language.
Forth was a reference to Moore’s claim that he had created a courth generation programming
language.

    Forth used to write the program to control the Kitt Peaks telescope.

nature: threaded stack-based language

SYNTAX: Hello World example

: hello_world ." Hello World" ;

FORTRAN history: FORTRAN (FORmula TRANslation) was created in
1954 by John Backus and other researchers at International Business Machines (now IBM).
Released in 1957. Intended for numerical and scientific work. FORTRAN is the oldest
programming language still in common use. Identifiers were limited to six characters. Elegant
representation of mathematic expressions, as well as relatively easy input and output. FORTRAN
was based on A-0.

    The first commercial FORTRAN program was run in 1957 at Westinghouse. The first compile
run produced a missing comma diagnostic. The second attempt was a success.

    “FORTRAN is a computer language first developed in the 1950’s and still used today. Its
name comes from “formula translation,” revealing its early use in processing mathematics.
Dialects include FORTRAN 77and FORTRAN 90. Versions include FORTRAN II, IV, and V,
WATFOR, and WATFIV.” —Language Finger, Maureen and Mike Mansfield Library,
University of Montana.

    “Often referred to as a scientific language, FORTRAN was the first high-level language, using
the first compiler ever developed. Prior to the development of FORTRAN computer
programmers were required to program in machine/assembly code, which was an extremely
difficult and time consuming task, not to mention the dreadful chore of debugging the code. The
objective during its design was to create a programming language that would be: simple to learn,
suitable for a wide variety of applications, machine independent, and would allow complex
mathematical expressions to be stated similarly to regular algebraic notation. While still being
almost as efficient in execution as assembly language. Since FORTRAN was so much easier to
code, programmers were able to write programs 500% faster than before, while execution
efficiency was only reduced by 20%, this allowed them to focus more on the problem solving
aspects of a problem, and less on coding.” —Neal Ziring, The Language Guide, University of
Michigan

    “FORTRAN was so innovative not only because it was the first high-level language [still in
use], but also because of its compiler, which is credited as giving rise to the branch of computer
science now known as compiler theory. Several years after its release FORTRAN had developed
many different dialects, (due to special tweaking by programmers trying to make it better suit
their personal needs) making it very difficult to transfer programs from one machine to another.”
—Neal Ziring, The Language Guide, University of Michigan

    FORTRAN II in 1958 introduced subroutines, functions, links to assembly language, loops,

and a primitive For loop.

    FORTRAN IV was released in 1962.

    FORTRAN 66 was released in 1966. The language was rarely used.

SYNTAX: Hello World example

PROGRAM HELLO
      WRITE(UNIT=*, FMT=*) 'Hello World'
      END

 FP history: FP was presented by John Backus in his 1977 Turing Award lecture Can
Programming be Liberated From the von Neumann Style? A Functional Style and its Algebra of
Programs.

nature: functional language; interpreted language

 GAP history: GAP (Groups, Algorithms, and Programming) was developed in 1986 by
Johannes Meier, Werner Nickel, Alice Niemeter, Martin Schönert, and others. Intended to
program mathematical algorithms

Haskell nature: functional language

     history: Haskell was developed in 1990

HTML history: HTML (HyperText Markup Language) was developed in 1989.

    “HTML stands for HyperText Machine (or Markup) Language. HTML is a subset of SGML.
It is a computer language used to create webpages. A newer version now exists, called Dynamic
HTML, or DHTML.” —Language Finger, Maureen and Mike Mansfield Library, University of
Montana.

SYNTAX: Hello World example

<html>
<head>
<title>Hello World</title>
</head>
<body>
<p>Hello World</p>
</body>
</html>
HyperTalk  history: HyperCard was created by William Atkinson in 1987.
HyperTalk was the scripting language built into HyperCard.

    “Apple Computer Company created a product called HyperCard for use in dealing with
hypertext and hypermedia on their Macintosh computer. HyperTalk is HyperCard’s
programming language. (Hypertext is the use of a computer to automate links and follow their
paths from one portion of text to another, going wherever the information which the user seeks is
located. Hypermedia is the same idea within a multimedia environment.)”

nature: scripting language

Icon  nature: procedural language

     history: Icon, based on SNOBOL, was created in 1977 by faculty, staff, and
students at the University of Arizona. Structured types include list, set, and table (dictionary).

 “Icon is a high-level, general purpose programming language, with many features for processing
symbolic data such as strings of chains and structures. Icon grew out of a desire to find a more
easily implemented language than SNOBOL. First implemented in 1979 (and written in Ratfor),
Icon has been continually developed and refined. It is an expression-level language more
powerful than Pascal or C. In Icon, a string of characters IS a value.” —Language Finger,
Maureen and Mike Mansfield Library, University of Montana.

 IPL history: IPL (Information Processing Language) was created in 1956 by A.

Newell, H. Simon, and J.C. Shaw. IPL was a low level list processing language which implemented
recursive programming.

Java history: Java (named for coffee) was created by James Gosling and others at Sun
Microsystems for embedded systems and released for applets in 1995. Original work started in
1991 as an interactive language under the name Oak. Rewritten for the internet in 1994.

    “Java is a computer language, but very powerful, intended to be machine and operating-
system independent. Java will enable whatever functions the piece you call up or download has,
including sound, video, etc., on your screen. It also is interactive, and can produce dynamic
images on your screen, not just static ones. It was developed by Sun Micro. There is a dialect
called Hot Java; on the other hand, JavaScript is a separate language.” —Language Finger,
Maureen and Mike Mansfield Library, University of Montana.

    Java should not be confused with Microsoft’s J++. Microsoft was worried about the success of
Java for two reasons: (1) Java directly competed with Windows CE as a system for embedded
devices, and (2) Java is cross-platform and therefore threatens the dominance of Windows. So,
Microsoft created their own version of Java, which was purposely slightly different. In addition
to adding a few Microsoft-only objects (available only when used on the latest versions of
Windows) and dropping a few general Java objects, Microsoft purposely made some objects
behave differently in their version than in pure Java. The prupose was to sew confusion and
cause Java programs written on Microsoft platforms to fail on other platforms and Java programs
written on other platforms to fail on Microsoft platforms, hoping this would lead to a widespread
belief that Java was unreliable. For a period of time, Sun used the “Pure Java” slogan to try to
distinguish between Microsoft’s version and the real thing. Eventually Sun won in court and and
got a U.S> federal court order preventing Microsoft from calling their own language “Java”.
Microsoft was forced to switch to an alternate name (“J++”).

SYNTAX: Hello World example

import java.applet.*;
import java.awt.*;
Public class HelloWorld extends Applet
{
public void paint(Graphics g)
   {
      g.drawstring("Hello World".,10,10);
   }
}

JavaScript  nature: scripting language with both object oriented and block structured
features

     history: JavaScript (originally called LiveScript) was created by

Brendan Elch at Netscape in 1995. A scripting language for web pages.

    “JavaScript is the scripting language developed by Netscape for use with the Java computer
language. It is designed for smaller applications than Java, yet it is a full-blown, powerful,
general-purpose programming language. Microsoft calls it Jscript. JavaScript and Jscript are very
differently implemented from Java. The language is also known as ECMAScript.”

LISP nature: list processing language

    history: LISP (LISt Processing) was created n 1958 and released in 1960 by John McCarthy
of MIT. LISP is the second oldest programming language still in common use. LISP was
intended for writing artificial intelligence programs.

SYNTAX: Hello World example

(print "Hello World".)

LOGO nature: functional language

    history: Logo was created in 1967 (work started in 1966) by Seymour Papert. Intended as a
programming language for children. Started as a drawing program. Based on moving a “turtle”
on the computer screen.

SYNTAX: Hello World example

print [Hello World]

Modula-2 nature: procedural language

    history: Modula-2 was released in 1979. Created by Niklaus Wirth at ETH in Zurich,
Switzerland. Wirth also created the Lilith computer, a Modula-2 machine.

    Modula-2 was based on Pascal and Modula. “Modula-2 has separately compiled library
modules, and makes much less use of blocks (begin...) than Standard Pascal. Identifiers are case
sensitive; there is no goto label; and I/O is in libraries rather than built in. The IF statement is
more versatile; and there are facilities for concurrent programming via coroutines. Extended
Pascals may have some of these features.” according to Modula-2 FAQ

SYNTAX: Hello World example

MODULE HelloWorld;
FROM InOut IMPORT WriteString, WriteLn;
BEGIN
   WriteString('Hello World');
   WriteLn;
END HelloWorld.

Pascal  nature: procedural language

    history: Pascal (named for French religious fanatic and mathematician Blaise Pascal) was
created in 1970 by Niklaus Wirth on a CDC 6000-series computer. Work started in 1968. Pascla
intended as a teaching language to replace BASIC. Programs compiled to an intermediate P-
code, that is platform independent.

    “The computer language Pascal was developed between 1968 and 1971, from ALGOL. It was
named for the French mathematician Blaise Pascal. Its highly-structured nature makes it
especially well-suited for developing algorithms.” —Language Finger, Maureen and Mike
Mansfield Library, University of Montana.
 SYNTAX: Hello World example

Hello World example

PROGRAM HelloWorld (OUTPUT);

BEGIN
   WRITELN('Hello World');
END.

Perl nature: scripting language

    history: Perl (Practical Extracting and Report Language) was created by Larry Wall in 1987.
Intended to replace the Unix shell, Sed, and Awk. Used in CGI scripts.

SYNTAX: Hello World example

print "Hello World\n";

PHP nature: scripting language

history: PHP (PHP Hypertext Processor) was created by Rasmus Lerdorf in

1995.

SYNTAX: Hello World example

<?php
   echo "Hello World\n";
?>

 Plantalkül history: Plankalkül (Plan Calculus), created in 1945 by Konrad Zuse for
the Z3 computer in Nazi germany, may have been the first programming language (other than
assemblers). This was a surprisingly advanced programming language, with many features that
didn’t appear again until the 1980s.

 PL/I history: Work on PL/I started in 1963. PL/I (Programming Language One) was
created in 1964 at IBM’s Hursley Laboratories in the United Kingdom. PL/I was intended as an
all-purpose langauge to combine the scientific abilities of FORTRAN with the business
capabilities of COBOL, plus additional facilities for systems programming. Also borrows from
ALGOL 60. Originally called NPL, or New Programming Language. Introduces storage classes
 (automatic, static, controlled, and based), exception processing (On conditions), Select When
Otherwise conditional structure, and several variations of the DO loop. Numerous data types,
including control over precision

SYNTAX: Hello World example

HELLO: PROCEDURE OPTIONS (MAIN);

   PUT SKIP LIST('HELLO WORLD');
END HELLO;

PostScript nature: threaded stack-based language (intended for graphics rendering)

    history: PostScript was created in 1982 by a team of researchers at Xerox PARC

SYNTAX: Hello World example

/Courier findfont
14 scalefont
setfont
0 0 moveto
(Hello World) show
showpage

 Pov-Ray history: Pov-Ray (Persistence of Vision) was created in 1991 by D.B.A. Collins
and others. A language for describing 3D images

 Prolog  history: Prolog (PROgramming LOGic) was created in 1972 in France by Alan
Colmerauer with Philippe Roussel. Introduces Logic Programming.

nature: logic language

SYNTAX: Hello World example

?- write('Hello World'), nl.

 Python  history: Python (named for Monty Python Flying Circus) was created in 1991 by
Guido van Rossum. A scripting language with dynamic types intended as a replacement for Perl.
 nature: object oriented language; interpreted language

SYNTAX: Hello World example

print: "Hello World

 Relational Language  history: Relational Language was created in 1981 by Clark and
Gregory
 SASL history: SASL (Saint Andrews Static Language) was created by D. Turner in 1976.
Intended for teaching functional programming. Based on ISWIM. Unlimited data structures.
 Scala  history: Scala was created February 2004 by Ecole Polytechnique Federale de
Lausanne. Object oriented language that implements Python features in a Java syntax.
 Scheme history: Scheme, based on LISP, was created by Guy Lewis Steele Jr. and Gerald
Jay Sussman at MIT in 1975.
 Scriptol history: Scriptol (Scriptwriter Oriented Language) was created by Dennis G.
Sureau in 2001. New control structuress include for in, while let, and scan by. Variables and
literals are objects. Supports XML as data structure
 Short Code history: Short Code created in 1949. This programming language was compiled
into machine code by hand.
 SmallTalk history: SmallTalk was created in 1969 at Xerox PARC by a team led by Alan Kay,
Adele Goldberg, Ted Kaehler, and Scott Wallace. Fully object oriented programming language
that introduced a graphic environment with windows and a mouse.

'Hello World' out.

SNOBOL history: SNOBOL (StroNg Oriented symBOli Language) was created in 1962 by
D.J. Farber, R.E. Griswold, and F.P. Polensky at Bell Telephone Laboratories. Intended for
processing strings, the language was the first to use associative arrays, indexed by any type of
key. Had features for pattern-matching, concatenation, and alternation. Allowed running code
stored in strings. Data types: integer, real, array, table, pattern, and user defined types.

    SNOBOL 3 was released in 1965.

    SNOBOL 4 was released in 1967.

 OUTPUT = 'Hello World'

END

SQL history: SQL (Standard Query Language) was designed by Donald D. Chamberlin and
Raymond F. Boyce of IBM in 1974. SQl was designed for data base queries.

    Larry Ellison wrote the first version of Oracle database by himself in about six months. That is
genius. Data bases typically take large teams (sometimes hundreds of programmers) at least a
year.
 Hello World example

SELECT 'Hello World'

 Standard ML  history: Standard ML, based on ML, was created in 1984 by R. Milner of the
University of Edinburgh.
 UML  history: UML (Unified Modeling Language) was created by Grady Booch, Jim
Rumbaugh, and Ivar Jacobson in 1996 by combining the three modeling languages of each of the
authors
 UNIX shell script history: UNIX shell scripts (such as sh, csh, and bash) are used for
controlling a UNIX machine from the command line.

Shell Script (BASH)

echo Hello World

Visual basic Visual Basic .NET (VB.NET or VB .NET) is a version of Microsoft's Visual Basic that
was designed, as part of the company's .NET product group, to make Web services applications easier to
develop. According to Microsoft, VB .NET was reengineered, rather than released as VB 6.0 with added
features, to facilitate making fundamental changes to the language. VB.NET is the first fully object-
oriented programming (OOP) version of Visual Basic, and as such, supports OOP concepts such as
abstraction, inheritance, polymorphism, and aggregation

SAMPLE CODE: