pldb/PLDB huggingface dataset:
IBM 1620 (assembly, appeared 1959)
Origin: IBM


The IBM 1620 was announced by IBM on October 21, 1959, and marketed as an inexpensive "scientific computer". After a total production of about two thousand machines, it was withdrawn on November 19, 1970. Modified versions of the 1620 were used as the CPU of the IBM 1710 and IBM 1720 Industrial Process Control Systems (making it the first digital computer considered reliable enough for real-time process control of factory equipment). Being variable word length decimal, as opposed to fixed-word-length pure binary, made it an especially attractive first computer to learn on –  and hundreds of thousands of students had their first experiences with a computer on the IBM 1620. Core memory cycle times were 20 microseconds for the (earlier) Model I, 10 microseconds for the Model II (about a thousand times slower than typical computer main memory in 2006). The Model II was introduced in 1962.
2-pak (pl, appeared 1975)
Origin: Department of Computer Science, University of Toronto




coroutine FRUIT_GEN()
 begin
 strin g FRUIT ;
 FRUIT :- 'CHERRY1
  ;
 detach ;
 whil e tru e do
 case FRUIT of
 'CHERRY1
 : FRUIT := 'LEMON1
  ;
 'LEMON': FRUIT := 'ORANGE?
  ;
 'ORANGE1
 : FRUIT :- 'APPLE' ;
 'APPLE': FRUIT :- 'CHERRY' ;
 end ;
 detach ;
 end ;
 end ;
3DS (binaryDataFormat, appeared 1990)
Origin: Autodesk Inc.

3DS is one of the file formats used by the Autodesk 3ds Max 3D modeling, animation and rendering software.

3DS is one of the file formats used by the Autodesk 3ds Max 3D modeling, animation and rendering software. It was the native file format of the old Autodesk 3D Studio DOS (releases 1 to 4), which was popular until its successor (3D Studio MAX 1.0) replaced it in April 1996. Having been around since 1990 (when the first version of 3D Studio DOS was launched), it has grown to become a de facto industry standard for transferring models between 3D programs, or for storing models for 3D resource catalogs (along with OBJ, which is more frequently used as a model archiving file format).While the 3DS format aims to provide an import/export format, retaining only essential geometry, texture and lighting data, the related MAX format (now superseded by the PRJ format) also contains extra information specific to Autodesk 3ds Max, to allow a scene to be completely saved/loaded.
3D Manufacturing Format (xmlFormat, appeared 2015)
Stands for: 3D Manufacturing Format
Origin: 3MF Consortium
Website: http://www.3mf.io/specification/


3D Manufacturing Format or 3MF is a file format developed and published by the 3MF Consortium. 3MF is an XML-based data format designed for using additive manufacturing, including information about materials, colors, and other information that cannot be represented in the STL format. As of today, CAD software related companies such as Autodesk, Dassault Systems and Netfabb are part of the 3MF Consortium. Other firms in the 3MF Consortium are Microsoft (for Operating system support), SLM and HP, whilst Shapeways are also included to give insight from a 3D Printing background. Other key players in the 3D printing and additive manufacturing business, such as Materialise, 3D Systems, Siemens PLM Software and Stratasys have recently joined the consortium.
4G (standard, appeared 2013)


4G is the fourth generation of broadband cellular network technology, succeeding 3G. A 4G system must provide capabilities defined by ITU in IMT Advanced. Potential and current applications include amended mobile web access, IP telephony, gaming services, high-definition mobile TV, video conferencing, and 3D television. The first-release Long Term Evolution (LTE) standard was commercially deployed in Oslo, Norway, and Stockholm, Sweden in 2009, and has since been deployed throughout most parts of the world. It has, however, been debated whether first-release versions should be considered 4G LTE, as discussed in the technical understanding section below.
51forth (pl, appeared 1980)
Origin: IDACOM Electronics or Hewlett-Packard


51-FORTH is an implementation of the Forth programming language for the Intel 8051 microcontroller. It was created in 1989 by Scott Gehmlich of IDACOM Electronics (which was acquired by Hewlett-Packard in 1990), and sent to Giovanni Moretti of Massey University, from whom it was propagated widely. The original 51forth.zip package is available from many archive sites, along with several other implementations of Forth. This implementation is subroutine-threaded, with about 20 words written in assembly language, and the complete system occupying a total of about 8K of RAM. It was cross-developed from a VAX to an RTX2000 Forth system connected to dual-ported RAM accessible to the microcontroller. The sources and documentation are in the public domain.
A-0 system (compiler, appeared 1951)
Origin: Remington Rand


