pldb/PLDB huggingface dataset:
Ada (pl, appeared 1980)
Creators: Jean Ichbiah
Origin: CII Honeywell Bull
Country: United States
Website: http://www.adaic.org
File extensions: adb
ads
Keywords: abort
else
new
return
abs
elsif
not
reverse
abstract
end
null
accept
entry
select
access
exception
of
separate
aliased
exit
or
some
all
others
subtype
and
for
out
synchronized
array
function
overriding
at
tagged
generic
package
task
begin
goto
pragma
terminate
body
private
then
if
procedure
type
case
in
protected
constant
interface
until
is
raise
use
declare
range
delay
limited
record
when
delta
loop
rem
while
digits
renames
with
do
mod
requeue
xor


Ada is a structured, statically typed, imperative, wide-spectrum, and object-oriented high-level computer programming language, extended from Pascal and other languages. It has built-in language support for design-by-contract, extremely strong typing, explicit concurrency, offering tasks, synchronous message passing, protected objects, and non-determinism. Ada improves code safety and maintainability by using the compiler to find errors in favor of runtime errors. Ada is an international standard; the current version (known as Ada 2012) is defined by ISO/IEC 8652:2012. Ada was originally designed by a team led by Jean Ichbiah of CII Honeywell Bull under contract to the United States Department of Defense (DoD) from 1977 to 1983 to supersede over 450 programming languages used by the DoD at that time. Ada was named after Ada Lovelace (1815–1852), who has been credited with being the first computer programmer.
Adenine (pl, appeared 1999)
Origin: Massachusetts Institute of Technology


Haystack was a project at the Massachusetts Institute of Technology to research and develop several applications around personal information management and the Semantic Web. The most notable of those applications is the Haystack client, a research personal information manager (PIM) and one of the first to be based on semantic desktop technologies. The Haystack client is published as open source software under the BSD license.  Similar to the Chandler PIM, the Haystack system unifies handling different types of unstructured information. This information has a common representation in RDF that is presented to users in a configurable human-readable way.
Adept (pl, appeared 2018)
Creators: Isaac Shelton
Origin: https://github.com/AdeptLanguage/
Country: Unknown
Website: https://github.com/AdeptLanguage/Adept

A blazing fast language for general purpose programming.


GitHub description: The Adept Programming Language

/*
    For values that use ownership-based memory management
    (e.g. String, List, Grid)
    we must transfer ownership if we want to keep them
    alive for longer than their owner's scope
*/
import basics
func main {
    everyone <String> List = getEveryoneAttending()
    each fullname String in everyone {
        print("=> " + fullname)
    }
}
func getEveryoneAttending() <String> List {
    everyone <String> List
    person1 String = getFullnameReturnImmediately("Alice", "Golden")
    person2 String = getFullnameStoreAndThenLaterReturn("Bob", "Johnson")
    // Commit ownership of strings held by 'person1' and 'person2'
    // to be managed by the list
    everyone.add(person1.commit())
    everyone.add(person2.commit())
    // Commit ownership of the list to the caller
    return everyone.commit()
}
func getFullnameReturnImmediately(firstname, lastname String) String {
    // '.commit()' is not necessary here
    return firstname + " " + lastname
}
func getFullnameStoreAndThenLaterReturn(firstname, lastname String) String {
    fullname String = firstname + " " + lastname
    // Ownership of the result is held by 'fullname',
    // so we must transfer ownership to the caller in order
    // to keep it alive after this function returns
    // '.commit()' is necessary here
    return fullname.commit()
}
Advanced Continuous Simulation Language (pl, appeared 1967)
Origin: Simulation Councils Inc


The Advanced Continuous Simulation Language, or ACSL (pronounced "axle"), is a computer language designed for modeling and evaluating the performance of continuous systems described by time-dependent, nonlinear differential equations. Like SIMCOS and TUTSIM, ACSL is a dialect of the Continuous System Simulation Language (CSSL), originally designed by the Simulation Councils Inc (SCI) in 1967 in an attempt to unify the continuous simulations field.
Agda (pl, appeared 2007)
Creators: Ulf Norell
Catarina Coquand
Origin: Chalmers University of Technology
Country: Sweden
Website: http://wiki.portal.chalmers.se/agda


