Compiler

Compilers generally implement these phases as modular components, promoting efficient design and correctness of transformations of source input to target output.

[4] With respect to making source code runnable, an interpreter provides a similar function as a compiler, but via a different mechanism.

Low-level programming languages, such as assembly and C, are typically compiled, especially when speed is a significant concern, rather than cross-platform support.

Primitive binary languages evolved because digital devices only understand ones and zeros and the circuit patterns in the underlying machine architecture.

[5] Limited memory capacity of early computers led to substantial technical challenges when the first compilers were designed.

"[9] Between 1942 and 1945, Konrad Zuse designed the first (algorithmic) programming language for computers called Plankalkül ("Plan Calculus").

Zuse also envisioned a Planfertigungsgerät ("Plan assembly device") to automatically translate the mathematical formulation of a program into machine-readable punched film stock.

[10] While no actual implementation occurred until the 1970s, it presented concepts later seen in APL designed by Ken Iverson in the late 1950s.

However, several research and industry efforts began the shift toward high-level systems programming languages, for example, BCPL, BLISS, B, and C. BCPL (Basic Combined Programming Language) designed in 1966 by Martin Richards at the University of Cambridge was originally developed as a compiler writing tool.

BLISS (Basic Language for Implementation of System Software) was developed for a Digital Equipment Corporation (DEC) PDP-10 computer by W. A. Wulf's Carnegie Mellon University (CMU) research team.

[37] Bell Labs left the Multics project in 1969, and developed a system programming language B based on BCPL concepts, written by Dennis Ritchie and Ken Thompson.

[44] PQCC tried to extend the term compiler-compiler beyond the traditional meaning as a parser generator (e.g., Yacc) without much success.

PQCC research into code generation process sought to build a truly automatic compiler-writing system.

TCOL was developed for the PQCC research to handle language specific constructs in the intermediate representation.

The Ada STONEMAN document[a] formalized the program support environment (APSE) along with the kernel (KAPSE) and minimal (MAPSE).

Unix/VADS could be hosted on a variety of Unix platforms such as DEC Ultrix and the Sun 3/60 Solaris targeted to Motorola 68020 in an Army CECOM evaluation.

More compilers became included in language distributions (PERL, Java Development Kit) and as a component of an IDE (VADS, Eclipse, Ada Pro).

[49] "When the field of compiling began in the late 50s, its focus was limited to the translation of high-level language programs into machine code ...

Design requirements include rigorously defined interfaces both internally between compiler components and externally between supporting toolsets.

A compiler for a relatively simple language written by one person might be a single, monolithic piece of software.

Separate phases provide design improvements that focus development on the functions in the compilation process.

As a result, compilers were split up into smaller programs which each made a pass over the source (or some representation of it) performing some of the required analysis and translations.

The disadvantage of compiling in a single pass is that it is not possible to perform many of the sophisticated optimizations needed to generate high quality code.

While the frontend can be a single monolithic function or program, as in a scannerless parser, it was traditionally implemented and analyzed as several phases, which may execute sequentially or concurrently.

The semantic analysis phase is generally more complex and written by hand, but can be partially or fully automated using attribute grammars.

Interprocedural analysis and optimizations are common in modern commercial compilers from HP, IBM, SGI, Intel, Microsoft, and Sun Microsystems.

The free software GCC was criticized for a long time for lacking powerful interprocedural optimizations, but it is changing in this respect.

Another open source compiler with full analysis and optimization infrastructure is Open64, which is used by many organizations for research and commercial purposes.

Some language specifications spell out that implementations must include a compilation facility; for example, Common Lisp.

Other languages have features that are very easy to implement in an interpreter, but make writing a compiler much harder; for example, APL, SNOBOL4, and many scripting languages allow programs to construct arbitrary source code at runtime with regular string operations, and then execute that code by passing it to a special evaluation function.