The A-0 system (Arithmetic Language version 0), written by Grace Murray Hopper  in 1951 and 1952 for the UNIVAC I, was an early compiler related tool developed for electronic computers. The A-0 functioned more as a loader or linker than the modern notion of a compiler. A program was specified as a sequence of subroutines and arguments. The subroutines were identified by a numeric code and the arguments to the subroutines were written directly after each subroutine code. The A-0 system converted the specification into machine code that could be fed into the computer a second time to execute the said program. The A-0 system was followed by the  A-1, A-2, A-3 (released as ARITH-MATIC), AT-3 (released as MATH-MATIC) and B-0 (released as FLOW-MATIC). The A-2 system was developed at the UNIVAC division of Remington Rand in 1953 and released to customers by the end of that year.  Customers were provided the source code for A-2 and invited to send their improvements back to UNIVAC.   Thus A-2 was an early example of free and open-source software.
A# (pl, appeared 2004)
Creators: Dr. Martin C. Carlisle
Lt Col Ricky Sward
Maj Jeff Humphries
Origin: AdaCore
United States Air Force Academy
Country: United States


A# is a port of the Ada programming language to the Microsoft .NET platform. A# is freely distributed by the Department of Computer Science at the United States Air Force Academy as a service to the Ada community under the terms of the GNU General Public License. AdaCore has taken over this development, and announced "GNAT for .NET", which is a fully supported .NET product with all of the features of A# and more.
Avionics Architecture Design Language (pl, appeared 2003)
Stands for: Avionics Architecture Design Language
Origin: Carnegie Mellon University
Website: http://www.aadl.info/aadl/currentsite/


The Architecture Analysis & Design Language (AADL) is an architecture description language standardized by SAE. AADL was first developed in the field of avionics, and was known formerly as the Avionics Architecture Description Language.The Architecture Analysis & Design Language is derived from MetaH, an architecture description language made by the Advanced Technology Center of Honeywell. AADL is used to model the software and hardware architecture of an embedded, real-time system. Due to its emphasis on the embedded domain, AADL contains constructs for modeling both software and hardware components (with the hardware components named "execution platform" components within the standard). This architecture model can then be used either as a design documentation, for analyses (such as schedulability and flow control) or for code generation (of the software portion), like UML.
Aardvark (pl, appeared 2020)
Creators: Hg0428
JustCoding123
CompilingCoder
TheBoys619
PlasDev
ZDev1
Origin: discord
Country: United Kingdom
United States
South Korea
Website: https://docs.programit.repl.co

Aardvark is an object oriented programming language designed writing clean and easy to read code. It is an interpreted language written in C++, Go, and Python. Version 0.1~0.8.9 was written in Python, Version 1.0 was written in C++, and AdkGO was written in Go. It has a UI, graphics, and data science/artificial intellegence library as of 2022.



#include os as os
class Hello() {
   funct helloWorld() {
       output('helloWorld')
       i = 0
       if i==0 {
           output('i is 0!')
       }
   }
}
ABC 80 (pl, appeared 1978)
Origin: Dataindustrier AB


The ABC 80 (Advanced BASIC Computer 80) was a personal computer engineered by the Swedish corporation Dataindustrier AB (DIAB) and manufactured by Luxor in Motala, Sweden in the late 1970s and early 1980s. It was introduced on the market in August 1978. The ABC 80 was based on an earlier modular computer system from the same company and built around a Z80 and 16 KB of ROM containing a fast semi-compiling BASIC interpreter. It had 16-32 KB of RAM as main memory and a dedicated (included) tape recorder for program and data storage, but could also be expanded to handle disk drives as well as many other peripherals.  The ROM could be extended in increments of 1 or 4KB in order to handle such so called "options". The monitor was a black and white TV set modified for the purpose, an obvious choice since Luxor also made TVs. The ABC 80 was used in schools and officies around Scandinavia and parts of Europe. It was also used for industrial automation, scientific measurement and control systems. Like its successor, the ABC 800, the computer had an unusually quick and usable BASIC with excellent I/O response times, something that was often discovered when trying to switch to IBM PC-based personal computers. Due to its roots in an industrial computer system, the ABC 80 also had a flexible bus extension system with many (external) expansion and peripheral cards available for various purposes and applications, as well as high quality support and documentation. ABC 80 was also manufactured on license as BRG ABC80 by Budapesti Rádiótechnikai Gyár in Hungary. It used the same keyboard, but the case was metal instead of plastic.
ABC (pl, appeared 1980)
Origin: Centrum Wiskunde & Informatica
Country: Netherlands


