on 02-Nov-2017 (Thu)

OPPROX operates in four conceptual steps. First, OPPROX identifies different computation phases. Second, OPPROX models the speedup and error generated due to different levels of approximation in the individual ABs and in different com- putation phases using representative inputs. Third, OPPROX compares the benefits of various approximation settings in dif- ferent phases and splits the overall error budget e b into phase- specific error budgets in proportion to the predicted benefits. Finally, OPPROX formulates phase-specific trade-off space exploration as a numerical optimization problem and finds the most profitable approximation settings for each phase using the phase-specific error budgets as the constraints. We show that for many applications, both the approxima- tion level and the phase in which approximation is performed, have significant contributions towards the final error. Hence, phase-specific optimal approximation settings can provide good speedup (which we express here using the number of instructions executed) even under constrained error budget. When compared to an oracle but phase-agnostic version from prior works[ 43 , 44 ], our approach on average provides 42% speedup compared to 37% from the oracle version for an error budget of 20% and for a small error budget of 5% provides on average 14% speedup compared to only 2% achieved by the phase-agnostic oracle version.

Compiler a computer program that translates other computer programs

programming language—a formal language designed for expressing com- putation.

Instruction set The set of operations supported by a processor; the overall design of an instruction set is often called an instruction set architecture or ISA

Virtual machine A virtual machine is a simulator for some processor. It is an interpreter for that machine’s instruction set.

Compilers that tar- get programming languages rather than the instruction set of a computer are often called source-to-source translators

compiler that executes at runtime, sometimes called a just-in-time compiler, or jit, that translates heavily used bytecode sequences into native code for the underlying computer.

The first principle is inviolable: The compiler must preserve the meaning of the program being compiled

The second principle that a compiler must observe is practical: The compiler must improve the input program in some discernible way

Some text here

IR A compiler uses some set of data structures to represent the code that it processes. That form is called an intermediate representation, or IR.

Retargeting The task of changing the compiler to generate code for a new processor is often called retargeting the compiler.

Optimizer The middle section of a compiler, called an optimizer, analyzes and transforms the IR to improve it

This leads to the following compiler structure, termed a three-phase compiler.

The optimizer is an ir-to-ir transformer that tries to improve the ir program in some way.

Scanner the compiler pass that converts a string of characters into a stream of words

By inspection, we can discover the following derivation for our example sentence:

The derivation starts with the syntactic variable Sentence.

Parser the compiler pass that determines if the input stream is a sentence in the source language

Moral principles or ethical principles are beliefs regarding what is good, acceptable, or obligatory behavior and what is bad, unacceptable, or forbidden behavior.

Ethical principles may refer to beliefs regarding behavior that an individual expects of himself, as well as shared beliefs regarding behavior expected by a community or societal group.

Data-flow analysis a form of compile-time reasoning about the runtime flow of values

Virtual register a symbolic register name that the compiler uses to indicate that a value can be stored in a register

• 1951 – Regional Assembly Language
• 1952 – Autocode
• 1954 – IPL (forerunner to LISP)
• 1955 – FLOW-MATIC (led to COBOL)
• 1957 – FORTRAN (First compiler)
• 1957 – COMTRAN (precursor to COBOL)
• 1958 – LISP
• 1958 – ALGOL 58
• 1959 – FACT (forerunner to COBOL)
• 1959 – COBOL

• 1959 – RPG
• 1962 – APL
• 1962 – Simula
• 1962 – SNOBOL
• 1963 – CPL (forerunner to C)
• 1964 – Speakeasy (computational environment)
• 1964 – BASIC
• 1964 – PL/I
• 1966 – JOSS
• 1967 – BCPL (forerunner to C)

Before computer programming languages were made, paper tapes and punch cards which held complicated weaving patterns for the loom Tabulating Machine Company Looms by Jacquard in 1710

Charles Babbage started building a computing and the analytical Machine

In the 20th century, Herman Hollerith founded the Tabulating Machine. His machine tabulators were used to speed up the counting and sorting of punch cards.

In the early 1940s J. Presper Eckert and John W. Mauchly started building the ENIAC (Electronic Numerical Integrator and Calculator), which was completed by 1946.

FORTRAN, which stands for FORmula TRANslation

