Programming Languages

ENIAC (Electronic Numerical Integrator and Calculator)
Physical motion was eventually replaced by electrical signals when the US

Government
built the ENIAC (Electronic Numerical Integrator and Calculator) in 1942. It
followed
many of the same principles of Babbage's engine and hence, could only be
"programmed"
by presetting switches and rewiring the entire system for each new
"program" or
calculation. This process proved to be very tedious.
Von Neumann Architecture - 1945
In 1945, John Von Neumann was working at the Institute for Advanced Study.
He
developed two important concepts that directly affected the path of
computer
programming languages. The first was known as "shared-program
technique". This
technique stated that the actual computer hardware should be simple and
not need to be
hand-wired for each program. Instead, complex instructions should be used
to control the
simple hardware, allowing it to be reprogrammed much faster.
The second concept was also extremely important to the development of
programming
languages. Von Neumann called it "conditional control transfer". This idea
gave rise to
the notion of subroutines, or small blocks of code that could be jumped to in
any order,
instead of a single set of chronologically ordered steps for the computer to
take. The
second part of the idea stated that computer code should be able to branch
based on
logical statements such as IF (expression) THEN, and looped such as with a
FOR
statement. "Conditional control transfer" gave rise to the idea of "libraries,"
which are
blocks of code that can be reused over and over.
In March 1949, Popular Mechanics made the following prediction:
"Where a calculator on the ENIAC is equipped with 18 000 vacuum tubes and
weighs 30
tons, computers of the future may have only 1 000 vacuum tubes and
perhaps weigh 1
tons."
In 1949, a few years after Von Neumann's work, the language Short Code
appeared. It
was the first computer language for electronic devices and it required the
programmer to
change its statements into 0's and 1's by hand. Still, it was the first step
towards the
complex languages of today. In 1951, Grace Hopper wrote the first compiler,
A-0. A
compiler is a program that turns the language's statements into 0's and 1's
for the
computer to understand. This lead to faster programming, as the
programmer no longer
had to do the work by hand.
Introduction and Historical Background (Lecture 1-8) VU
22
Copyright Virtual University of Pakistan
A most important class of programming languages, known as the imperative

languages, is
based upon the von Neumann Architecture. This includes languages like
FORTAN,
COBOL, Pascal, Ada, C, and many more.
Other major influences on programming language design have been
mentioned as below:
Programming Methodologies
1950s and early 1960s:
Simple applications; worry about machine efficiency
Late 1960s:
People efficiency became important
readability, better control structures
Late 1970s:
Data abstraction
Middle 1980s:
Domain and data complexity - Object-oriented programming
Today
Web and networked environment; distributed computing
Language Categories
Imperative
variables, assignment, iteration
Functional (applicative)
set of functions
Logic (Declarative)
rule based
Order of execution in not defined
Object Oriented
close relatives of imperative
Application Domains
1. Scientific applications
simple data structures, large FP operations - FORTRAN
2. Business applications
reports, decimal arithmetic, character operations - COBOL
3. Artificial intelligence
Symbol processing, logic programming Lisp, Prolog
4. Embedded systems
Concurrent programming - Ada
5. Systems programming
execution efficiency, low-level features PL/1, BLISS, C
6. Scripting languages
list of commands batch files, ksh, Perl
7. Special purpose languages
Hundreds of languages
FORTAN
The First High Level Language - FORTRAN I John Backus 1957
FORTRAN stands FORmula TRANslating system. It was the first implemented
version
of FORTRAN as FORTRAN 0 (1954) was never implemented. It was the first
compiled
high-level language designed for the new IBM 704, which had index registers
and
floating point hardware. At that time computers were small and unreliable,
applications
were scientific, and no programming methodology or tools were available.
Machine
efficiency was most important and no need was felt for dynamic storage. So
the language
needed good array handling and counting loops. No string handling or

decimal arithmetic
was supported. Names could have up to six characters. It had support for
formatted I/O
and user-defined subprograms. There was no data typing statements and no
separate
compilation. The compiler was released in April 1957, after 18 man/years of
effort.
Unfortunately, programs larger than 400 lines rarely compiled correctly,
mainly due to
poor reliability of the 704 but code was very fast. Within one year, 50% of
the code
written for 704 was being developed in FORTRAN.
All statements of FORTRAN I were based on 704s instruction set. It included
3 way
branch and computed if in the form of If (EXPRESSION) L1, L2, L3. It also had
posttest
counting loop as shown below:
DO L1 I = N, M
Fortran II (1958) and IV (1960)
Fortran II came after one year in 1958. It added independent compilation and
had some
bug fixes.
Fortran IV was released in 1960 and became the most popular language of
its time. It had
support for explicit type declarations and logical IF statement. Subprograms
could also be
passed as parameters. ANSI standard of FORTRAN IV was release in 1966 and
remained
mostly unchanged for the next 10 years.
FORTRAN 77 and 90
FORTRAN 77, released in 1977, was the next major release of FORTRAN after
FORTRAN IV. It added support for structured Programming, character string
handling,
logical loop control statement, and IF-THEN-ELSE statement.
FORTRAN 90, released in 1990, added modules, dynamic arrays, pointers,
recursion
stack frames, case statement, and parameter type checking. However,
because of the
backward compatibility constraints, it could never gain the same popularity
as its
predecessors.
Functional Programming LISP McCarthy 1959
LISP stands for LISt Processing language. It was designed by John McCarthy
in 1959 as
part of AI research at MIT to deal with problems of linguistic, psychology, and
mathematics. They needed a language to process data in dynamically
growing lists (rather
than arrays) and handle symbolic computation (rather than numeric). LISP
has only two
data types: atoms and lists and syntax is based on lambda calculus. It
pioneered functional
26
programming where there is no need for assignment and control flow is

achieved via
recursion and conditional expressions. It is still the dominant language for AI.
COMMON
LISP and Scheme are contemporary dialects of LISP and ML, Miranda, and
Haskell are
related languages.
ALGOL
ALGOL 58 1958 Search for a Universal Language
ALGOL stands for ALGOrithmic Language. It was designed in 1958. At that
time
FORTRAN had (barely) arrived for IBM 70x and was owned by IBM. Many
other
languages were being developed, all for specific machines. There was no
portable
language as all were machine-dependent. Also, there was no universal
language for
communicating algorithms.
ALGOL was thus designed to be a language that was close to mathematical
notation,
good for describing algorithms, and was machine independent. That is, it was
an
algorithmic language for use on all kinds of computers.
Salient features of the language are:
Concept of type was formalized
Names could have any length
Arrays could have any number of subscripts
Lower bound of an array could be defined
Parameters were separated by mode (in & out)
Subscripts were placed in brackets
Compound statements were introduced (begin ... end)
Semicolon as a statement separator was used
Assignment operator was :=
if had an else-if clause
It was actually not meant to be implemented, but variations of it were (MAD,
JOVIAL)
implemented. Although IBM was initially enthusiastic but vested interest in
FORTRAN
resulted in taking back all support by mid-1959.
Algol 60 - 1960
ALGOL 60 was a modified version of ALGOL 58. It added new features to the
language.
These included block structure (local scope), two parameter passing methods
value and
name, subprogram recursion, and stack-dynamic arrays run time size
definition and
space allocation. It did not have built-in I/O facility.
It was quite successful as it was the standard way to publish algorithms for
over 20 years.
All subsequent imperative languages are based on it. It was the first
machine-independent
language and the first language whose syntax was formally defined in BNF. It
also
impacted the hardware design.
It was never widely used, especially in U.S because there was no i/o support
and the
character set made programs non-portable. Also, it was too flexible and
hence was hard to
understand and implement. On top of that, IBM never supported it on their
machines
27
because of their interest in FORTRAN. In addition, BNF was considered