Agda is a dependently typed functional programming language originally developed by Ulf Norell at Chalmers University of Technology with implementation described in his PhD thesis. The current version of Agda was originally known as Agda 2. The original Agda system was developed at Chalmers by Catarina Coquand in 1999. The current version is a full rewrite, which should be considered a new language that shares name and tradition. Agda is also a proof assistant based on the propositions-as-types paradigm, but unlike Coq, has no support for tactics, and proofs are written in a functional programming style. The language has ordinary programming constructs such as data types, pattern matching, records, let expressions and modules, and a Haskell-like syntax. The system has Emacs and Atom interfaces but can also be run in batch mode from the command line. Agda is based on Zhaohui Luo's Unified Theory of Dependent Types (UTT), a type theory similar to Martin-Löf type theory.
AgentSpeak (pl, appeared 1994)
Creators: Anand Rao
Origin: Federal University of Rio Grande do Sul
University of Massachusetts Amherst


AgentSpeak is an agent-oriented programming language. It is based on logic programming and the BDI architecture for (cognitive) autonomous agents. The language was originally called AgentSpeak(L), but became more popular as AgentSpeak, a term that is also used to refer to the variants of the original language.
Aime (pl, appeared 2013)
Creators: Ciprian Niculescu
Origin: https://sourceforge.net/projects/aime-embedded/
Country: Unknown
Website: https://aime-embedded.sourceforge.net/

aime is an imperative procedural programming language, with a C inspired syntax.



integer
median3(integer a, integer b, integer c)
{
    integer m;
    if (a < b) {
        if (b < c) {
            m = b;
        } else {
            if (a < c) {
                m = c;
            } else {
                m = a;
            }
        }
    } else {
        if (a < c) {
            m = a;
        } else {
            if (b < c) {
                m = c;
            } else {
                m = b;
            }
        }
    }
    return m;
}
AIMMS (pl, appeared 1993)
Stands for: Advanced Interactive Multidimensional Modeling System
Creators: Johannes J. Bisschop
Marcel Roelofs
Origin: AIMMS B.V. or Paragon Decision Technology B.V.

AIMMS (an acronym for "Advanced Interactive Multidimensional Modeling System") began as a software system designed for modeling and solving large-scale optimization and scheduling-type problems. AIMMS is considered to be one of the five most important algebraic modeling languages and the creator (Johannes J. Bisschop) has been awarded with INFORMS Impact Prize for his work in this language.

AIMMS is a prescriptive analytics software company with offices in the Netherlands, United States, China and Singapore. AIMMS has two main product offerings that provide modeling and optimization capabilities across a variety of industries. The AIMMS Prescriptive Analytics Platform is a tool for those with an Operations Research or Analytics background. It offers unlimited flexibility to develop optimization-based applications and deploy them to business users. AIMMS SC Navigator, launched in 2017, is built on the AIMMS Prescriptive Analytics Platform and provides configurable Apps for supply chain teams. SC Navigator provides supply chain analytics to individuals without a technical or analytics background so they can get the same benefits from sophisticated analytics without needing to code or model.
AIR (ir, appeared 2016)
Stands for: Assembly Intermediate Representation
Origin: Apple
Website: https://webkit.org/docs/b3/assembly-intermediate-representation.html

Bare Bones Backend / Assembly Intermediate Representation. The B3 compiler comprises two intermediate representations: a higher-level SSA-based representation called B3 IR and a lower-level representation that focuses of machine details, like registers. This lower-level form is called Air (Assembly Intermediate Representation).
Airtable (application, appeared 2012)
Origin: Formagrid, Inc.
Website: https://airtable.com/