ABC is an imperative general-purpose programming language and programming environment developed at CWI, Netherlands by Leo Geurts, Lambert Meertens, and Steven Pemberton. It is interactive, structured, high-level, and intended to be used instead of BASIC, Pascal, or AWK. It is not meant to be a systems-programming language but is intended for teaching or prototyping. The language had a major influence on the design of the Python programming language; Guido van Rossum, who developed Python, previously worked for several years on the ABC system in the early 1980s.
Armed Bear Common Lisp (pl, appeared 2008)
Also known as: ABCL
Stands for: Armed Bear Common Lisp
Website: https://common-lisp.net/project/armedbear/

Armed Bear Common Lisp (ABCL) is a full implementation of the Common Lisp language featuring both an interpreter and a compiler, running in the JVM. Originally started to be a scripting language for the J editor, it now supports JSR-223 (Java scripting API): it can be a scripting engine in any Java application. Additionally, it can be used to implement (parts of) the application using Java to Lisp integration APIs.


GitHub description: Armed Bear Common Lisp <git+https://github.com/armedbear/abcl/> <--> <svn+https://abcl.org/svn> Bridge
Augmented Backus-Naur Form (grammarLanguage, appeared 2008)
Stands for: Augmented Backus-Naur Form


In computer science, augmented Backus–Naur form (ABNF) is a metalanguage based on Backus–Naur form (BNF), but consisting of its own syntax and derivation rules. The motive principle for ABNF is to describe a formal system of a language to be used as a bidirectional communications protocol. It is defined by Internet Standard 68 ("STD 68", type case sic), which as of December 2010 is RFC 5234, and it often serves as the definition language for IETF communication protocols. RFC 5234 supersedes RFC 4234 (which superseded RFC 2234 and RFC 733). RFC 7405 updates it, adding a syntax for specifying case-sensitive string literals.
abs (pl, appeared 2018)
Creators: Alessandro Nadalin
Country: United Arab Emirates
Website: https://www.abs-lang.org

ABS is a programming language that works best when you're scripting on your terminal. It tries to combine the elegance of languages such as Python, or Ruby with the convenience of Bash.


GitHub description: Home of the ABS programming language: the joy of shell scripting.