strange and
complicated!
Algol 68 - 1968
ALGOL 68 was from the continued development of ALGOL 60, but it is not a
superset of
that language. Its design is based on the concept of orthogonality. Major
contributions of
this language include user-defined data structures, reference types, and
dynamic arrays
(called flex arrays).
From a practical point of view it had even less usage than ALGOL 60 but had
strong
influence on subsequent languages, especially Pascal, C, and Ada.
COBOL - 1960
COBOL was designed in 1960 to support business-oriented computation
which requires
fixed point arithmetic. It was designed to look like simple English to broaden
the base of
computer users. It was thus required to be easy to use, even if that means it
will be less
powerful. Another design consideration was that it must not be biased by
current
compiler.
It encountered problems because the design committee members were all
from computer
manufacturers and DoD branches and there were fights among
manufacturers.
It was the first language to add macro facility in a high-level language. It also
introduced
hierarchical data structures (records) and nested selection statements. The
language
supported long variable names (up to 30 characters) with hyphens, data
division, and
fixed-point arithmetic.
It was the first language required by DoD and would probably have failed
without support
from DoD. It is still a very widely used business applications language and is
very
popular in business and government, much less at universities.
Basic - 1964
BASIC was designed by Kemeny & Kurtz at Dartmouth College with the
following goals
in mind: Easy to learn and use for non-science students; Must be pleasant
and friendly;
Fast turnaround for homework; Free and private access; User time is more
important than
computer time.
Current popular dialects include QuickBASIC and Visual BASIC.
PL/1 1965 Everything for Everybody
From IBMs point of view there were two computing groups: scientific
computing and
business computing. The scientific computing was supported by IBM 1620
and 7090
computers and FORTRAN. Business computing was done on IBM 1401, 7080
computers
and COBOL programming language.
28
By 1963 scientific users began to need more elaborate i/o, like COBOL had
and business
users began to need fl. pt. and arrays (MIS). It looked like many shops would
begin to
need two kinds of computers, languages, and support staff. This proposition
was
obviously too costly and the obvious solution was to build a new computer to
do both
kinds of applications and design a new language to do both kinds of
applications. Hence
PL/1 came into being.
PL/I was the first language to introduce unit-level concurrency, exception
handling,
pointer data type, and array cross sections.
The language was not a huge success because many new features were
poorly designed
and it was too large and too complex.
Early Dynamic Languages -Characterized by dynamic typing and dynamic storage
allocation
APL (A Programming Language) 1962
It was designed as a hardware description language (at IBM by Ken Iverson).
It was
highly expressive (many operators, for both scalars and arrays of various
dimensions) but
programs are very difficult to read - commonly known as write-only
language.
SNOBOL (1964)
It was designed as a string manipulation language (at Bell Labs by Farber,
Griswold, and
Polensky). It had powerful operators for string pattern matching but suffered
from poot
readability and maintainability.
Simula 67 1967 The first Object-oriented langauge
It was designed in Norway by Nygaard and Dahl, primarily for system
simulation. It was
based on ALGOL 60 and SIMULA I. Its primary contributions include the
concept of a
class which was the basis for data abstraction. Classes are structures that
include both
local data and functionality.
Pascal 1971 Simplicity by Design
Pascal was designed by Niklaus Wirth, who quit the ALGOL 68 committee
because he
didn't like the direction of that work. It was designed for teaching structured
programming. It was small and simple with nothing really new. Because of its
simplicity
and size it was, for almost two decades, the most widely used language for
teaching
programming in colleges.
C 1972 High-level system programming language
C was designed for systems programming at Bell Labs by Dennis Richie. It
evolved
primarily from B, but was also influenced by ALGOL 68. It had powerful set of
operators, but poor type checking. It initially spread through UNIX but
became very
popular in the academic circles because of its easy portability. Many modern
programming languages including C++, Java, and C# are direct descendents
of C.
Prolog 1972 Logic Programming

