Originally known as Alpha Systems Programming Language, named for the development project that produced the 3000-series, SPL was designed to take advantage of the Alpha's stack-based processor design. It is patterned on ESPOL, a similar ALGOL-derived language used by the Burroughs B5000mainframe systems, which also influenced a number of 1960s languages like PL360 and JOVIAL.
Through the mid-1970s, the success of the HP systems produced a number of SPL offshoots. Examples include ZSPL for the Zilog Z80 processor, and Micro-SPL for the Xerox Alto. The later inspired Action! for the Atari 8-bit family, which was fairly successful. The later more closely followed Pascal syntax, losing some of SPL's idiosyncrasies.
SPL was widely used during the lifetime of the original integrated circuit-based versions HP 3000 platform. In the 1980s, the HP 3000 and MPE were reimplemented in an emulator running on the PA-RISC-based HP 9000 platforms. HP promoted Pascal as the favored system language on PA-RISC and did not provide an SPL compiler. This caused code maintenance concerns, and 3rd party SPL compilers were introduced to fill this need.
History
Hewlett-Packard introduced their first minicomputers, the HP 2100 series, in 1967. The machines had originally been designed by an external team working for Union Carbide
and intended mainly for industrial embedded control uses, not the wider
data processing market. HP saw this as a natural fit with their
existing instrumentation business and initially pitched it to those
users. In spite of this, HP found that the machine's price/performance ratio was making them increasingly successful in the business market.
During this period, the concept of time sharing was becoming popular, especially as core memory
costs fell and systems began to ship with more memory. In 1968, HP
introduced a bundled system using two 2100-series machine running HP Time-Shared BASIC, which provided a complete operating system as well as the BASIC programming language. These two-machine systems, collectively known as HP 2000s, were an immediate success. HP BASIC was highly influential for many years, and its syntax can be seen in a number microcomputer BASICs, including Palo Alto TinyBASIC, North Star BASIC, Atari BASIC, and others.
Designers at HP began to wonder "If we can produce a time-sharing
system this good using a junky computer like the 2116, think what we
could accomplish if we designed our own computer."
To this end, in 1968 the company began putting together a larger team
to design a new mid-sized architecture. New team members included those
who had worked on Burroughs and IBMmainframe systems, and the resulting concepts bore a strong resemblance to the highly successful Burroughs B5000 system. The B5000 used a stack machine processor that made multiprogramming simpler to implement, and this same architecture was also selected for the new HP concept.
Two implementations were considered, a 32-bit mainframe-scale
machine known as Omega, and a 16-bit design known as Alpha. Almost all
effort was on the Omega, but in June 1970, Omega was canceled. This led
to an extensive redesign of Alpha to differentiate it from the 2100's,
and it eventually emerged with plans for an even more aggressive
operating system design. Omega had intended to run in batch mode
and use a smaller computer, the "front end", to process interactions
with the user. This was the same operating concept as the 2000 series.
However, yet-another-2000 would not be enough for Alpha, and the
decision was made to have a single operating for batch, interactive and
even real time operation.
To make this work, it needed an advanced computer bus design with extensive direct memory access (DMA) and required an advanced operating system
(OS) to provide quick responses to user actions. The B5000 was also
unique, for its time, in that its operating system and core utilities
were all programmed in a high-level language, ESPOL.
ESPOL was a derivative of the ALGOL language tuned to work on the
B5000's, a concept that was highly influential in the 1960s and led to
new languages like JOVIAL, PL/360 and BCPL.
The HP team decided they would also use an ALGOL-derived language for
their operating systems work. HP's similar language was initially known
as the Alpha Systems Programming Language.
Alpha took several years to develop before emerging in 1972 as
the HP 3000. The machine was on the market for only a few months before
it was clear it simply wasn't working right, and HP was forced to recall
all 3000's already sold. It was reintroduced in late 1973 with most of
its problems having been fixed. A major upgrade to the entire system,
the CX machine, and MPE-C to run on it, reformed its image and the 3000
went on to be another major success during the second half of the 1970s.
This success made SPL almost as widespread as the 2000 series'
BASIC, and like that language, SPL resulted in a number of versions for
other platforms. Notable among them was Micro-SPL, a version written for
the Xerox Alto workstation. This machine had originally used BCPL as its primary language, but dissatisfaction with its performance led Henry Baker to design a non-recursive language that he implemented with Clinton Parker in 1979. Clinton would then further modify Micro-SPL to produce Action! for the Atari 8-bit family in 1983.
HP reimplemented the HP 3000 system on the PA-RISC chipset,
running a new version of the operating system known as MPE/iX. MPE/iX
had two modes, in "native mode" it ran applications that had been
recompiled for the PA-RISC using newer Pascal compilers, while under
"compatible mode" it could run all existing software via emulation. HP
did not supply a native mode compiler for MPE/iX so it was not an easy
process to move existing software to the new platform. To fill the need,
Allegro Consultants wrote an SPL-compatible language named "SPLash!"
that could compile to original HP 3000 code to run within the emulator,
or to native mode. This offered a porting pathway for existing SPL
software.
Language
Basic syntax
SPL
generally follows ALGOL 60 syntax conventions, and will be familiar to
anyone with experience in ALGOL or its descendants, like Pascal and Modula-2.
Like those languages, program statements can span multiple physical
lines and end with a semicolon. Comments are denoted with the COMMENT keyword, or by surrounding the comment text in << and >>.
Statements are grouped into blocks using BEGIN and END, although,
as in Pascal, the END of a program must be followed by a period. The
program as a whole is surrounded by BEGIN and END., similar to Pascal,
but lacking a PROGRAM keyword or similar statement at the top.
The reason for this is that SPL allows any block of code to be used as a
program on its own, or compiled into another program to act as a
library. The creation of code as a program or subprogram was not part of
the language itself, handled instead by placing the $CONTROL SUBPROGRAMcompiler directive at the top of the file.
The language used the INTRINSIC keyword to allow external code to be called directly by giving it a local name. For instance, a machine language library exposing a function to run the console bell could be imported to an SPL program as INTRINSIC BELL and then the bell could be operated by using the keyword BELL as if it was a native command.
In contrast to Pascal, where PROCEDURE and FUNCTION were separate concepts, SPL uses a more C-like approach where any PROCEDURE
can be prefixed with a type to turn it into a function. In keeping with
the syntax of other ALGOL-like languages, the types of the parameters
were listed after the name, not part of it. For instance:
INTEGER PROCEDURE FACT(N); VALUE N; INTEGER N;
Declares a function FACT that takes a value N that is an integer. The VALUE indicates that this variable is also the return value for the procedure.
Although frowned upon, ALGOL and Pascal allowed code to be
labeled using a leading name ending with a colon, which could then be
used for the target of loops and GO TO statements. One minor difference is that SPL required the label names to be declared in the variable section using the LABEL keyword.
SPL added to this concept with the ENTRY
statement which allowed these labels to be further defined as "entry
points" that could be accessed from the command line. Labels named in
the entry statement(s) were exposed to the operating system and could be
called from the RUN command. For instance, one could write a program
containing string functions to convert to uppercase or lowercase, and
then provide ENTRY points for these two. This could be called from the
command line as RUN $STRINGS,TOUPPER.
Data types
Where SPL differs most noticeably from ALGOL is that its data types are very machine specific, based on the 3000's 16-bit big endian word format.
The INTEGER type is a 16-bit signed type, with 15 bits of value and the least significant bit as the sign. DOUBLE is a 32-bit integer, not a floating-point type. REAL is a 32-bit floating-point value with 22 bits for the mantissa and 9 for the exponent, while LONG is a 64-bit floating-point value with 54 bits of mantissa and 9 bits exponent.
BYTE is used for character processing, consisting of a 16-bit machine word holding two 8-bit characters. LOGICAL is a boolean type that stores a single bit in the most significant bit. There is no equivalent of a PACKED modifier as found in Pascal, so LOGICAL is somewhat wasteful of memory.
Like C, data is weakly typed,
memory locations and variable storage are intermixed concepts, and one
can access values directly through their locations. For instance, the
code:
INTEGER A,B,C
LOGICAL D=A+2
defines three 16-bit integer variables, A, B and C, and then a LOGICAL, also a 16-bit value. The =, like Pascal, means "is equivalent to", not "gets the value of", which uses :=
in Algol-like languages. So the second line states "declare a variable D
that is in the same memory location as A+2", which in this case is also
the location of the variable C. This allows the same value to be read
as an integer via C or a logical through D.
This syntax may seem odd to modern readers where memory is generally a black box,
but it has a number of important uses in systems programming where
particular memory locations hold values from the underlying hardware. In
particular, it allows one to define a variable that points to the front
of a table of values, and then declare additional variables that point
to individual values within the table. If the table location changes,
only a single value has to change, the initial address, and all of the
individual variables will automatically follow in their proper relative
offsets.
Pointers were declared by adding the POINTER modifier to any variable declaration, and the memory location of a variable dereferenced with the @. Thus INTEGER POINTER P:=@A declares a pointer who's value contains the memory location of the variable A, not the value of A. @ can be used on either side of the assignment; P:=A puts the value of A into P, likely resulting in a dangling pointer, P:=@A makes P point to A, while @P:=A puts the value of A into the location currently pointed to by A.
In a similar fashion, SPL includes C-like array support in which
the index variable is a number-of-words offset from the memory location
set for the initial variable. Unlike C, SPL only provided
one-dimensional arrays, and used parentheses as opposed to brackets. Variables could also be declared GLOBAL, in which case no local memory was set aside for them and the storage was assumed to be declared in another library. This mirrors the extern keyword in C.
Literals can be specified with various suffixes, and those without a suffix are assumed to be INTEGER. For instance, 1234 would be interpreted as an INTEGER, while 1234D was a DOUBLE. E denoted a REAL and L a LONG. String constants were delimited by double-quotes, and double-quotes within a line were escaped with a second double-quote.
Variable declarations could use constants to define an initial value, as in INTEGER A:=10. Note the use of the assign-to rather than is-a. Additionally, SPL had a EQUATE
keyword that allowed a string of text to be defined as a variable, and
then replaced any instances of that variable in the code with the
literal string during compiles. This is similar to the const keyword in C.
Memory segmentation
As was common in the era, the HP 3000 used a byte-oriented segmented memory
model in which an address was a single 16-bit word, allowing code to
access up to 65,536 bytes (or as they termed it, "half-words"). To allow
larger amounts of memory to be accessed, a virtual memory
system was used. When memory was accessed, the 16-bit address was
prefixed with one of two 8-bit segment values, one for the program code
(PB) and another for variable data. The result was a 24-bit address.
Thus, while each program had access to a total of 128 kB at any one
time, it could swap the segments to access a full 16 MB memory space.
SPL included a variety of support systems to allow programs to be
easily segmented and then make that segmentation relatively invisible
in the code. The primary mechanism was to use the $CONTROL SEGMENT=asegmentnamecompiler directive which defined which segment the following code should be placed in. The default was MAINLINESEG, but the programmer could add any number of additional named segments to organize the code into blocks.
Other features
SPL included a "bit-extraction" feature that allowed simplified bit fiddling. Any bit, or string of bits, in a word could be accessed using the .(x:y) syntax, where x and y were the start and end bit positions from 0 to 15. Thus A.(8:15) returned the upper byte of the word storing A.
This format could be used to split and merge bits as needed.
Additionally, additional operations were provided for shifts and
rotates, and could be applied to any variable with the &, for instance A:=A & LSR(3).
Example
This simple program, from the 1984 version of the reference manual, shows most of the features of the SPL language.
The program as a whole is delimited between the BEGIN and END..
It begins with the definition of a series of global variables, A, B and
C, defines a single procedure and then calls it twenty times. Note that
the procedure does not have a BEGIN and END of its own because it
contains only one line of actual code, X:=X*(Y+Z); the INTEGER X,Y,Z
is not considered part of the code itself, it is indicating the type of
the three parameters being passed in on the line above and is
considered part of that line.
BEGIN
INTEGER A:=0, B, C:=1;
PROCEDURE N(X,Y,Z);
INTEGER X,Y,X;
X:=X*(Y+Z);
FOR B:=1 UNTIL 20 DO
N(A,B,C);
END.
Genetics appear to be playing a stronger role in heart disease
For years, we’ve been told to avoid high-cholesterol foods for heart health, but those days may be coming to an end.
A top nutrition advisory committee says people no longer have to be concerned about eating foods that are high in cholesterol. The committee’s report, which was released today, will help shape the next version of the U.S. Dietary Guidelines, set to be released later this year.
High levels of “bad” cholesterol
in the blood, which have been linked to heart disease, are still a
health concern. What’s changed is that many researchers and physicians
now believe that eating cholesterol-rich foods such as eggs may not
affect the cholesterol that is in your blood.
However, people with certain health problems, such as diabetes,
should continue to avoid cholesterol-rich foods, the report says.
It’s complicated
Cholesterol is a waxy substance that ultimately ends up in the walls of arteries. It causes the plaques that lead to heart attacks and strokes. The current U.S. Dietary Guidelines call for a daily cholesterol limit of 300 milligrams.
Researchers are beginning to understand in greater depth that the
relationship between cholesterol and the body is extremely complicated.
The body regulates how much cholesterol is in your blood.
There’s different kinds
of cholesterol. Low-density lipoprotein or LDL (bad) cholesterol
contributes to plaque buildup along with triglycerides, another lipid.
High-density lipoprotein or HDL (good) cholesterol discourages plaque
buildup.
The way people process cholesterol differs. Some people appear to be more vulnerable to cholesterol-rich diets.
Research is beginning to show that your genetic makeup – not diet –
is the driving force behind cholesterol levels, says cardiologist Steven Nissen, MD.
The body creates cholesterol in amounts much larger than what you can
eat, Dr. Nissen says. So avoiding foods that are high in cholesterol
won’t affect your blood cholesterol levels very much.
“About 85 percent of the cholesterol in the circulation is
manufactured by the body in the liver,” he says. “It isn’t coming
directly from the cholesterol that you eat.”
What you should worry about
The greater danger for everyone is in foods that are high in trans fats, Dr. Nissen says.
“Those often appear on food labels as hydrogenated oils or partially
hydrogenated vegetable oil,” Dr. Nissen says. “Those types of fats do
tend to raise cholesterol and do tend to increase the risk of heart
disease.”
The new U.S. Dietary Guidelines are expected to be announced later this year.
Thousands of different programming languages have been created,
and more are being created every year. Many programming languages are
written in an imperative form (i.e., as a sequence of operations to perform) while other languages use the declarative form (i.e. the desired result is specified, not how to achieve it).
The description of a programming language is usually split into the two components of 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) while other languages (such as Perl) have a dominant implementation that is treated as a reference.
Some languages have both, with the basic language defined by a standard
and extensions taken from the dominant implementation being common.
Definitions
A programming language is a notation for writing programs, which are specifications of a computation or algorithm. Some 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 language used to write computer programs, which involves 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.[8] 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 a 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-92 and Charity are examples of languages that are not Turing complete, yet often called programming languages.
Markup languages like XML, HTML, or troff, which define structured data, are not usually 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 language entirely using XML syntax. 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.
Similarly, 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.
History
Early developments
Very early computers, such as Colossus, were programmed without the help of a stored program, by modifying their circuitry or setting banks of physical controls.
Slightly later, programs could be written in machine language,
where the programmer writes each instruction in a numeric form the
hardware can execute directly. For example, the instruction to add the
value in two memory location might consist of 3 numbers: an "opcode"
that selects the "add" operation, and two memory locations. The
programs, in decimal or binary form, were read in from punched cards, paper tape, magnetic tape or toggled in on switches on the front panel of the computer. Machine languages were later termed first-generation programming languages (1GL).
John Mauchly's Short Code, proposed in 1949, was one of the first high-level languages ever developed for an electronic computer. Unlike machine code,
Short Code statements represented mathematical expressions in
understandable form. However, the program had to be translated into machine code every time it ran, making the process much slower than running the equivalent machine code.
At the University of Manchester, Alick Glennie developed Autocode in the early 1950s. As a programming language, it used a compiler to automatically convert the language into machine code. The first code and compiler was developed in 1952 for the Mark 1 computer at the University of Manchester and is considered to be the first compiled high-level programming language.
The second autocode was developed for the Mark 1 by R. A. Brooker in 1954 and was called the "Mark 1 Autocode". Brooker also developed an autocode for the Ferranti Mercury in the 1950s in conjunction with the University of Manchester. The version for the EDSAC 2 was devised by D. F. Hartley of University of Cambridge Mathematical Laboratory
in 1961. Known as EDSAC 2 Autocode, it was a straight development from
Mercury Autocode adapted for local circumstances and was noted for its
object code optimisation and source-language diagnostics which were
advanced for the time. A contemporary but separate thread of
development, Atlas Autocode was developed for the University of Manchester Atlas 1 machine.
Another early programming language was devised by Grace Hopper in the US, called FLOW-MATIC. It was developed for the UNIVAC I at Remington Rand
during the period from 1955 until 1959. Hopper found that business data
processing customers were uncomfortable with mathematical notation, and
in early 1955, she and her team wrote a specification for an English programming language and implemented a prototype. The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959. FLOW-MATIC was a major influence in the design of COBOL, since only it and its direct descendant AIMACO were in actual use at the time.
Refinement
The increased use of high-level languages introduced a requirement for low-level programming languages or system programming languages.
These languages, to varying degrees, provide facilities between
assembly languages and high-level languages. They can be used to perform
tasks which require direct access to hardware facilities but still
provide higher-level control structures and error-checking.
The period from the 1960s to the late 1970s brought the development of the major language paradigms now in use:
ALGOL refined both structured procedural programming and the discipline of language specification; the "Revised Report on the Algorithmic Language ALGOL 60" became a model for how later language specifications were written.
In the 1960s, Simula was the first language designed to support object-oriented programming; in the mid-1970s, Smalltalk followed with the first "purely" object-oriented language.
C was developed between 1969 and 1973 as a system programming language for the Unix operating system and remains popular.
Each of these languages spawned descendants, and most modern programming languages count at least one of them in their ancestry.
The 1960s and 1970s also saw considerable debate over the merits of structured programming, and whether programming languages should be designed to support it. Edsger Dijkstra, in a famous 1968 letter published in the Communications of the ACM, argued that GOTO statements should be eliminated from all "higher level" programming languages.
Consolidation and growth
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.
The 1980s were years of relative consolidation. C++ combined object-oriented and systems programming. The United States government standardized Ada, a systems programming language derived from Pascal and intended for use by defense contractors. In Japan and elsewhere, vast sums were spent investigating so-called "fifth-generation" languages that incorporated logic programming constructs. The functional languages community moved to standardize ML
and Lisp. Rather than inventing new paradigms, all of these movements
elaborated upon the ideas invented in the previous decades.
One important trend in language design for programming
large-scale systems during the 1980s was an increased focus on the use
of modules or large-scale organizational units of code. Modula-2, Ada, and ML all developed notable module systems in the 1980s, which were often wedded to generic programming constructs.
The rapid growth of the Internet in the mid-1990s created opportunities for new languages. Perl, originally a Unix scripting tool first released in 1987, became common in dynamic websites. Java
came to be used for server-side programming, and bytecode virtual
machines became popular again in commercial settings with their promise
of "Write once, run anywhere" (UCSD Pascal
had been popular for a time in the early 1980s). These developments
were not fundamentally novel, rather they were refinements of many
existing languages and paradigms (although their syntax was often based
on the C family of programming languages).
Programming language evolution continues, in both industry and
research. Current directions include security and reliability
verification, new kinds of modularity (mixins, delegates, aspects), and database integration such as Microsoft's LINQ.
Fourth-generation programming languages
(4GL) are computer programming languages which aim to provide a higher
level of abstraction of the internal computer hardware details than
3GLs. Fifth-generation programming languages (5GL) are programming languages based on solving problems using constraints given to the program, rather than using an algorithm written by a programmer.
Elements
All programming languages have some primitive
building blocks for the description of data and the processes or
transformations applied to them (like the addition of two numbers or the
selection of an item from a collection). These primitives are defined
by syntactic and semantic rules which describe their structure and
meaning respectively.
Syntax highlighting is often used to aid programmers in recognizing elements of source code. The language above is Python.
A programming language's surface form is known as its syntax.
Most programming languages are purely textual; they use sequences of
text including words, numbers, and punctuation, much like written
natural languages. On the other hand, there are some programming
languages which are more graphical in nature, using visual relationships between symbols to specify a program.
The syntax of a language describes the possible combinations of
symbols that form a syntactically correct program. The meaning given to a
combination of symbols is handled by semantics (either formal or hard-coded in a reference implementation). Since most languages are textual, this article discusses textual syntax.
expression ::= atom | list
atom ::= number | symbol
number ::= [+-]?['0'-'9']+
symbol ::= ['A'-'Z''a'-'z'].*
list ::= '(' expression* ')'
This grammar specifies the following:
an expression is either an atom or a list;
an atom is either a number or a symbol;
a number is an unbroken sequence of one or more decimal digits, optionally preceded by a plus or minus sign;
a symbol is a letter followed by zero or more of any characters (excluding whitespace); and
a list is a matched pair of parentheses, with zero or more expressions inside it.
The following are examples of well-formed token sequences in this grammar: 12345, () and (a b c232 (1)).
Not all syntactically correct programs are semantically correct.
Many syntactically correct programs are nonetheless ill-formed, per the
language's rules; and may (depending on the language specification and
the soundness of the implementation) result in an error on translation
or execution. In some cases, such programs may exhibit undefined behavior.
Even when a program is well-defined within a language, it may still
have a meaning that is not intended by the person who wrote it.
Using natural language as an example, it may not be possible to assign a meaning to a grammatically correct sentence or the sentence may be false:
"John is a married bachelor." is grammatically well-formed but expresses a meaning that cannot be true.
The following C language fragment is syntactically correct, but performs operations that are not semantically defined (the operation *p >> 4 has no meaning for a value having a complex type and p->im is not defined because the value of p is the null pointer):
complex*p=NULL;complexabs_p=sqrt(*p>>4+p->im);
If the type declaration
on the first line were omitted, the program would trigger an error on
undefined variable "p" during compilation. However, the program would
still be syntactically correct since type declarations provide only
semantic information.
The grammar needed to specify a programming language can be classified by its position in the Chomsky hierarchy. The syntax of most programming languages can be specified using a Type-2 grammar, i.e., they are context-free grammars.
Some languages, including Perl and Lisp, contain constructs that allow
execution during the parsing phase. Languages that have constructs that
allow the programmer to alter the behavior of the parser make syntax
analysis an undecidable problem, and generally blur the distinction between parsing and execution. In contrast to Lisp's macro system and Perl's BEGIN blocks, which may contain general computations, C macros are merely string replacements and do not require code execution.
Semantics
The term semantics refers to the meaning of languages, as opposed to their form (syntax).
Static semantics
The
static semantics defines restrictions on the structure of valid texts
that are hard or impossible to express in standard syntactic formalisms.
For compiled languages, static semantics essentially include those
semantic rules that can be checked at compile time. Examples include
checking that every identifier is declared before it is used (in languages that require such declarations) or that the labels on the arms of a case statement are distinct.
Many important restrictions of this type, like checking that
identifiers are used in the appropriate context (e.g. not adding an
integer to a function name), or that subroutine calls have the appropriate number and type of arguments, can be enforced by defining them as rules in a logic called a type system. Other forms of static analyses like data flow analysis may also be part of static semantics. Newer programming languages like Java and C# have definite assignment analysis, a form of data flow analysis, as part of their static semantics.
Dynamic semantics
Once data has been specified, the machine must be instructed to
perform operations on the data. For example, the semantics may define
the strategy by which expressions are evaluated to values, or the manner in which control structures conditionally execute statements. The dynamic semantics (also known as execution semantics)
of a language defines how and when the various constructs of a language
should produce a program behavior. There are many ways of defining
execution semantics. Natural language is often used to specify the
execution semantics of languages commonly used in practice. A
significant amount of academic research went into formal semantics of programming languages,
which allow execution semantics to be specified in a formal manner.
Results from this field of research have seen limited application to
programming language design and implementation outside academia.
Type system
A type system defines how a programming language classifies values and expressions into types,
how it can manipulate those types and how they interact. The goal of a
type system is to verify and usually enforce a certain level of
correctness in programs written in that language by detecting certain
incorrect operations. Any decidable
type system involves a trade-off: while it rejects many incorrect
programs, it can also prohibit some correct, albeit unusual programs. In
order to bypass this downside, a number of languages have type loopholes, usually unchecked casts
that may be used by the programmer to explicitly allow a normally
disallowed operation between different types. In most typed languages,
the type system is used only to type check programs, but a number of languages, usually functional ones, infer types, relieving the programmer from the need to write type annotations. The formal design and study of type systems is known as type theory.
Typed versus untyped languages
A language is typed if the specification of every operation defines types of data to which the operation is applicable. For example, the data represented by "this text between the quotes" is a string,
and in many programming languages dividing a number by a string has no
meaning and will not be executed. The invalid operation may be detected
when the program is compiled ("static" type checking) and will be
rejected by the compiler with a compilation error message, or it may be
detected while the program is running ("dynamic" type checking),
resulting in a run-time exception.
Many languages allow a function called an exception handler to handle
this exception and, for example, always return "-1" as the result.
A special case of typed languages are the single-typed languages. These are often scripting or markup languages, such as REXX or SGML, and have only one data type–—most commonly character strings which are used for both symbolic and numeric data.
In contrast, an untyped language, such as most assembly languages, allows any operation to be performed on any data, generally sequences of bits of various lengths. High-level untyped languages include BCPL, Tcl, and some varieties of Forth.
In practice, while few languages are considered typed from the type theory (verifying or rejecting all operations), most modern languages offer a degree of typing.
Many production languages provide means to bypass or subvert the type
system, trading type-safety for finer control over the program's
execution.
Static versus dynamic typing
In static typing,
all expressions have their types determined prior to when the program
is executed, typically at compile-time. For example, 1 and (2+2) are
integer expressions; they cannot be passed to a function that expects a
string, or stored in a variable that is defined to hold dates.
Statically typed languages can be either manifestly typed or type-inferred. In the first case, the programmer must explicitly write types at certain textual positions (for example, at variable declarations). In the second case, the compiler infers the types of expressions and declarations based on context. Most mainstream statically typed languages, such as C++, C# and Java, are manifestly typed. Complete type inference has traditionally been associated with less mainstream languages, such as Haskell and ML. However, many manifestly typed languages support partial type inference; for example, C++, Java and C# all infer types in certain limited cases.
Additionally, some programming languages allow for some types to be
automatically converted to other types; for example, an int can be used
where the program expects a float.
Dynamic typing, also called latent typing, determines the type-safety of operations at run time; in other words, types are associated with run-time values rather than textual expressions.
As with type-inferred languages, dynamically typed languages do not
require the programmer to write explicit type annotations on
expressions. Among other things, this may permit a single variable to
refer to values of different types at different points in the program
execution. However, type errors cannot be automatically detected until a piece of code is actually executed, potentially making debugging more difficult. Lisp, Smalltalk, Perl, Python, JavaScript, and Ruby are all examples of dynamically typed languages.
Weak and strong typing
Weak typing allows a value of one type to be treated as another, for example treating a string as a number. This can occasionally be useful, but it can also allow some kinds of program faults to go undetected at compile time and even at run time.
Strong typing prevents these program faults. An attempt to perform an operation on the wrong type of value raises an error. Strongly typed languages are often termed type-safe or safe.
An alternative definition for "weakly typed" refers to languages, such as Perl and JavaScript, which permit a large number of implicit type conversions. In JavaScript, for example, the expression 2 * x implicitly converts x to a number, and this conversion succeeds even if x is null, undefined, an Array, or a string of letters. Such implicit conversions are often useful, but they can mask programming errors.
Strong and static are now generally considered orthogonal concepts, but usage in the literature differs. Some use the term strongly typed to mean strongly, statically typed, or, even more confusingly, to mean simply statically typed. Thus C has been called both strongly typed and weakly, statically typed.
It may seem odd to some professional programmers that C could be
"weakly, statically typed". However, notice that the use of the generic
pointer, the void* pointer, does allow for casting of pointers to
other pointers without needing to do an explicit cast. This is
extremely similar to somehow casting an array of bytes to any kind of
datatype in C without using an explicit cast, such as (int) or (char).
Standard library and run-time system
Most programming languages have an associated core library
(sometimes known as the 'standard library', especially if it is
included as part of the published language standard), which is
conventionally made available by all implementations of the language.
Core libraries typically include definitions for commonly used
algorithms, data structures, and mechanisms for input and output.
The line between a language and its core library differs from
language to language. In some cases, the language designers may treat
the library as a separate entity from the language. However, a
language's core library is often treated as part of the language by its
users, and some language specifications even require that this library
be made available in all implementations. Indeed, some languages are
designed so that the meanings of certain syntactic constructs cannot
even be described without referring to the core library. For example, in
Java, a string literal is defined as an instance of the java.lang.String class; similarly, in Smalltalk, an anonymous function expression (a "block") constructs an instance of the library's BlockContext class. Conversely, Scheme
contains multiple coherent subsets that suffice to construct the rest
of the language as library macros, and so the language designers do not
even bother to say which portions of the language must be implemented as
language constructs, and which must be implemented as parts of a
library.
Design and implementation
Programming
languages share properties with natural languages related to their
purpose as vehicles for communication, having a syntactic form separate
from its semantics, and showing language families of related languages branching one from another.
But as artificial constructs, they also differ in fundamental ways from
languages that have evolved through usage. A significant difference is
that a programming language can be fully described and studied in its
entirety, since it has a precise and finite definition. By contrast, natural languages have changing meanings given by their users in different communities. While constructed languages
are also artificial languages designed from the ground up with a
specific purpose, they lack the precise and complete semantic definition
that a programming language has.
Many programming languages have been designed from scratch,
altered to meet new needs, and combined with other languages. Many have
eventually fallen into disuse. Although there have been attempts to
design one "universal" programming language that serves all purposes,
all of them have failed to be generally accepted as filling this role. The need for diverse programming languages arises from the diversity of contexts in which languages are used:
Programs range from tiny scripts written by individual hobbyists to huge systems written by hundreds of programmers.
Programmers range in expertise from novices who need simplicity
above all else, to experts who may be comfortable with considerable
complexity.
Programs may be written once and not change for generations, or they may undergo continual modification.
Programmers may simply differ in their tastes: they may be
accustomed to discussing problems and expressing them in a particular
language.
One common trend in the development of programming languages has been
to add more ability to solve problems using a higher level of abstraction.
The earliest programming languages were tied very closely to the
underlying hardware of the computer. As new programming languages have
developed, features have been added that let programmers express ideas
that are more remote from simple translation into underlying hardware
instructions. Because programmers are less tied to the complexity of the
computer, their programs can do more computing with less effort from
the programmer. This lets them write more functionality per time unit.
Natural language programming
has been proposed as a way to eliminate the need for a specialized
language for programming. However, this goal remains distant and its
benefits are open to debate. Edsger W. Dijkstra
took the position that the use of a formal language is essential to
prevent the introduction of meaningless constructs, and dismissed natural language programming as "foolish". Alan Perlis was similarly dismissive of the idea. Hybrid approaches have been taken in Structured English and SQL.
A language's designers and users must construct a number of
artifacts that govern and enable the practice of programming. The most
important of these artifacts are the language specification and implementation.
Specification
The specification of a programming language is an artifact that the language users and the implementors can use to agree upon whether a piece of source code is a valid program in that language, and if so what its behavior shall be.
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.
An implementation of a programming language provides a way to
write programs in that language and execute them 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 much faster than those that are interpreted in software.
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.
Proprietary languages
Although most of the most commonly used programming languages have
fully open specifications and implementations, many programming
languages exist only as proprietary programming languages with the
implementation available only from a single vendor, which may claim that
such a proprietary language is their intellectual property. Proprietary
programming languages are commonly domain specific languages or internal scripting languages
for a single product; some proprietary languages are used only
internally within a vendor, while others are available to external
users.
Some programming languages exist on the border between proprietary and open; for example, Oracle Corporation asserts proprietary rights to some aspects of the Java programming language, and Microsoft's C# programming language, which has open implementations of most parts of the system, also has Common Language Runtime (CLR) as a closed environment.
Many proprietary languages are widely used, in spite of their proprietary nature; examples include MATLAB, VBScript, and Wolfram Language. Some languages may make the transition from closed to open; for example, Erlang was originally an Ericsson's internal programming language.
Use
Thousands of different programming languages have been created, mainly in the computing field.
Software is commonly built with 5 programming languages or more.
Programming languages differ from most other forms of human
expression in that they require a greater degree of precision and
completeness. When using a natural language to communicate with other
people, human authors and speakers can be ambiguous and make small
errors, and still expect their intent to be understood. However,
figuratively speaking, computers "do exactly what they are told to do",
and cannot "understand" what code the programmer intended to write. The
combination of the language definition, a program, and the program's
inputs must fully specify the external behavior that occurs when the
program is executed, within the domain of control of that program. On
the other hand, ideas about an algorithm can be communicated to humans
without the precision required for execution by using pseudocode, which interleaves natural language with code written in a programming language.
A programming language provides a structured mechanism for
defining pieces of data, and the operations or transformations that may
be carried out automatically on that data. A programmer uses the abstractions
present in the language to represent the concepts involved in a
computation. These concepts are represented as a collection of the
simplest elements available (called primitives). Programming
is the process by which programmers combine these primitives to compose
new programs, or adapt existing ones to new uses or a changing
environment.
Determining which is the most widely used programming language is
difficult since the definition of usage varies by context. One language
may occupy the greater number of programmer hours, a different one has
more lines of code, and a third may consume the most CPU time. Some
languages are very popular for particular kinds of applications. For
example, COBOL is still strong in the corporate data center, often on large mainframes; Fortran in scientific and engineering applications; Ada in aerospace, transportation, military, real-time and embedded applications; and C
in embedded applications and operating systems. Other languages are
regularly used to write many different kinds of applications.
Various methods of measuring language popularity, each subject to a different bias over what is measured, have been proposed:
counting the number of job advertisements that mention the language
the number of books sold that teach or describe the language
estimates of the number of existing lines of code written in the
language – which may underestimate languages not often found in public
searches
counts of language references (i.e., to the name of the language) found using a web search engine.
Combining and averaging information from various internet sites,
stackify.com reported the ten most popular programming languages as (in
descending order by overall popularity): Java, C, C++, Python, C#, JavaScript, VB .NET, R, PHP, and MATLAB.
Dialects, flavors and implementations
A dialect of a programming language or a data exchange language
is a (relatively small) variation or extension of the language that
does not change its intrinsic nature. With languages such as Scheme and Forth,
standards may be considered insufficient, inadequate or illegitimate by
implementors, so often they will deviate from the standard, making a
new dialect. In other cases, a dialect is created for use in a domain-specific language, often a subset. In the Lisp world, most languages that use basic S-expression syntax and Lisp-like semantics are considered Lisp dialects, although they vary wildly, as do, say, Racket and Clojure.
As it is common for one language to have several dialects, it can
become quite difficult for an inexperienced programmer to find the right
documentation. The BASIC programming language has many dialects.
The explosion of Forth dialects led to the saying "If you've seen one Forth... you've seen one Forth."
Taxonomies
There is no overarching classification scheme for programming
languages. A given programming language does not usually have a single
ancestor language. Languages commonly arise by combining the elements of
several predecessor languages with new ideas in circulation at the
time. Ideas that originate in one language will diffuse throughout a
family of related languages, and then leap suddenly across familial gaps
to appear in an entirely different family.
The task is further complicated by the fact that languages can be
classified along multiple axes. For example, Java is both an
object-oriented language (because it encourages object-oriented
organization) and a concurrent language (because it contains built-in
constructs for running multiple threads in parallel). Python is an object-oriented scripting language.
In broad strokes, programming languages divide into programming paradigms and a classification by intended domain of use, with general-purpose programming languages distinguished from domain-specific programming languages.
Traditionally, programming languages have been regarded as describing
computation in terms of imperative sentences, i.e. issuing commands.
These are generally called imperative programming
languages. A great deal of research in programming languages has been
aimed at blurring the distinction between a program as a set of
instructions and a program as an assertion about the desired answer,
which is the main feature of declarative programming. More refined paradigms include procedural programming, object-oriented programming, functional programming, and logic programming; some languages are hybrids of paradigms or multi-paradigmatic. An assembly language
is not so much a paradigm as a direct model of an underlying machine
architecture. By purpose, programming languages might be considered
general purpose, system programming languages, scripting languages, domain-specific languages, or concurrent/distributed languages (or a combination of these). Some general purpose languages were designed largely with educational goals.
A programming language may also be classified by factors
unrelated to programming paradigm. For instance, most programming
languages use English language keywords, while a minority do not. Other languages may be classified as being deliberately esoteric or not.