r = $(curl "http://data.nba.net/prod/v1/20170201/0021600732_boxscore.json" -H 'DNT: 1' -H 'Accept-Encoding: gzip, deflate, sdch' -H 'Accept-Language: en' -H 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36' -H 'Accept: */*' -H 'Referer: http://stats.nba.com/' -H 'Connection: keep-alive' --compressed);
if !r.ok {
    echo("Could not fetch game data. Bummer!")
    exit(1)
}
doc = r.json()
arena = doc.basicGameData.arena.name
city = doc.basicGameData.arena.city
echo("The game was played at the %s in %s", arena, city)
highlight = doc.basicGameData.nugget.text
if highlight.len() {
    echo("The press said: \"%s\"", highlight)
}
# The game was played at the TD Garden in Boston
# The press said: "Thomas scores 19 of 44 points in 4th quarter"
Ace Editor (editor, appeared 2010)
Creators: Fabian Jakobs
Origin: Mozilla Labs
Cloud9
Website: https://ace.c9.io

Ace is an embeddable code editor written in JavaScript. It matches the features and performance of native editors such as Sublime, Vim and TextMate. It can be easily embedded in any web page and JavaScript application. Ace is maintained as the primary editor for Cloud9 IDE and is the successor of the Mozilla Skywriter (Bespin) project.


GitHub description: Ace (Ajax.org Cloud9 Editor)
ACL2 (pl, appeared 1990)
Stands for: A Computational Logic for Applicative Common Lisp
Creators: Robert S. Boyer
J Strother Moore
Origin: The University of Texas at Austin
Country: United States


ACL2 (A Computational Logic for Applicative Common Lisp) is a software system consisting of a programming language, an extensible theory in a first-order logic, and an automated theorem prover.  ACL2 is designed to support automated reasoning in inductive logical theories, mostly for the purpose of software and hardware verification.  The input language and implementation of ACL2 are built on Common Lisp.  ACL2 is free, open source (BSD license) software. The ACL2 programming language is an applicative (side-effect free) variant of Common Lisp.  ACL2 is untyped. All ACL2 functions are total — that is, every function maps each object in the ACL2 universe to another object in its universe. ACL2's base theory axiomatizes the semantics of its programming language and its built-in functions.  User definitions in the programming language that satisfy a definitional principle extend the theory in a way that maintains the theory's logical consistency. The core of ACL2's theorem prover is based on term rewriting, and this core is extensible in that user-discovered theorems can be used as ad-hoc proof techniques for subsequent conjectures. ACL2 is intended to be an "industrial strength" version of the Boyer–Moore theorem prover, NQTHM.  Toward this goal, ACL2 has many features to support clean engineering of interesting mathematical and computational theories.  ACL2 also derives efficiency from being built on Common Lisp; for example, the same specification that is the basis for inductive verification can be compiled and run natively. In 2005, the authors of the Boyer-Moore family of provers, which includes ACL2, received the ACM Software System Award "for pioneering and engineering a most effective theorem prover (...) as a formal methods tool for verifying safety-critical hardware and software."
Acme (pl, appeared 1994)
Origin: Carnegie Mellon University
University of Southern California
Country: United States
Website: http://www.cs.cmu.edu/~acme/docs/language_overview.html

Acme is a simple, generic software architecture description language (ADL) that can be used as a common interchange format for architecture design tools and/or as a foundation for developing new architectural design and analysis tools. This site provides an introduction to Acme along with a collection of useful Acme software and technical information.



System simple_cs = {
   Component client = { Port send-request; };
   Component server = { Port receive-request; };
   Connector rpc = { Roels { caller, callee}};
   Attachments {
       client.send-request to rpc.caller;
       server.receive-request to rpc.callee;
   }
}
ACT-III (pl, appeared 1956)
Origin: Librascope company
Country: United States

The LGP-30 had a high-level language called ACT-III. Every token had to be delimited by an apostrophe, making it hard to read and even harder to prepare tapes.

The LGP-30, standing for Librascope General Purpose and then Librascope General Precision, was an early off-the-shelf computer. It was manufactured by the Librascope company of Glendale, California (a division of General Precision Inc.), and sold and serviced by the Royal Precision Electronic Computer Company, a joint venture with the Royal McBee division of the Royal Typewriter Company. The LGP-30 was first manufactured in 1956 with a retail price of $47,000—equivalent to about $423,000 in 2017.The LGP-30 was commonly referred to as a desk computer.  It was 26 inches (660 mm) deep, 33 inches (840 mm) high, and 44 inches (1120 mm) long, exclusive of the typewriter shelf.  The computer weighed approximately 800 pounds (360 kg) and was mounted on sturdy casters which facilitated movement of the computer.


s1'dim'a'500'm'500'q'500''
index'j'j+1'j-1''
daprt'e'n't'e'r' 'd'a't'a''cr''
rdxit's35''
s2'iread'm'1''iread'q'1''iread'd''iread'n''
1';'j''
0'flo'd';'d.''
s3'sqrt'd.';'sqrd.''
1'unflo'sqrd.'i/'10';'sqrd''
2010'print'sqrd.''2000'iprt'sqrd''cr''cr''
Action Code Script (pl, appeared 2004)
Origin: id Software


Action Code Script (ACS) is a scripting language used in video games such as HeXen and some modern Doom source ports, such as ZDoom. It is syntactically similar to C, but less flexible. As its name implies, most of the core logic for script functionality comes in the form of "scripts", which are traditionally identified with a numerical value. Later revisions of the ACS compiler added support for "named" scripts (which utilize a String in lieu of the numerical identifier), and simple functions.  Similar to traditional code, ACS is compiled using ACC (an homage to C's gcc utility) for use in Doom, Hexen, etc... Scripts can be executed in a variety of methods, such as being attached to in-game actors, execution through level triggers around each map, or invocation from other scripts or functions. As the entire scripting language is built as a hack on top of the Doom id Tech's engine, there is no formal support for any Object-oriented programming principles.
Action! (pl, appeared 1983)
Origin: Optimized Systems Software


Action! is a procedural programming language similar to ALGOL 68 that is intended to produce high-performance programs for the Atari 8-bit family. The language was written by Clinton Parker and distributed on ROM cartridge by Optimized Systems Software starting in 1983. Action! was used to develop at least two commercial products—the Homepak productivity suite and Games Computers Play client program—and numerous programs in ANALOG Computing and Antic magazines. The system was not ported to any other platforms. Parker had previously developed Micro-SPL with Henry Baker, a similar programming language for the Xerox Alto. The 6502 assembly language source code for Action! was made available under the GNU General Public License by the author in 2015.
ActionScript (pl, appeared 1998)
Creators: Gary Grossman
Origin: Macromedia


438 184 ActionScript is an object-oriented programming language originally developed by Macromedia Inc. (later acquired by Adobe Systems). It is a derivation of HyperTalk, the scripting language for HyperCard. It is now a dialect of ECMAScript (meaning it is a superset of the syntax and semantics of the language more widely known as JavaScript), though it originally arose as a sibling, both being influenced by HyperTalk. ActionScript is used primarily for the development of websites and software targeting the Adobe Flash Player platform, used on Web pages in the form of embedded SWF files. ActionScript 3 is also used with Adobe AIR system for the development of desktop and mobile applications. The language itself is open-source in that its specification is offered free of charge and both an open source compiler (as part of Apache Flex) and open source virtual machine (Mozilla Tamarin) are available. ActionScript is also used with Scaleform GFx for the development of 3D video game user interfaces and HUDs.
ActiveVFP (pl, appeared 2001)
Origin: VFP Community


ActiveVFP (also known as AVFP) is a server-side scripting framework designed for Web development to produce dynamic Web pages. Similar to PHP, but using the native Visual Foxpro (VFP) language and database (or other databases like Microsoft SQL and MySQL), ActiveVFP can also be used in Model-View-Controller (MVC) web applications as well as RESTful API.  ActiveVFP is completely free and open source and does not require the purchase of Microsoft Visual FoxPro or any additional software. ActiveVFP was originally created in 2001. The main implementation of ActiveVFP is now produced by the Foxpro Community at activevfp.codeplex.com and serves as the formal reference to ActiveVFP. ActiveVFP is free software released under the MIT License. ActiveVFP is unique among server-side web languages and frameworks because it has a database and database functionality built into the language.
Actor (pl, appeared 1988)
Origin: The Whitewater Group


The Actor programming language was invented by Charles Duff of The Whitewater Group in 1988. It was an offshoot of some object-oriented extensions to the Forth language he had been working on. Actor would be categorized as a pure object-oriented language in the style of Smalltalk. Like Smalltalk, everything was an object, including small integers. A Baker semi-space garbage collector was used, along with (in memory-constrained Windows 2.1 days) a software virtual memory system that swapped objects. A token threaded interpreter, written in 16-bit x86 assembly language, was the execution mechanism for compiled code. Actor only was released on the Microsoft Windows 2.1 and 3.0 operating system. Actor used perhaps the first pure object-oriented framework over native operating system calls as its basic GUI architecture. This allowed an Actor application to look and feel exactly like a Windows application written in C, but with all the advantages of an interactive Smalltalk-like development environment. Both a downside and upside to this architecture was a tight coupling to the Windows OS architecture, with a thin abstraction layer into objects. This allowed direct use of the rich Windows OS API, but also made it nearly impossible to support any other OS without a significant rewrite of the application framework.
Ad-hoc (pl, appeared 2017)
Website: https://gitlab.com/trobador/ad-hoc

<a href='https://github.com/pera/ad-hoc'>Ad-hoc</a> is an experimental programming language currently supporting the following features: first-class functions, immutability, lambda terms, recursion, closures, strict and non-strict evaluation, lexical and dynamic scopes, and deep binding.


GitHub description: Ad-hoc programming language