During a nine-month period in 1842–1843, Ada Lovelace translated the memoir of Italian mathematician Luigi Menabrea about Charles Babbage's newest proposed machine, the analytical engine. With the article she appended a set of notes which specified in complete detail a method for calculating Bernoulli numbers with the engine, recognized by some historians as the world's first computer program.^[1]

Herman Hollerith realized that he could encode information on punch cards when he observed that train conductors encode the appearance of the ticket holders on the train tickets using the position of punched holes on the tickets^[2]. Hollerith then encoded the 1890 American census data on punch cards.

Jacquard Looms and Charles Babbage's Difference Engine both had simple, extremely limited languages for describing the actions that these machines should perform. One can even regard the punch holes on a player piano scroll as a limited domain-specific language, albeit not designed for human consumption.

An early high-level programming language to be designed for a computer was Plankalkül, developed by the Germans for Z1 by Konrad Zuse between 1943 and 1945. However, it was not implemented until 1998 and 2000.^[3]

John Mauchly's Short Code, proposed in 1949, was one of the first high-level languages ever developed for an electronic computer.^[4] 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. 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.^[5][6]

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.^[11] The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959.^[12] Flow-Matic was a major influence in the design of COBOL, since only it and its direct descendent AIMACO were in actual use at the time.^[13]

Other languages still in use today include LISP (1958), invented by John McCarthy and COBOL (1959), created by the Short Range Committee. Another milestone in the late 1950s was the publication, by a committee of American and European computer scientists, of "a new language for algorithms"; the ALGOL 60 Report (the "ALGOrithmic Language").

The period from the late 1960s to the late 1970s brought a major flowering of programming languages. Most of the major language paradigms now in use were invented in this period:

• Speakeasy (computational environment), developed in 1964 at Argonne National Laboratory (ANL) by Stanley Cohen, is an OOPS (object-oriented programming, much like the later MATLAB, IDL (programming language) and Mathematica) numerical package. Speakeasy has a clear Fortran foundation syntax. It first addressed efficient physics computation internally at ANL, was modified for research use (as "Modeleasy") for the Federal Reserve Board in the early 1970s and then was made available commercially; Speakeasy and Modeleasy are still in use currently.
• Simula, invented in the late 1960s by Nygaard and Dahl as a superset of Algol 60, was the first language designed to support object-oriented programming.
• C, an early systems programming language, was developed by Dennis Ritchie and Ken Thompson at Bell Labs between 1969 and 1973.
• Smalltalk (mid-1970s) provided a complete ground-up design of an object-oriented language.
• Prolog, designed in 1972 by Colmerauer, Roussel, and Kowalski, was the first logic programming language.
• ML built a polymorphic type system (invented by Robin Milner in 1973) on top of Lisp,

...

1968 – Logo 1969 – B (forerunner to C) 1970 – Pascal 1970 – Forth 1972 – C

1972 – Smalltalk 1972 – Prolog 1973 – ML 1975 – Scheme 1978 – SQL (a query language, later extended)

1980 – C++ (as C with classes, renamed in 1983) 1983 – Ada 1984 – Common Lisp 1984 – MATLAB 1984 - FoxPro (as FoxBASE, later developing into Visual FoxPro 1985 – Eiffel 1986 – Objective-C

1986 – LabVIEW (Visual Programming Language) 1986 – Erlang 1987 – Perl 1988 – Tcl 1988 – Wolfram Language (as part of Mathematica, only got a separate name in June 2013) 1989 – FL (Backus)

• 1990 – Haskell
• 1991 – Python
• 1991 – Visual Basic
• 1993 – Ruby
• 1993 – Lua
• 1993 – R
• 1994 – CLOS (part of ANSI Common Lisp)

• 1995 – Ada 95
• 1995 – Java
• 1995 – Delphi (Object Pascal)
• 1995 – JavaScript
• 1995 – PHP
• 1997 – Rebol
• 1999 – D

Some notable languages developed during this period include:

2000 – ActionScript 2001 – C# 2003 – Apache Groovy 2003 – Scala 2005 – F# 2006 – Windows PowerShell 2007 – Clojure

2009 – Go 2010 – Rust 2011 – Dart 2011 – Kotlin 2012 – Julia 2014 – Swift