Airtable is a cloud collaboration service headquartered in San Francisco. It was founded in 2012 by Howie Liu, Andrew Ofstad, and Emmett Nicholas. Airtable is a spreadsheet-database hybrid, with the features of a database but applied to a spreadsheet. The fields in an Airtable table are similar to cells in a spreadsheet, but have types such as 'checkbox', 'phone number', and 'drop-down list', and can reference file attachments like images.Users can create a database, set up column types, add records, link tables to one another, collaborate, sort records and publish views to external websites.
Alternate Instruction Set (isa, appeared 2001)
Origin: VIA Technologies, Inc


The Alternate Instruction Set (AIS) is a second 32-bit instruction set architecture found in some x86 CPUs made by VIA Technologies.  On these VIA C3 processors, the second hidden processor mode is accessed by executing the x86 instruction ALTINST (0F 3F).  If AIS mode has been enabled, the processor will perform a JMP EAX and begin executing AIS instructions at the address of the EAX register.  Using AIS allows native access to the Centaur Technology-designed RISC core inside the processor.
alan (pl, appeared 2018)
Origin: Kjerner
Website: https://alan-platform.com/pages/tuts/introducing.html




'Reasons': collection { }
'Users': collection {
  'Name': text
  'Active': stategroup @default: 'Yes' (
    'Yes' -> { }
    'No' -> {
      'Reason': text -> ?^ .^ .'Reasons'
    }
  )
}
'Active Users':= integer 'n' = count .'Users'?'Active'|'Yes'
ALCOR (pl, appeared 1959)
Origin: ALCOR Group


For the cryonics organization, see Alcor Life Extension Foundation. ALCOR is a radar tracking station in Roi-Namur island in the north part of the Kwajalein atoll in the Marshall Islands.ALCOR is an early computer language definition created by the ALCOR Group, a consortium of universities, research institutions and manufacturers in Europe and the United States which was founded in 1959 and which had 60 members in 1966. The group had the aim of a common compiler specification for a subset of ALGOL 60 after the ALGOL meeting in Copenhagen in 1958.
Aldor (pl, appeared 1990)
Creators: Richard Dimick Jenks
Barry Trager
Stephen Watt
James Davenport
Robert Sutor
Scott Morrison
Origin: Western University
Country: United Kingdom
Website: http://www.aldor.org


Aldor is a programming language. It is the successor of A# as the extension language of the Axiom computer algebra system. Aldor combines imperative, functional, and object-oriented features. It has an elaborate type system,"Aldor Programming Language". Aldor.org. Retrieved 12 February 2017. allowing types to be used as first-class values. Aldor's syntax is heavily influenced by Pascal, but it is optionally indentation-sensitive, using whitespace characters and the off-side rule, like Python. In its current implementation, it is compiled, but an interactive listener is provided. Aldor is distributed as free and open-source software, under the Apache License 2.0.
Algebraic Logic Functional (pl, appeared 1990)
Stands for: Algebraic Logic Functional
Origin: Carnegie Mellon University
University of Kiel
Country: Germany


Algebraic Logic Functional programming language, also known as ALF, is a programming language which combines functional and logic programming techniques. Its foundation is Horn clause logic with equality which consists of predicates and Horn clauses for logic programming, and functions and equations for functional programming. ALF was designed to be genuine integration of both programming paradigms, and thus any functional expression can be used in a goal literal and arbitrary predicates can occur in conditions of equations. ALF's operational semantics is based on the resolution rule to solve literals and narrowing to evaluate functional expressions. In order to reduce the number of possible narrowing steps, a leftmost-innermost basic narrowing strategy is used which, it is claimed, can be efficiently implemented. Terms are simplified by rewriting before a narrowing step is applied and equations are rejected if the two sides have different constructors at the top. Rewriting and rejection are supposed to result in a large reduction of the search tree and produce an operational semantics that is more efficient than Prolog's resolution strategy. Similarly to Prolog, ALF uses a backtracking strategy corresponding to a depth-first search in the derivation tree. The ALF system was designed to be an efficient implementation of the combination of resolution, narrowing, rewriting, and rejection. ALF programs are compiled into instructions of an abstract machine. The abstract machine is based on the Warren Abstract Machine (WAM) with several extensions to implement narrowing and rewriting. In the current ALF implementation programs of this abstract machine are executed by an emulator written in C. In the Carnegie Mellon University Artificial Intelligence Repository, ALF is included as an AI programming language, in particular as a functional/logic programming language Prolog implementation. A user manual describing the language and the use of the system is available. The ALF System runs under Unix and is free.
alfred (pl, appeared 1972)
Website: https://www.alfredapp.com/