It was developed at the University of Aix-Marseille, by Comerauer and
Roussel, with
some help from Kowalski at the University of Edinburgh. It is based on formal
logic. It is
a non-procedural declarative programming language with built-in
backtracking
mechanism. It has support for associative memory and pattern directed
procedure
invocation. After LISP, it is the second most widely used language in AI
community,
especially in Europe.
Ada 1983 Historys largest design effort
It involved a huge design effort, involving hundreds of people, much money,
and about
eight years. It introduced Packages - support for data abstraction, elaborate
exception
handling, generic program units, and concurrency through the tasking model.
It was the outcome of a competitive design effort. It included all that was
then known
about software engineering and language design. Because of its size and
complexity, first
compilers were very difficult and the first really usable compiler came nearly
five years
after the language design was completed
Smalltalk - 1972-1980 The Purest Object-Oriented Langauge
It was developed at Xerox PARC, initially by Alan Kay and then later by Adele
Goldberg. It is the first full implementation of an object-oriented language
(data
abstraction, inheritance, and dynamic type binding) and the purest objectoriented
language yet! It pioneered the graphical user interface everyone now uses.
C++ - 1985
It was developed at Bell Labs by Stroustrup. It evolved from C and SIMULA
67.
Facilities for object-oriented programming, taken partially from SIMULA 67,
were
added to C. It also has exception handling. It is a large and complex
language, in part
because it supports both procedural and OO programming. Rapidly grew in
popularity,
along with OOP and ANSI standard was approved in November, 1997.
Java - 1995
Java was developed at Sun in the early 1990s and is based on C++. It is
significantly
simplified as compared to C++ and supports only OOP. It eliminated multiple
inheritance, pointers, structs, enum types, operator overloading, and goto
statement and
added support for applets and a form of concurrency.
C# - 2002
It is part of the .NET framework by Microsoft. It is based upon C++ and Java
and support
component-based software development. It has taken some ideas from
Visual Basic. It
brought back pointers, structs, enum types, operator overloading, and goto
statement. It
has safer enum types, more useful struct types, and modified switch
statement.
===============================================================
BASIC(Acronym for Beginner's All-purpose Symbolic Instruction Code). Developed by John

Kemeney and Thomas Kurtz in the mid 1960s at Dartmouth College, BASIC is one of the
earliest and simplest high-level programming languages. During the 1970s, it was the principal
programming language taught to students, and continues to be a popular choice among
educators.Despite its simplicity, BASIC is used for a wide variety of business applications. There
is an ANSI standard for the BASIC language,but most versions of BASIC include many
proprietary extensions. Microsoft's popular Visual Basic, for example, adds many object-oriented
featuresto the standard BASIC.Recently, many variations of BASIC have appeared as
programming,or macro, languages within applications. For example, Microsoft Word and Excel
both come with a version of BASIC with which userscan write programs to customize and
automate these applications.
History
Basic is a very powerful language as a tool for the novice programmer. Basic allows for a wide
range of applications, and it has many versions. However, as long as the emphasis is on the
techniques of programming and problem solving, the specific syntax is easy to follow.
Significant Language Features
Basic is a multi-platform language because many basic compilers use the same types of routines.
Basic allows:Loops Input from the keyboard Menu Driven Applications System Commands These are words that make the system perform a specific task immediately. Structured
Programming Subroutines Built-In Functions User-Defined Functions Arrays, sorting, and
searches
Areas of Application
Basic has many strong points, such as:Easy to learn for beginners Adds powerful additional
features for the advanced user Is designed for interactive use rather than batch work Lends itself
to learning by hands-on practical use and is therefore suitable for both the professional and nonprofessional.
===================================================================
Fortran
The Fortran Automatic Coding System for the IBM 704 (15 October 1956), the
first Programmer's Reference Manual for Fortran
Paradigm(s) multi-paradigm: structured, imperative (procedural, objectoriented), generic
Designed by John Backus
Developer John Backus & IBM
Appeared in 1957
Stable release Fortran 2008 (ISO/IEC 1539-1:2010) / 2010
Typing discipline strong, static, manifest
Major implementations Absoft, Cray, GFortran, G95, IBM XL Fortran, Intel,
Hitachi, Lahey/Fujitsu, Numerical Algorithms Group, Open Watcom,
PathScale, PGI, Silverfrost, Oracle Solaris Studio, Visual Fortran, others
Influenced by Speedcoding
Influenced ALGOL 58, BASIC, C, PL/I, PACT I, MUMPS, Ratfor

Filename extension(s)
.f , .for , .f90 ,
.f95
Fortran (previously FORTRAN, derived from Formula Translating System) is a
general-purpose, imperative programming language that is especially suited
to numeric computation and scientific computing. Originally developed by
IBM [1] in the 1950s for scientific and engineering applications, Fortran came
to dominate this area of programming early on and has been in continuous
use for over half a century in computationally intensive areas such as
numerical weather prediction, finite element analysis, computational fluid
dynamics, computational physics and computational chemistry. It is one of
the most popular languages in the area of high-performance computing [2]
and is the language used for programs that benchmark and rank the world's
fastest supercomputers.
Fortran encompasses a lineage of versions, each of which evolved to add
extensions to the language while usually retaining compatibility with
previous versions. Successive versions have added support for structured
programming and processing of character-based data (FORTRAN 77), array
programming, modular programming and generic programming (Fortran 90),
high performance Fortran (Fortran 95), object-oriented programming (Fortran
2003) and concurrent programming (Fortran 2008)
History
One of the oldest programming languages, the FORTRAN was developed by a
team of programmers at IBM led by John Backus, and was first published in
1957. The name FORTRAN is an acronym for FORmula TRANslation, because
it was designed to allow easy translation of math formulas into code.
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 it's 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.
FORTRAN was so innovative not only because it was the first high-level
language, but also because of it's compiler, which is credited as giving rise to
the branch of computer science now known as compiler theory. Several years
after it's 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.
These problems lead the American Standards Association (now known as the
American National Standards Association) to release it's first Standard for a
Programming Languagein 1966. This first standardized version has come to
be known as FORTRAN '66 (aka.. FORTRAN IV).
Despite this standardization, a few years later, various new dialects began to
surface again, requiring the Standards Association review the language
again. This version is known as FORTRAN '77. This version was released in
1978 (it was called '77 because the Association began it's review in 1977),
with several new features. Some of the more notable properties were; new
error handling methods, and mechanisms for managing large-scale
programs. The latest version; Fortran '90 (released in 1990, using the new
capitalization scheme) added even more new features, such as support for:
recursion, pointers, and for programmer-defined data types. {Fortran 90's
future - Current research in complier theory involves equipping compilers to
generate object code, that is able to exploit the capabilities of massively
parallel computers. Thr Fortran 90 compilers are key targets of such
research}
Significant Language Features:Some of the more significant features of
the language are as listed below:Simple to learn - when FORTRAN was design
one of the objectives was to write a language that was easy to learn and
understand. Machine Independent - allows for easy transportation of a
program from one machine to another. More natural ways to express
mathematical functions - FORTRAN permits even severely complex
mathematical functions to be expressed similarly to regular algebraic
notation. Problem orientated language Remains close to and exploits the
available hardware Efficient execution - there is only an approximate 20%
decrease in efficiency as compared to assembly/machine code. Ability to
control storage allocation -programmers were able to easily control the
allocation of storage (although this is considered to be a dangerous practice
today, it was quite important some time ago due to limited memory. More
freedom in code layout - unlike assembly/machine language, code does not
need to be laid out in rigidly defined columns, (though it still must remain
within the parameters of the FORTRAN source code form).
Areas of Application
FORTRAN is useful for a wide variety of applications, some of the more
outstanding ones are as follows:
Number crunching - due to the more natural (like it's true algebraic form)
way of expressing complex mathematical functions and it's quick execution
time, FORTRAN is easy and efficient at processing mathematical equations.
Scientific, mathematical, statistical, and engineering type procedures -due to
it's rapid number-crunching ability FORTRAN is a good choice for these type
of applications.
Basically FORTRAN is most useful for applications that are "computationalbound" rather than "I/O bound".
COBOL
This article is about the compiled programming language. For other uses, see
COBOL (disambiguation).
This page has some issues
COBOL (, an acronym for common business-oriented language) is a compiled
computer programming language designed for business use. It is imperative,
procedural and, since 2002, object-oriented.
It was designed in 1959 by the Conference on Data Systems Languages
(CODASYL) and was largely based on previous programming language design
work by Grace Hopper, commonly referred to as "the (grand)mother of
COBOL". [2][3][4] It was created as part of a US Department of Defense
effort to create a portable programming language for data processing.
Intended as a temporary stopgap, the Department of Defense promptly
forced computer manufacturers to provide it, resulting in its widespread
adoption. [5] It was standardized in 1968 and has since been revised four
times. Expansions include support for structured and object-oriented
programming. The current standard is ISO/IEC 1989:2014. [6]
COBOL is primarily used in business, finance, and administrative systems for
companies and governments. In 1997, Gartner Group estimated that there
were a total of 200 billion lines of COBOL in existence which ran 80% of all
business programs. [7]
Background
Computer users and manufacturers were becoming concerned about the
rising cost of programming. A 1959 survey had found that in any data
processing installation, programming cost at least $800,000 and that
translating programs to run on new hardware would cost $600,000. In a time
where new programming languages were proliferating at an ever increasing
rate, the same survey suggested that if a common business-oriented
language were used, conversion would be far cheaper and faster. [8]
Grace Hopper, the inventor of FLOW-MATIC, apredecessor to COBOL.
In April 1959, representatives from academia, computer users and

manufacturers met at the University of Pennsylvania to organize a formal
meeting on common business languages. Representatives included Grace
Hopper, inventor of the English-like data processing language FLOW-MATIC,
Jean Sammet and Saul Gorn. [9][10]
COBOL 60
On May 28 and 29 of 1959 (exactly one year after the Zrich ALGOL 58
meeting), a meeting was held at the Pentagon to discuss creating a common
programming language for business. It was attended by 41 people and was
chaired by Phillips. FORTRAN, the only mainstream language at the time,
lacked the features needed to write such programs.
Representatives enthusiastically described a language which could work in a

wide variety of environments, from banking and insurance to utilities and
inventory control.
The steering committee met on June 4 and agreed to name the entire
activity as the Committee on Data Systems Languages, or CODASYL, and to
form an executive committee. [20]
Although context-sensitive keywords were rejected, the approach was later
used in PL/I and partially in COBOL from 2002. [38] Little consideration was
given to interactivity, interaction with operating systems (few existed at that
time) and functions (thought of as purely mathematical and of no use in data
processing). [39][40]
The specifications were presented to the Executive Committee on September
4. They fell short of expectations: Joseph Wegstein noted that "it contains
rough spots and requires some additions" and Bob Bemer later described
them as a "hodgepodge". The subcommittee was given until December to
improve it. [18]
At a mid-September meeting, the committee discussed the new language's
name. Suggestions included "BUSY" (Business System), "INFOSYL"
(Information System Language) and "COCOSYL" (Common Computer
Systems Language). [41] The name "COBOL" was suggested by Bob Bemer.
[42][43]
In October, the intermediate-range committee received copies of the FACT
language specification created by Roy Nutt. Its features impressed the
committee so much that they passed a resolution to base COBOL on it. [44]
This was a blow to the short-range committee, who had made good progress
on the specification. Despite being technically superior, FACT had not been
created with portability in mind or through manufacturer and user
consensus. It also lacked a demonstrable implementation, [18] allowing
supporters of a FLOW-MATIC-based COBOL to overturn the resolution. RCA
representative Howard Bromberg also decided to block FACT so that RCA's
work on a COBOL implementation would not go to waste. [45]
It soon became apparent that the committee was too large for any further
progress to be made quickly. A frustrated Howard Bromberg bought a $15
tombstone with "COBOL" engraved on it and sent it to Charles Phillips to
demonstrate his displeasure (the tombstone is currently at the Computer
History Museum). [46][47][48] A sub-committee was formed to analyze
existing languages and was made up of six individuals: [14][49]
William Selden and Gertrude Tierney of IBM Howard Bromberg and Howard
Discount of RCA Vernon Reeves and Jean E. Sammet of Sylvania Electric
Products
The sub-committee did most of the work creating the specification, leaving
the short-range committee to review and modify their work before producing
the finished specification. [14]
COBOL-61 to COBOL-65
Many logical flaws were found in COBOL 60, leading GE's Charles Katz to
warn that it could not be interpreted unambiguously. A reluctant short-term
committee enacted a total cleanup and, by March 1963, it was reported that
COBOL's syntax was as definable as ALGOL's, although semantic ambiguities
remained. [52]
Early COBOL compilers were primitive and slow. A 1962 US Navy evaluation
found compilation speeds of 311 statements per minute
COBOL-60 was replaced in 1961 by COBOL-61. This was then replaced by the
COBOL-61 Extended specifications in 1963 which introduced the sort and
report writer facilities.
COBOL-68
Efforts began to standardise COBOL to overcome incompatibilities between
versions. In late 1962, both ISO and the United States of America Standards
Institute (now ANSI) formed groups to create standards. ANSI produced USA
Standard COBOL X3.23 in August 1968 which became the cornerstone for
later versions. [58] This version was known as American National Standard
(ANS) COBOL and was adopted by ISO in 1972. [59]
COBOL-74
By 1970, COBOL had become the most widely used programming language
in the world. [60]
Independently of the ANSI committee, the CODASYL Programming Language
Committee was working on improving the language. They described new
versions in 1968, 1969, 1970 and 1973, including changes such as new interprogram communication, debugging and file merging facilities as well as
improved string-handling and library inclusion features
COBOL-85
In June 1978, work began on revising COBOL-74. The proposed standard
(commonly called COBOL-80) differed significantly from the previous one,
causing concerns about incompatibility and conversion costs. In January
1981, Joseph T. Brophy, Senior Vice-President of Travelers Insurance,
threatened to sue the standard committee because it was not upwards
compatible with COBOL-74. Mr. Brophy described previous conversions of
their 40 million line code base as "non-productive" and a "complete waste of
our programmer resources". [68] Later that year, the Data Processing
Management Association (DPMA) said it was "strongly opposed" to the new
standard, citing "prohibitive" conversion costs and enhancements that were
"forced on the user". [69][70]
In late 1985, ANSI published the revised standard. 60 features were changed
or deprecated and many [quantify] were added, such as: [74][75]
scope terminators ( END-IF , ENDPERFORM , END-READ ,etc.) nested subprograms
CONTINUE ,a no-operation statement
EVALUATE ,a switch statement

INITIALIZE ,astatementwhich canset groups of data to their default values
inline PERFORM loop bodiespreviously, loop bodies had to be specified in a
separate procedure reference modification, which allows access to substrings
I/O status codes
The standard was adopted by ISO the same year. [59] Two amendments
followed in 1989 and 1993, the first introducing intrinsic functions and the
other providing corrections. ISO adopted the amendments in 1991 and 1994,
respectively, [59] before subsequently taking primary ownership and
development of the standard.
COBOL 2002 and object-oriented COBOL
In the early 1990s it was decided to add object-orientation in the next full
revision of COBOL. Object-orientated features were taken from C++ and
Smalltalk. [76][77] The initial estimate was to have this revision completed
by 1997 and an ISO Committee Draft (CD) was available by 1997.
COBOL 2014
Between 2003 and 2009, three technical reports were produced describing
object finalization, XML processing and collection classes for COBOL. [83]
COBOL 2002 suffered from poor support: no compilers completely supported
the standard. Micro Focus found that it was due to a lack of user demand for
the new features and due to the abolition of the NIST test suite which had
been used to test compiler conformance. The standardization process was
also found to be slow and under-resourced. [84]
COBOL 2014 includes the following changes: [85]
Portable arithmetic results have been replaced by IEEE 754 data types Major
features have been made optional, such as object-orientation, the VALIDATE
facility, the report writer and the screen-handling facility. Method overloading
Dynamic capacity tables (a feature dropped from the draft of COBOL 2002)
[86]
Legacy
COBOL programs are used globally in governments and businesses, and are
running on diverse operating systems such as z/OS, VME, Unix and Windows.
In 1997, the Gartner Group reported that 80% of the world's business ran on
COBOL with over 200 billion lines of code and 5 billion lines more being
written annually. [87]
Near the end of the twentieth century, the year 2000 problem (Y2K) was the
focus of significant COBOL programming effort, sometimes by the same
programmers who had designed the systems decades before. The particular
level of effort required to fix COBOL code has been attributed [by whom?] to
the large amount of business-oriented COBOL, as business applications use
dates heavily, and to fixed-length data fields. After the clean-up effort put
into these programs for Y2K, a 2003 survey found that many remained in
use. [88] The authors said that the survey data suggest "a gradual decline in
the importance of Cobol in application development over the [following] 10
years unless ... integration with other languages and technologies can be
adopted". [89]
In 2006 and 2012, Computerworld surveys found that over 60% of
organizations used COBOL (more than C++ and Visual Basic .NET) and that
for half of those, COBOL was used for the majority of their internal software.
[90][91] 36% of managers said they planned to migrate from COBOL and
25% said they would like to if it was cheaper. Instead, some businesses have
migrated their systems from expensive mainframes to cheaper, more
modern systems, while maintaining their COBOL programs. [90]
Syntax
COBOL has an English-like syntax which is used to describe nearly everything
in a program. For example, a condition can be expressed as x IS GREATER
THAN
y or moreconciselyas x GREATER y or x > y . Morecomplexconditionscan be
"abbreviated" by removing repeated conditions and variables. For example, a
> b AND a > c OR a = d can be shortened to a > b AND c
OR = d .Asaconsequenceofthis English-like syntax, COBOL has over 300
keywords. [92] However, compiler extensions allow many implementations to
have far more: one implementation recognizes over 1,100 keywords. [93]
Some of the keywords are simple alternative or pluralized spellings of the
same word, which provides for more English-like statements and clauses;
e.g., the
IN and OF keywordscan beused interchangeably, as can IS and ARE ,and
VALUE and VALUES .

The syntactical elements of a COBOL program are "words", "literals", and
"punctuation". Word elements include reserved keywords, user-defined
identifiers, and labels, and must be separated from other words by spaces,
newlines, or punctuation elements. Identifiers (for data items and files, as
well as paragraph and section labels) are case-insensitive and may contain
dashes for readability, and can be up to 30 characters long. Literal elements
include numeric constants and quoted character (string) constants.
A COBOL program is split into four divisions: the identification division, the
environment division, the data division and the procedure division. The
identification division specifies the name and type of the source element and
is where classes and interfaces are specified. The environment division
specifies any program features that depend on the system running it, such
as files and character sets. The data division is used to declare variables and
parameters. The procedure division contains the program's statements. Each
division is sub-divided into sections which are made up of paragraphs.
Code format
COBOL can be written in two formats: fixed (the default) or free. In fixedformat, code must be aligned to fit in certain areas. Until COBOL 2002, these
were:
Name Column(s) Usage
Sequence number area
16 Originally used for card/line numbers, this area is ignored by the
compiler
Indicator area 7 The following characters are allowed here:
* a comment line
/ a comment line which will be printed on a new page of a source listing
- a continuation line where words or literals from the previous line are
continued
Environment division
The environment division contains the configuration section and the inputoutput section. The configuration section is used to specify variable features
such as currency signs, locales and character sets. The input-output section
contains file-related information.
Files
COBOL supports three file formats, or organizations: sequential, indexed and
relative. In sequential files, records are contiguous and must be traversed
sequentially, similarly to a linked list. Indexed files have one or more indexes
which allow records to be randomly accessed and which can be sorted on
them. Each record must have a unique key, but alternate record keys need
not be unique.
Data division
The data division is split into six sections which declare different items: the
file section, for file records; the working-storage section, for static variables;
the local-storage section, for automatic variables; the linkage section, for
parameters and the return value; the report section and the screen section,
for text-based user interfaces.
Aggregated data
Data items in COBOL are declared hierarchically through the use of levelnumbers which indicate if a data item is part of another. An item with a
higher level-number is subordinate to an item with a lower one. Data items
containing subordinate items which are not subordinate to another item are
called records. Items that have no subordinate data items are called
elementary items; those that do are called group items. [102]
01 some-record. 05 num PIC 9(10). 05 the-date. 10 the-year PIC 9(4). 10 themonth PIC 99. 10 the-day PIC 99.
In the above example, num and the-date are subordinate to the record somerecord , while the-year , the-month ,and the-day are part of the group item
the-date .
Level-numbers used to describe standard data items are between 01 and 49.
Subordinate items can be disambiguated with the IN (or OF )
keyword.Forexample, consider the example code above along with the
following example:
01 sale-date. 05 the-year PIC 9(4). 05 the-month PIC 99. 05 the-day PIC 99.
The names the-year , the-month , and
the-day areambiguousbythemselves, since more than one data item is
defined with those names. To specify a particular data item, for instance one
of the items contained within the sale-date group,the programmer would use
the-year IN saledate (or itssemanticequivalent the-year
OF sale-date ).(Thissyntaxissimilar to the "dot notation" supported by most
C-like and other object-oriented programming languages.)
Other data levels
A level-number of 66 is used to declare a re-grouping of previously defined
items, irrespective of how those items are structured. [103]
01 customer-record. 05 cust-key PIC X(10). 05 cust-name. 10 cust-first-name
PIC X(30). 10 cust-last-name PIC X(30). 05 cust-dob PIC 9(8). 05 cust-balance
PIC 9(7)V99.
66 cust-personal-details RENAMES cust-name THRU cust-dob. 66 cust-alldetails RENAMES cust-name THRU cust-balance.
A 77 level-number indicates the item is stand-alone, and in such situations is
equivalent to the level-number 01. For example, the following code declares
two 77-level data items, property-name and
sales-region ,whicharenon-group data items that are independent of (not
subordinate to) any other data items:
Data types
Standard COBOL provides the following data types: [105]
Data type Sample declaration Notes
Alphabetic PIC
A(30
PICTURE clause
A PICTURE (or PIC )clauseisa stringof characters, each of which represents a
portion of the data item. Some picture
Pascal (programming language)
Paradigm(s) imperative, structured

Designed by Niklaus Wirth
Appeared in 1970
Typing discipline static, strong, safe
Major implementations CDC 6000, ICL 1900, Pascal-P, PDP-11, PDP-10, IBM
System/370, HP Pascal, Free Pascal, GNU Pascal
Dialects Borland, Turbo Pascal, UCSD Pascal
Influenced by ALGOL W
Influenced Ada, Component Pascal, Java, [1][2][3] Modula, Modula-2, Modula3, Oberon, Oberon-2, Object Pascal, Oxygene, Seed7
Pascal is a formerly influential imperative and procedural programming
language, designed in 19681969 and published in 1970 by Niklaus Wirth as
a small and efficient language intended to encourage good programming
practices using structured programming and data structuring.
A derivative known as Object Pascal designed for object-oriented
programming was developed in 1985.
Pascal, named in honor of the French mathematician and philosopher Blaise
Pascal, was developed by Niklaus Wirth.
Before his work on Pascal, Wirth had developed Euler and ALGOL W and later
went on to develop the Pascal-like languages Modula-2 and Oberon.
Initially, Pascal was largely, but not exclusively, intended to teach students
structured programming. [4] A generation of students used Pascal as an
introductory language in undergraduate courses. Variants of Pascal have also
frequently been used for everything from research projects to PC games and
embedded systems. Newer Pascal compilers exist which are widely used.
Pascal was the primary high-level language used for development in the
Apple Lisa, and in the early years of the Macintosh. Parts of the original
Macintosh operating system were hand-translated into Motorola 68000
assembly language from the Pascal sources. [6] The popular typesetting
system TeX by Donald E. Knuth was written in WEB, the original literate
programming system, based on DEC PDP-10 Pascal, while applications like
Total Commander, Skype and Macromedia Captivate were written in Delphi
(Object Pascal)
Object Pascal (Embarcadero Delphi) is still used for developing Windows
applications but also has the ability to cross compile the same code to Mac
and iOS. Another cross-platform version called Free Pascal, with the Lazarus
IDE, is popular with Linux users since it also offers write once, compile
anywhere development. CodeTyphon is a variant of Lazarus with more
preinstalled packages and cross compilers.
Wirth's intention was to create an efficient language (regarding both
compilation speed and generated code) based on so-called structured
programming, a concept which had recently become popular. Pascal has its
roots in the ALGOL 60 language, but also introduced concepts and

mechanisms which (on top of ALGOL's scalars and arrays) enabled
programmers to define their own complex (structured) datatypes, and also
made it easier to build dynamic and recursive data structures such as lists,
trees and graphs. Important features included for this were records,
enumerations, subranges, dynamically allocated variables with associated
pointers, and sets. To make this possible and meaningful, Pascal has a strong
typing on all objects, which means that one type of data cannot be converted
or interpreted as another without explicit conversions. Similar mechanisms
are standard in many programming languages today. Other languages that
influenced Pascal's development were COBOL, Simula 67, and Wirth's own
ALGOL W.
Pascal, like many programming languages of today (but unlike most
languages in the C family), allows nested procedure definitions to any level
of depth, and also allows most kinds of definitions and declarations inside
subroutines (procedures and functions). This enables a very simple and
coherent syntax where a complete program is syntactically nearly identical
to a single procedure or function (except for the heading, which has one of
these three keywords)
Early Pascal compilers
The first Pascal compiler was designed in Zrich for the CDC 6000 series
mainframe computer family. Niklaus Wirth reports that a first attempt to
implement it in Fortran in 1969 was unsuccessful due to Fortran's
inadequacy to express complex data structures. The second attempt was
formulated in the Pascal language itself and was operational by mid-1970.
Many Pascal compilers since have been similarly self-hosting, that is, the
compiler is itself written in Pascal, and the compiler is usually capable of
recompiling itself when new features are added to the language, or when the
compiler is to be ported to a new environment. The GNU Pascal compiler is
one notable exception, being written in C.
The first successful port of the CDC Pascal compiler to another mainframe
was completed by Welsh and Quinn at the Queen's University of Belfast
(QUB) in 1972. The target was the ICL 1900 series. This compiler in turn was
the parent of the Pascal compiler for the ICS Multum minicomputer. The
Multum port was developed with a view to using Pascal as a systems
programming language by Findlay, Cupples, Cavouras and Davis, working
at the Department of Computing Science in Glasgow University. It is thought
that Multum Pascal, which was completed in the summer of 1973, may have
been the first 16-bit implementation.
The first Pascal compiler written in North America was constructed at the
University of Illinois under Donald B. Gillies for the PDP-11 and generated
native machine code.
The Pascal-P system
To propagate the language rapidly, a compiler "porting kit" was created in
Zurich that included a compiler that generated code for a "virtual" stack
machine, i.e., code that lends itself to reasonably efficient interpretation,
along with an interpreter for that code the Pascal-P system. The P-system
compilers were termed Pascal-P1, Pascal-P2, Pascal-P3, and Pascal-P4.

Pascal-P1 was the first version, and Pascal-P4 was the last to come from
Zurich.
The Pascal-P4 compiler/interpreter can still be run and compiled on systems
compatible with original Pascal. However, it only accepts a subset of the
Pascal language.
Pascal-P5, created outside of the Zurich group, accepts the full Pascal
language and includes ISO 7185 compatibility.
UCSD Pascal branched off Pascal-P2, where Kenneth Bowles utilized it to
create the interpretive UCSD p-System. In the early 1980s, UCSD Pascal was
ported to the Apple II and Apple III computers to provide a structured
alternative to the BASIC interpreters that came with the machines, and the
UCSD p-System was one of three operating systems available at the launch
of the original IBM PC. [7]
A compiler based on the Pascal-P4 compiler, which created native binaries,
was released for the IBM System/370 mainframe computer by the Australian
Atomic Energy Commission; it was called the "AAEC Pascal Compiler" after
the abbreviation of the name of the Commission.
In the early 1980s, Watcom Pascal was developed, also for the IBM System
370.
IP Pascal was an implementation of the Pascal programming language using
Micropolis DOS, but was moved rapidly to CP/M running on the Z80.
Object Pascal, Turbo Pascal
Apple Computer created its own Lisa Pascal for the Lisa Workshop in 1982
and ported this compiler to the Apple Macintosh and MPW in 1985. In 1985
Larry Tesler, in consultation with Niklaus Wirth, defined Object Pascal and
these extensions were incorporated in both the Lisa Pascal and Mac Pascal
compilers.
In the 1980s Anders Hejlsberg wrote the Blue Label Pascal compiler for the
Nascom-2. A reimplementation of this compiler for the IBM PC was marketed
under the names Compas Pascal and PolyPascal before it was acquired by
Borland. Renamed Turbo Pascal, it became hugely popular, thanks in part to
an aggressive pricing strategy and in part to having one of the first fullscreen Integrated development environments, and fast turnaround-time (just
seconds to compile, link, and run.)
Turbo Pascal, and other derivatives with units or module concepts are
modular languages. However, it does not provide a nested module concept
or qualified import and export of specific symbols.
Other variants
Super Pascal was a variant that added non-numeric labels, a return
statement and expressions as names of types.
Hello world
Pascal programs start with the program keyword with a list of external file
descriptors as parameters [14] (not required in Turbo Pascal etc.); then
follows the main block bracketed by the begin and end keywords. Semicolons
separate statements, and the full stop (i.e., a period) ends the whole
program (or unit). Letter case is ignored in Pascal source.
Here is an example of the source code in use for a very simple "Hello world"
program:
Program HelloWorld; Begin WriteLn('Hello world!') {no ";" is required after the
last statement of a block -adding one adds a "null statement" to the
program} End.
Data types
A type in Pascal, and in several other popular programming languages,
defines a variable in such a way that it defines a range of values which the
variable is capable of storing, and it also defines a set of operations that are
permissible to be performed on variables of that type. The predefined types
are:
Data type Type of values which the variable is capable of storing
integer integer (whole) numbers
real floating-point numbers
boolean the value True or False
char a single character from an ordered character set
string a group or "string" of characters
Subrange types
Subranges of any ordinal data type (any simple type except real) can also be
made:
var x : 1..10; y : 'a'..'z';
Set types
In contrast with other programming languages from its time, Pascal supports
a set type:
var Set1 : set of 1..10; Set2 : set of 'a'..'z';
A set is a fundamental concept for modern mathematics, and they may be
used in many algorithms. Such a feature is useful and may be faster than an
equivalent construct in a language that does not support sets. For example,
for many Pascal compilers:
if i in [5..10] then ...
executes faster than:
if (i > 4) and (i < 11) then ...
Sets of non-contiguous values can be particularly useful, in terms of both

performance and readability:
if i in [0..3, 7, 9, 12..15] then ...
For these examples, which involve sets over small domains, the improved
performance is usually achieved by the compiler representing set variables
as bit vectors. The set operators can then be implemented efficiently as
bitwise machine code operations.
Type declarations
Types can be defined from other types using type declarations:
type x = integer; y = x; ...
Further, complex types can be constructed from simple types:
type a = array[1..10] of integer; b = record x : integer; y : char end; c = file
of a;
File type
As shown in the example above, Pascal files are sequences of components.
Every file has a buffer variable which is denoted by f^. The procedures get
(for reading) and put (for writing) move the buffer variable to the next
element. Read is introduced such that read(f, x) is the same as x := f^;
get(f);. Write is introduced such that write(f, x) is the same as f^ := x; put(f);
The type text is predefined as file of char. While the buffer variable could be
used for inspecting the next character to be used (check for a digit before
reading an integer), this leads to serious problems with interactive programs
in early implementations, but was solved later with the "lazy I/O" concept.
Pointer types
Pascal supports the use of pointers:
type pNode = ^Node; Node = record a : integer; b : char; c : pNode {extra
semicolon not strictly required} end; var NodePtr : pNode; IntPtr : ^integer;
Control structures
Pascal is a structured programming language, meaning that the flow of
control is structured into standard statements, usually without 'goto'
commands.
The Java Programming Language

What is Java technology and why do I need it?
Java is a programming language and computing platform first released by Sun Microsystems in 1995.
There are lots of applications and websites that will not work unless you have Java installed, and more
are created every day. Java is fast, secure, and reliable. From laptops to datacenters, game consoles to
scientific supercomputers, cell phones to the Internet, Java is everywhere!
Java is a general-purpose computer programming language that is concurrent, class-based, objectoriented,[10] and specifically designed to have as few implementation dependencies as possible. It is
intended to let application developers "write once, run anywhere" (WORA),[11] meaning that code that
runs on one platform does not need to be recompiled to run on another.[12] Java applications are
typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless
of computer architecture. Java is, as of 2015, one of the most popular programming languages in
use, particularly for client-server web applications, with a reported 9 million developers. [13][14] Java was
originally developed by James Gosling at Sun Microsystems (which has since merged into Oracle
Corporation) and released in 1995 as a core component of Sun Microsystems' Java platform. The
language derives much of its syntax from C and C++, but it has fewer low-level facilities than either
of them.
The original and reference implementation Java compilers, virtual machines, and class libraries were
originally released by Sun under proprietary licences. As of May 2007, in compliance with the
specifications of the Java Community Process, Sun relicensed most of its Java technologies under
the GNU General Public License. Others have also developed alternative implementations of these
Sun technologies, such as the GNU Compiler for Java (bytecode compiler), GNU
Classpath (standard libraries), and IcedTea-Web (browser plugin for applets).
History
James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June
1991.[15] Java was originally designed for interactive television, but it was too advanced for the digital
cable television industry at the time.[16] The language was initially called Oak after anoak tree that
stood outside Gosling's office. Later the project went by the name Green and was finally
renamed Java, from Java coffee,[17] said to be consumed in large quantities by the language's
creators.[citation needed] Gosling designed Java with a C/C++-style syntax that system and application
programmers would find familiar.[18]
Sun Microsystems released the first public implementation as Java 1.0 in 1995.[1] It promised "Write
Once, Run Anywhere" (WORA), providing no-cost run-times on popular platforms. Fairly secure and
featuring configurable security, it allowed network- and file-access restrictions. Major web
browsers soon incorporated the ability to run Java applets within web pages, and Java quickly
became popular. The Java 1.0 compiler was re-written in Java by Arthur van Hoff to comply strictly
with the Java 1.0 language specification.[19] With the advent of Java 2 (released initially as J2SE 1.2
in December 1998 1999), new versions had multiple configurations built for different types of
platforms. J2EE included technologies and APIs for enterprise applications typically run in server
environments, while J2ME featured APIs optimized for mobile applications. The desktop version was
renamed J2SE. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java
ME, and Java SE, respectively.
In 1997, Sun Microsystems approached the ISO/IEC JTC 1 standards body and later the Ecma
International to formalize Java, but it soon withdrew from the process.[20] Java remains a de
facto standard, controlled through the Java Community Process.[21] At one time, Sun made most of its
Java implementations available without charge, despite their proprietary software status. Sun
generated revenue from Java through the selling of licenses for specialized products such as the
Java Enterprise System.
On November 13, 2006, Sun released much of Java as free and open-source software, (FOSS),
under the terms of the GNU General Public License (GPL). On May 8, 2007, Sun finished the
process, making all of Java's core code available under free software/open-source distribution terms,
aside from a small portion of code to which Sun did not hold the copyright. [22]
Sun's vice-president Rich Green said that Sun's ideal role with regard to Java was as an
"evangelist".[23] Following Oracle Corporation's acquisition of Sun Microsystems in 20092010,
Oracle has described itself as the "steward of Java technology with a relentless commitment to
fostering a community of participation and transparency".[24] This did not prevent Oracle from filing a
lawsuit against Google shortly after that for using Java inside the Android SDK (see Google section
below). Java software runs on everything fromlaptops to data centers, game consoles to
scientific supercomputers. There are 930 million Java Runtime Environment downloads each year
and over 3 billion mobile phones run Java.[25] On April 2, 2010, James Gosling resigned from Oracle.
[26]
Principles
There were five primary goals in the creation of the Java language:[12]
1. It must be "simple, object-oriented and familiar"
2. It must be "robust and secure"
3. It must be "architecture-neutral and portable"
4. It must execute with "high performance"
5. It must be "interpreted, threaded, and dynamic"
Versions
Major release versions of Java, along with their release dates:
JDK 1.0 (January 21, 1996)
JDK 1.1 (February 19, 1997)
J2SE 1.2 (December 8, 1998)
J2SE 1.3 (May 8, 2000)
J2SE 1.4 (February 6, 2002)
J2SE 5.0 (September 30, 2004)
Java SE 6 (December 11, 2006)
Java SE 7 (July 28, 2011)
Java SE 8 (March 18, 2014)
Practices[edit]
Java platform[edit]
Main articles: Java (software platform) and Java virtual machine
One design goal of Java is portability, which means that programs written for the Java platform must
run similarly on any combination of hardware and operating system with adequate runtime support.
This is achieved by compiling the Java language code to an intermediate representation called Java
bytecode, instead of directly to architecture-specific machine code. Java bytecode instructions are
analogous to machine code, but they are intended to be executed by a virtual machine (VM) written
specifically for the host hardware. End users commonly use a Java Runtime Environment (JRE)
installed on their own machine for standalone Java applications, or in a web browser for
Java applets.
Standardized libraries provide a generic way to access host-specific features such as
graphics, threading, and networking.
A major benefit of using bytecode is porting. However, the overhead of interpretation means that
interpreted programs almost always run more slowly than programs compiled to native executables
would. Just-in-Time (JIT) compilers were introduced from an early stage that compile bytecodes to
machine code during runtime.
Implementations[edit]
See also: Free Java implementations
Oracle Corporation is the current owner of the official implementation of the Java SE platform,
following their acquisition of Sun Microsystems on January 27, 2010. This implementation is based
on the original implementation of Java by Sun. The Oracle implementation is available for Microsoft
Windows, Mac OS X, Linux and Solaris. Because Java lacks any formal standardization recognized
by Ecma International, ISO/IEC, ANSI, or other third-party standards organization, the Oracle
implementation is the de facto standard.
The Oracle implementation is packaged into two different distributions: The Java Runtime
Environment (JRE) which contains the parts of the Java SE platform required to run Java programs
and is intended for end users, and the Java Development Kit (JDK), which is intended for software
developers and includes development tools such as the Java compiler, Javadoc, Jar, and
a debugger.
OpenJDK is another notable Java SE implementation that is licensed under the GNU GPL. The
implementation started when Sun began releasing the Java source code under the GPL. As of Java
SE 7, OpenJDK is the official Java reference implementation.
The goal of Java is to make all implementations of Java compatible. Historically, Sun's trademark
license for usage of the Java brand insists that all implementations be "compatible". This resulted in
a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not
support RMI or JNI and had added platform-specific features of their own. Sun sued in 1997, and in
2001 won a settlement of US$20 million, as well as a court order enforcing the terms of the license
from Sun.[27] As a result, Microsoft no longer ships Windows with Java.
Platform-independent Java is essential to Java EE, and an even more rigorous validation is required
to certify an implementation. This environment enables portable server-side applications.
Automatic memory management[edit]

Java uses an automatic garbage collector to manage memory in the object lifecycle. The
programmer determines when objects are created, and the Java runtime is responsible for
recovering the memory once objects are no longer in use
Examples[edit]
Hello World[edit]
The traditional "Hello, world!" program can be written in Java as:[36]
class HelloWorldApp {
public static void main(String[] args) {
System.out.println("Hello World!"); // Prints the string to the
console.
}
}
To compare this to other programming languages see the list of "Hello World!" program examples.
Source files must be named after the public class they contain, appending the suffix .java , for
example, HelloWorldApp.java . It must first be compiled into bytecode, using aJava compiler,
producing a file named HelloWorldApp.class . Only then can it be executed, or 'launched'. The
Java source file may only contain one public class, but it can contain multiple classes with other than
public access and any number of public inner classes. When the source file contains multiple
classes, make one class 'public' and name the source file with that public class name.
A class that is not declared public may be stored in any .java file. The compiler will generate a
class file for each class defined in the source file. The name of the class file is the name of the class,
with .class appended. For class file generation, anonymous classes are treated as if their name were
the concatenation of the name of their enclosing class, a $, and an integer.
The keyword public denotes that a method can be called from code in other classes, or that a
class may be used by classes outside the class hierarchy. The class hierarchy is related to the name
of the directory in which the .java file is located.
The keyword static in front of a method indicates a static method, which is associated only with
the class and not with any specific instance of that class. Only static methods can be invoked without
a reference to an object. Static methods cannot access any class members that are not also static.
The keyword void indicates that the main method does not return any value to the caller. If a Java
program is to exit with an error code, it must call System.exit() explicitly.
The method name " main " is not a keyword in the Java language. It is simply the name of the
method the Java launcher calls to pass control to the program. Java classes that run in managed
environments such as applets and Enterprise JavaBeans do not use or need a main() method. A
Java program may contain multiple classes that have main methods, which means that the VM
needs to be explicitly told which class to launch from.
The main method must accept an array of String objects. By convention, it is referenced
as args although any other legal identifier name can be used. Since Java 5, the main method can
also use variable arguments, in the form of public static void main(String... args) ,
allowing the main method to be invoked with an arbitrary number of String arguments. The effect
of this alternate declaration is semantically identical (the args parameter is still an array
of String objects), but it allows an alternative syntax for creating and passing the array.
The Java launcher launches Java by loading a given class (specified on the command line or as an
attribute in a JAR) and starting its public static void main(String[]) method. Stand-alone
programs must declare this method explicitly. The String[] args parameter is
an array of String objects containing any arguments passed to the class. The parameters
to main are often passed by means of a command line.
Printing is part of a Java standard library: The System class defines a public static field called out .
The out object is an instance of the PrintStream class and provides many methods for printing
data to standard out, including println(String) which also appends a new line to the passed
string.
The string "Hello World!" is automatically converted to a String object by the compiler.
A more comprehensive example[edit]

This section does not cite any references or sources. Please help improve this
section by adding citations to reliable sources. Unsourced material may be challenged
and removed. (May 2013)
This article contains instructions, advice, or how-to content. The purpose of
Wikipedia is to present facts, not to train. Please help improve this article either by
rewriting the how-to content or by moving it to Wikiversity, Wikibooks or Wikivoyage(May
2013)
// OddEven.java
import javax.swing.JOptionPane;
public class OddEven {
private int userInput; // a whole number("int" means integer)
/**
* This is the constructor method. It gets called when an object of
the OddEven type
* is being created.
*/
public OddEven() {
/*
* In most Java programs constructors can initialize objects with
default values, or create
* other objects that this object might use to perform its
functions. In some Java programs, the
* constructor may simply be an empty function if nothing needs to
be initialized prior to the
* functioning of the object. In this program's case, an empty
constructor would suffice.
* A constructor must exist; however, if the user doesn't put one
in then the compiler
* will create an empty one.
*/
}
/**
* This is the main method. It gets called when this class is run
through a Java interpreter.
* @param args command line arguments (unused)
*/
public static void main(final String[] args) {
/*
* This line of code creates a new instance of this class called
"number" (also known as an
* Object) and initializes it by calling the constructor. The next
line of code calls
* the "showDialog()" method, which brings up a prompt to ask you
for a number.
*/
OddEven number = new OddEven();
number.showDialog();
}
public void showDialog() {
/*
* "try" makes sure nothing goes wrong. If something does,
* the interpreter skips to "catch" to see what it should do.
*/
try {
/*
* The code below brings up a JOptionPane, which is a dialog
box
* The String returned by the "showInputDialog()" method is
converted into
* an integer, making the program treat it as a number instead
of a word.
* After that, this method calls a second method, calculate()
that will
* display either "Even" or "Odd."
*/
userInput =
Integer.parseInt(JOptionPane.showInputDialog("Please enter a number."));
calculate();
} catch (final NumberFormatException e) {
/*
* Getting in the catch block means that there was a problem
with the format of
* the number. Probably some letters were typed in instead of
a number.
*/
System.err.println("ERROR: Invalid input. Please type in a
numerical value.");
}
}
/**
* When this gets called, it sends a message to the interpreter.
* The interpreter usually shows it on the command prompt (For Windows
users)
* or the terminal (For *nix users).(Assuming it's open)

*/
private void calculate() {
if ((userInput % 2) == 0) {
JOptionPane.showMessageDialog(null, "Even");
} else {
JOptionPane.showMessageDialog(null, "Odd");
}
}
}
The import statement imports the JOptionPane class from the javax.swing package.
The OddEven class declares a single private field of type int named userInput .
Every instance of the OddEven class has its own copy of the userInput field. The private
declaration means that no other class can access (read or write) the userInput field.
OddEven() is a public constructor. Constructors have the same name as the enclosing
class they are declared in, and unlike a method, have no return type. A constructor is used to
initialize an object that is a newly created instance of the class.
The calculate() method is declared without the static keyword. This means that the
method is invoked using a specific instance of the OddEven class. (The referenceused to invoke
the method is passed as an undeclared parameter of type OddEven named this .) The method
tests the expression userInput % 2 == 0 using the if keyword to see if the remainder of
dividing the userInput field belonging to the instance of the class by two is zero. If this
expression is true, then it prints Even; if this expression is false it prints Odd.
(The calculate method can be equivalently accessed as this.calculate and
the userInput field can be equivalently accessed as this.userInput , which both explicitly
use the undeclared this parameter.)
OddEven number = new OddEven(); declares a local object reference variable in
the main method named number . This variable can hold a reference to an object of
type OddEven . The declaration initializes number by first creating an instance of
the OddEven class, using the new keyword and the OddEven() constructor, and then
assigning this instance to the variable.
The statement number.showDialog(); calls the calculate method. The instance

of OddEven object referenced by the number local variable is used to invoke the method and
passed as the undeclared this parameter to the calculate method.
userInput = Integer.parseInt(JOptionPane.showInputDialog("Please Enter

A Number")); is a statement that converts the type of String to the primitive data type int by
using a utility function in the primitive wrapper class Integer.
Special classes[edit]
This article contains instructions, advice, or how-to content. The purpose of
Wikipedia is to present facts, not to train. Please help improve this article either by
rewriting the how-to content or by moving it
to Wikiversity, Wikibooks or Wikivoyage(January 2012)
Applet[edit]
Main article: Java applet
Java applets are programs that are embedded in other applications, typically in a Web page
displayed in a web browser.
// Hello.java
import javax.swing.JApplet;
import java.awt.Graphics;
public class Hello extends JApplet {
public void paintComponent(final Graphics g) {
g.drawString("Hello, world!", 65, 95);
}
}
The import statements direct the Java compiler to include
the javax.swing.JApplet and java.awt.Graphics classes in the compilation. The import
statement allows these classes to be referenced in the source code using the simple class
name (i.e. JApplet ) instead of the fully qualified class name (FQCN, i.e. javax.swing.JApplet ).
The Hello class extends (subclasses) the JApplet (Java Applet) class; the JApplet class
provides the framework for the host application to display and control thelifecycle of the applet.
The JApplet class is a JComponent (Java Graphical Component) which provides the applet with
the capability to display a graphical user interface (GUI) and respond to user events.
The Hello class overrides the paintComponent(Graphics) method (additionally indicated with
the annotation, supported as of JDK 1.5, Override ) inherited from the Container superclass to
provide the code to display the applet. The paintComponent() method is passed
a Graphics object that contains the graphic context used to display the applet.
The paintComponent() method calls the graphic context drawString(String, int,
int) method to display the "Hello, world!" string at a pixeloffset of ( 65, 95 ) from the upper-left
corner in the applet's display.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">

<html>
<head>
<title>Hello World Applet</title>
</head>
<body>
<applet code="Hello.class" width="200" height="200">
</applet>
</body>
</html>
An applet is placed in an HTML document using the <applet> HTML element. The applet tag
has three attributes set: code="Hello" specifies the name of the JApplet class
and width="200" height="200" sets the pixel width and height of the applet. Applets may also
be embedded in HTML using either the object or embed element,[37]although support for these
elements by web browsers is inconsistent.[38] However, the applet tag is deprecated, so
the object tag is preferred where supported.
The host application, typically a Web browser, instantiates the Hello applet and creates
an AppletContext for the applet. Once the applet has initialized itself, it is added to the AWT
display hierarchy. The paintComponent() method is called by the AWT event dispatching
thread whenever the display needs the applet to draw itself.
Servlet[edit]
Main article: Java Servlet
Java Servlet technology provides Web developers with a simple, consistent mechanism for
extending the functionality of a Web server and for accessing existing business systems. Servlets
are server-side Java EE components that generate responses (typically HTML pages) to requests
(typically HTTP requests) from clients. A servlet can almost be thought of as an applet that runs on
the server sidewithout a face.
// Hello.java
import java.io.*;
import javax.servlet.*;
public class Hello extends GenericServlet {
public void service(final ServletRequest request, final
ServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
final PrintWriter pw = response.getWriter();
try {
pw.println("Hello, world!");
} finally {
pw.close();
}
}
}
The import statements direct the Java compiler to include all the public classes
and interfaces from the java.io and javax.servlet packages in the compilation. Packages
make Java well suited for large scale applications.
The Hello class extends the GenericServlet class; the GenericServlet class provides the
interface for the server to forward requests to the servlet and control the servlet's lifecycle.
The Hello class overrides the service(ServletRequest, ServletResponse) method defined
by the Servlet interface to provide the code for the service request handler.
The service() method is passed: a ServletRequest object that contains the request from the
client and a ServletResponse object used to create the response returned to the client.
The service() method declares that
it throws the exceptions ServletException and IOException if a problem prevents it from
responding to the request.
The setContentType(String) method in the response object is called to set the MIME content
type of the returned data to "text/html". The getWriter() method in the response returns
a PrintWriter object that is used to write the data that is sent to the client.
The println(String) method is called to write the "Hello, world!" string to the response and
then the close() method is called to close the print writer, which causes the data that has been
written to the stream to be returned to the client.
JavaServer Pages[edit]
Main article: JavaServer Pages
JavaServer Pages (JSP) are server-side Java EE components that generate responses,
typically HTML pages, to HTTP requests from clients. JSPs embed Java code in an HTML page by
using the special delimiters <% and %> . A JSP is compiled to a Java servlet, a Java application in its
own right, the first time it is accessed. After that, the generated servlet creates the response.
Swing application[edit]
Main article: Swing (Java)
Swing is a graphical user interface library for the Java SE platform. It is possible to specify a different
look and feel through the pluggable look and feel system of Swing. Clones
ofWindows, GTK+ and Motif are supplied by Sun. Apple also provides an Aqua look and feel for Mac
OS X. Where prior implementations of these looks and feels may have been considered lacking,
Swing in Java SE 6 addresses this problem by using more native GUI widget drawing routines of the
underlying platforms.
This example Swing application creates a single window with "Hello, world!" inside:
// Hello.java (Java SE 5)
import javax.swing.*;
public class Hello extends JFrame {
public Hello() {
super("hello");
super.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
super.add(new JLabel("Hello, world!"));
super.pack();
super.setVisible(true);
}
public static void main(final String[] args) {
new Hello();
}
}
The first import includes all the public classes and interfaces from the javax.swing package.
The Hello class extends the JFrame class; the JFrame class implements a window with a title
bar and a close control.
The Hello() constructor initializes the frame by first calling the superclass constructor, passing the
parameter "hello" , which is used as the window's title. It then calls
the setDefaultCloseOperation(int) method inherited from JFrame to set the default operation
when the close control on the title bar is selected to WindowConstants.EXIT_ON_CLOSE this
causes the JFrame to be disposed of when the frame is closed (as opposed to merely hidden),
which allows the Java virtual machine to exit and the program to terminate. Next, a JLabel is
created for the string "Hello, world!" and the add(Component) method inherited from
the Container superclass is called to add the label to the frame. The pack() method inherited
from the Window superclass is called to size the window and lay out its contents.
The main() method is called by the Java virtual machine when the program starts. It instantiates a
new Hello frame and causes it to be displayed by calling the setVisible(boolean) method
inherited from the Component superclass with the boolean parameter true . Once the frame is
displayed, exiting the main method does not cause the program to terminate because the
AWT event dispatching thread remains active until all of the Swing top-level windows have been
disposed.
Generics[edit]
Main article: Generics in Java
In 2004, generics were added to the Java language, as part of J2SE 5.0. Prior to the introduction of
generics, each variable declaration had to be of a specific type. For container classes, for example,
this is a problem because there is no easy way to create a container that accepts only specific types
of objects. Either the container operates on all subtypes of a class or interface, usually Object , or a
different container class has to be created for each contained class. Generics allow compile-time
type checking without having to create many container classes, each containing almost identical
code. In addition to enabling more efficient code, certain runtime exceptions are converted to
compile-time errors, a characteristic known as type safety.
Criticism[edit]
Main article: Criticism of Java
Criticisms directed at Java include the implementation of generics,[39] speed,[40] the handling of
unsigned numbers,[41] the implementation of floating-point arithmetic,[42] and a history of security
vulnerabilities in the primary Java VM implementation HotSpot.[43]
Documentation[edit]
Main article: Javadoc
Javadoc is a comprehensive documentation system, created by Sun Microsystems, used by

many Java developers. It provides developers with an organized system for documenting
their code.
Graph theory
From Wikipedia, the free encyclopedia
This article is about sets of vertices connected by edges. For graphs of mathematical functions,
see Graph of a function. For other uses, see Graph (disambiguation).
A drawing of a graph
In mathematics and computer science, graph theory is the study of graphs, which are mathematical
structures used to model pairwise relations between objects. A "graph" in this context is made up of
"vertices" or "nodes" and lines called edges that connect them. A graph may be undirected, meaning
that there is no distinction between the two vertices associated with each edge, or its edges may
be directed from one vertex to another; see graph (mathematics) for more detailed definitions and for
other variations in the types of graph that are commonly considered. Graphs are one of the prime
objects of study in discrete mathematics.
Refer to the glossary of graph theory for basic definitions in graph theory.
Definitions[edit]
Definitions in graph theory vary. The following are some of the more basic ways of defining graphs
and related mathematical structures.
Graph[edit]
In the most common sense of the term,[1] a graph is an ordered pair G = (V, E) comprising
a set V of vertices or nodes together with a set E of edges or lines, which are 2-element subsets
of V (i.e., an edge is related with two vertices, and the relation is represented as an unordered pair of
the vertices with respect to the particular edge). To avoid ambiguity, this type of graph may be
described precisely as undirected and simple.
Other senses of graph stem from different conceptions of the edge set. In one more generalized
notion,[2] E is a set together with a relation of incidence that associates with each edge two vertices.
In another generalized notion, E is a multiset of unordered pairs of (not necessarily distinct) vertices.
Many authors call this type of object a multigraph or pseudograph.
All of these variants and others are described more fully below.
The vertices belonging to an edge are called the ends, endpoints, or end vertices of the edge. A
vertex may exist in a graph and not belong to an edge.
V and E are usually taken to be finite, and many of the well-known results are not true (or are rather
different) for infinite graphs because many of the arguments fail in theinfinite case. The order of a
graph is
(the number of vertices). A graph's size is
, the number of edges. The degree of a
vertex is the number of edges that connect to it, where an edge that connects to the vertex at both
ends (a loop) is counted twice.
For an edge {u, v}, graph theorists usually use the somewhat shorter notation uv.
Applications[edit]
The network graph formed by Wikipedia editors (edges) contributing to different Wikipedia language versions (nodes)
during one month in summer 2013.[3]
Graphs can be used to model many types of relations and processes in physical, biological, [4] social
and information systems. Many practical problems can be represented by graphs.
In computer science, graphs are used to represent networks of communication, data organization,
computational devices, the flow of computation, etc. For instance, the link structure of a website can
be represented by a directed graph, in which the vertices represent web pages and directed edges
represent links from one page to another. A similar approach can be taken to problems in travel,
biology, computer chip design, and many other fields. The development of algorithms to handle
graphs is therefore of major interest in computer science. The transformation of graphs is often
formalized and represented by graph rewrite systems
Graph theory is also used to study molecules in chemistry and physics. In condensed matter
physics, the three-dimensional structure of complicated simulated atomic structures can be studied
quantitatively by gathering statistics on graph-theoretic properties related to the topology of the
atoms..
Graph-theoretic data structures[edit]

Main article: Graph (abstract data type)
There are different ways to store graphs in a computer system. The data structure used depends
on both the graph structure and the algorithm used for manipulating the graph. Theoretically one
can distinguish between list and matrix structures but in concrete applications the best structure
is often a combination of both. List structures are often preferred for sparse graphs as they have
smaller memory requirements. Matrix structures on the other hand provide faster access for
some applications but can consume huge amounts of memory.
List structures include the incidence list, an array of pairs of vertices, and the adjacency list,
which separately lists the neighbors of each vertex: Much like the incidence list, each vertex has
a list of which vertices it is adjacent to.
Matrix structures include the incidence matrix, a matrix of 0's and 1's whose rows represent
vertices and whose columns represent edges, and the adjacency matrix, in which both the rows
and columns are indexed by vertices
Tree (graph theory)
Trees
A labeled tree with 6 vertices and 5 edges

Vertices
Edges
v1
Chromatic number
2 if v > 1
In mathematics, and more specifically in graph theory, a tree is an undirected graph in which any
two vertices are connected byexactly one path. In other words, any connected graph without simple
cycles is a tree. A forest is a disjoint union of trees.
The various kinds of data structures referred to as trees in computer science have underlying
graphs that are trees in graph theory, although such data structures are generally rooted trees, thus
in fact being directed graphs, and may also have additional ordering of branches.
Rooted trees in their directed graph form may be called directed rooted tree.[1] Other terms for this
include[2] arborescence,[3]out-arborescence,[4] out-tree,[3][5] and even branching.[3]
The term "tree" was coined in 1857 by the British mathematician Arthur Cayley.[6]

Programming Languages

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Programming Languages

Caricato da

Copyright:

Formati disponibili

ENIAC (Electronic Numerical Integrator and Calculator)

Physical motion was eventually replaced by electrical signals when the US

A most important class of programming languages, known as the imperative

needed good array handling and counting loops. No string handling or

programming where there is no need for assignment and control flow is

because of their interest in FORTRAN. In addition, BNF was considered

Copyright Virtual University of Pakistan

Prolog 1972 Logic Programming

BASIC(Acronym for Beginner's All-purpose Symbolic Instruction Code). Developed by John

Influenced ALGOL 58, BASIC, C, PL/I, PACT I, MUMPS, Ratfor

special tweaking by programmers trying to make it better suit their personal

In April 1959, representatives from academia, computer users and

Representatives enthusiastically described a language which could work in a

EVALUATE ,a switch statement

IN and OF keywordscan beused interchangeably, as can IS and ARE ,and

VALUE and VALUES .

Paradigm(s) imperative, structured

roots in the ALGOL 60 language, but also introduced concepts and

compilers were termed Pascal-P1, Pascal-P2, Pascal-P3, and Pascal-P4.

Sets of non-contiguous values can be particularly useful, in terms of both

The Java Programming Language

JDK 1.0 (January 21, 1996)

JDK 1.1 (February 19, 1997)

J2SE 1.2 (December 8, 1998)

J2SE 1.3 (May 8, 2000)

J2SE 1.4 (February 6, 2002)

J2SE 5.0 (September 30, 2004)

Java SE 6 (December 11, 2006)

Java SE 7 (July 28, 2011)

Java SE 8 (March 18, 2014)

Automatic memory management[edit]

A more comprehensive example[edit]

* or the terminal (For *nix users).(Assuming it's open)

OddEven number = new OddEven(); declares a local object reference variable in

The statement number.showDialog(); calls the calculate method. The instance

userInput = Integer.parseInt(JOptionPane.showInputDialog("Please Enter

using a utility function in the primitive wrapper class Integer.

corner in the applet's display.

Main article: Javadoc

Javadoc is a comprehensive documentation system, created by Sun Microsystems, used by

(the number of vertices). A graph's size is

, the number of edges. The degree of a

Graph-theoretic data structures[edit]

Tree (graph theory)

A labeled tree with 6 vertices and 5 edges

Potrebbero piacerti anche