alfred is an application launcher and productivity application for macOS. Alfred is free, though an optional paid upgrade ('Powerpack') is available. Using a keyboard shortcut chosen by the user, Alfred provides a quick way to find and launch applications and files on the Mac or to search the web both with predefined keywords for often-used sites such as Amazon.com, IMDb, Wikipedia and many others, with the ability to add users' custom searches for the sites most applicable to them.
Algebraic modeling language (pl, appeared 1980)
Origin: IBM


Algebraic modeling languages (AML) are high-level computer programming languages for describing and solving high complexity problems for large scale mathematical computation (i.e. large scale optimization type problems). One particular advantage of some algebraic modeling languages like AIMMS, AMPL, GAMS,MathProg, Mosel,  and OPL is the similarity of their syntax to the mathematical notation of optimization problems. This allows for a very concise and readable definition of problems in the domain of optimization, which is supported by certain language elements like sets, indices, algebraic expressions, powerful sparse index and data handling variables, constraints with arbitrary names. The algebraic formulation of a model does not contain any hints how to process it. An AML does not solve those problems directly; instead, it calls appropriate external algorithms to obtain a solution. These algorithms are called solvers and can handle certain kind of mathematical problems like:  linear problems integer problems (mixed integer) quadratic problems mixed complementarity problems mathematical programs with equilibrium constraints constrained nonlinear systems general nonlinear problems non-linear programs with discontinuous derivatives nonlinear integer problems global optimization problems stochastic optimization problems
ALGO (pl, appeared 1958)
Origin: Bendix Corporation


ALGO is an algebraic programming language developed between 1959 and 1961 for the Bendix G-15 computer. ALGO was one of several programming languages inspired by the Preliminary Report on the Language written in Zürich in 1958. This report underwent several modifications before becoming the Revised Report on which most ALGOL implementations are based. As a result, ALGO and other early "ALGOLs" have a very different syntax from ALGOL 60. Other languages developed from the Zürich report include BENJAMIN, MAD (Michigan Algorithm Decoder) and NELIAC.
algobox (pl, appeared 2011)
Country: France
Website: https://www.xm1math.net/algobox/


algobox is an easy-to-use pedagogical software for initiation to algorithms, distributed under the GNU/GPL license. It is available for free for Linux, macOS and Windows platforms and can even run on a simple USB key. Using an algorithmic language in French and a simple and ergonomic graphical user interface, this software makes it easy to design and test algorithms that may be encountered in secondary school mathematics education.
ALGOL 58 (pl, appeared 1958)
Origin: Association for Computing Machinery
Gesellschaft für Angewandte Mathematik und Mechanik


ALGOL 58, originally known as IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus  "The Zurich ACM-GAMM Conference had two principal motives in proposing the IAL: (a) To provide a means of communicating numerical methods and other procedures between people, and (b) To provide a means of realizing a stated process on a variety of machines..."  ALGOL 58 introduced the fundamental notion of the compound statement, but it was restricted to control flow only, and it was not tied to identifier scope in the way that Algol 60's blocks were.
ALGOL 60 (pl, appeared 1960)
Creators: John Backus
Friedrich L. Bauer
Julien Green
Charles Katz
John McCarthy
Peter Naur
Alan Perlis
Heinz Rutishauser
Klaus Samelson
Adriaan van Wijngaarden
Bernard Vauquois
Joseph Henry Wegstein
Michael Woodger
Origin: International Federation for Information Processing

ALGOL 60 (short for Algorithmic Language 1960) is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them. ALGOL 60 was the first language implementing nested function definitions with lexical scope. It gave rise to many other programming languages, including CPL, Simula, BCPL, B, Pascal and C.

ALGOL 60 (short for Algorithmic Language 1960) is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them.  ALGOL 60 was the first language implementing nested function definitions with lexical scope.  It gave rise to many other programming languages, including CPL, Simula, BCPL, B, Pascal and C. Niklaus Wirth based his own ALGOL W on ALGOL 60 before moving to develop Pascal. Algol-W was intended to be the next generation ALGOL but the ALGOL 68 committee decided on a design that was more complex and advanced rather than a cleaned simplified ALGOL 60. The official ALGOL versions are named after the year they were first published. Algol 68 is substantially different from Algol 60 and was criticised partially for being so, so that in general "Algol" refers to dialects of Algol 60.


procedure Absmax(a) Size:(n, m) Result:(y) Subscripts:(i, k);
   value n, m; array a; integer n, m, i, k; real y;
comment The absolute greatest element of the matrix a, of size n by m,
    is transferred to y, and the subscripts of this element to i and k;
begin
    integer p, q;
    y := 0; i := k := 1;
    for p := 1 step 1 until n do
        for q := 1 step 1 until m do
            if abs(a[p, q]) > y then
                begin y := abs(a[p, q]);
                    i := p; k := q
                end
end Absmax
ALGOL 68-R (pl, appeared 1970)
Origin: Royal Radar Establishment


ALGOL 68-R was the first implementation of the Algorithmic language ALGOL 68. In December 1968 the report on the Algorithmic language ALGOL 68 was published.  On 20–24 July 1970 a working conference was arranged by the IFIP to discuss the problems of implementation of the language, a small team from the Royal Radar Establishment attended to present their compiler, written by I.F. Currie, Susan G. Bond and J.D. Morrison.  In the face of estimates of up to 100 man-years to implement the language, using up to 7 pass compilers they described how they had already implemented a one-pass compiler which was in production use in engineering and scientific applications.
ALGOL 68 (pl, appeared 1968)
Origin: International Federation for Information Processing


ALGOL 68 (short for Algorithmic Language 1968) is an imperative computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics. The contributions of ALGOL 68 to the field of computer science have been deep, wide ranging and enduring, although many of these contributions were only publicly identified when they had reappeared in subsequently developed programming languages.
ALGOL N (pl, appeared 1967)


ALGOL N is the name of a successor to ALGOL 60 designed in Japan with the aim of being as powerful as ALGOL 68 but as simple as ALGOL 60. The language was proposed by Nobuo Yoneda. Algol N tried to use extensibility in order to solve the problem that programming language designers faced when trying to make an inextensible language for everything or having to make many languages, one for each domain. It avoided coercion while not making things difficult for programmers. The letter 'N' is short for 'Nippon', or Japan in Japanese.
ALGOL W (pl, appeared 1966)
Origin: Stanford University


ALGOL W is a programming language. It is based on a proposal for ALGOL X by Niklaus Wirth and Tony Hoare as a successor to ALGOL 60 in IFIP Working Group 2.1. When the committee decided that the proposal was not a sufficient advance over ALGOL 60, the proposal was published as A contribution to the development of ALGOL. After making small modifications to the language Wirth supervised a high quality implementation for the IBM/360 at Stanford University that was widely distributed.It represented a relatively conservative modification of ALGOL 60, adding string, bitstring, complex number and reference to record datatypes and call-by-result passing of parameters, introducing the while statement, replacing switch with the case statement, and generally tightening up the language. The implementation was written in PL/360, an ALGOL-like assembly language designed by Wirth. The implementation includes influential debugging and profiling abilities.