pldb/PLDB huggingface dataset:
ARM Templates (jsonFormat, appeared 2017)
Origin: Microsoft

Azure Resource Manager templates are JavaScript Object Notation (JSON) files that define the infrastructure and configuration for your project.



"properties": {
  "publisher": "Microsoft.Azure.Extensions",
  "type": "CustomScript",
  "typeHandlerVersion": "2.0",
  "autoUpgradeMinorVersion": true,
  "settings": {
    "fileUris": [
      "[concat(variables('template').assets, '/lamp-app/install_lamp.sh')]"
    ]
  },
  "protectedSettings": {
    "commandToExecute": "[concat('sh install_lamp.sh ', parameters('mySqlPassword'))]"
  }
}
ARM (assembly, appeared 1985)
Stands for: Acorn RISC Machine
Creators: Sophie Wilson
Steve Furber
Acorn Computers
Origin: Acorn Computers or Arm Ltd
Country: United Kingdom


ARM, originally Acorn RISC Machine, later Advanced RISC Machine, is a family of reduced instruction set computing (RISC) architectures for computer processors, configured for various environments. British company ARM Holdings develops the architecture and licenses it to other companies, who design their own products that implement one of those architectures‍—‌including systems-on-chips (SoC) and systems-on-modules (SoM) that incorporate memory, interfaces, radios, etc. It also designs cores that implement this instruction set and licenses these designs to a number of companies that incorporate those core designs into their own products. Processors that have a RISC architecture typically require fewer transistors than those with a complex instruction set computing (CISC) architecture (such as the x86 processors found in most personal computers), which improves cost, power consumption, and heat dissipation. These characteristics are desirable for light, portable, battery-powered devices‍—‌including smartphones, laptops and tablet computers, and other embedded systems. For supercomputers, which consume large amounts of electricity, ARM could also be a power-efficient solution. ARM Holdings periodically releases updates to architectures and core designs. All of them support a 32-bit address space (only pre-ARMv3 chips, made before ARM Holdings was formed, as in original Acorn Archimedes, had smaller) and 32-bit arithmetic; instructions for ARM Holdings' cores have 32-bit fixed-length instructions, but later versions of the architecture also support a variable-length instruction set that provides both 32- and 16-bit instructions for improved code density. Some older cores can also provide hardware execution of Java bytecodes. The ARMv8-A architecture, announced in October 2011, adds support for a 64-bit address space and 64-bit arithmetic with its new 32-bit fixed-length instruction set. With over 100 billion ARM processors produced as of 2017, ARM is the most widely used instruction set architecture in terms of quantity produced. Currently, the widely used Cortex cores, older "classic" cores, and specialized SecurCore cores variants are available for each of these to include or exclude optional capabilities.
Apache Arrow (binaryDataFormat, appeared 2016)
Also known as: feather
Origin: The Apache Software Foundation
Country: Various
Website: https://arrow.apache.org/

Apache Arrow is a cross-language development platform for in-memory data. It specifies a standardized language-independent columnar memory format for flat and hierarchical data, organized for efficient analytic operations on modern hardware. It also provides computational libraries and zero-copy streaming messaging and interprocess communication. Languages currently supported include C, C++, Java, JavaScript, Python, and Ruby.
arvelie-format (timeFormat, appeared 2017)
Origin: https://github.com/XXIIVV
Country: Unknown
Website: https://wiki.xxiivv.com/#arvelie

The Arvelie Calendar has 26 months of 14 days each. Each month has 2 weeks of 7 days, and each month's name is one of the 26 letters of the alphabet. The 365th day of the year is the Year Day(+01), preceded by the Leap Day(+02) on leap years.



02A01  2002-01-01  01D07 2001-02-18
13B12  2013-01-26  02E07 2002-03-04
24C01  2024-01-29  03+01 2003-12-31
22D12  2022-02-23  19U07 Today
ASCII Armor (textEncodingFormat, appeared 2007)

OpenPGP provides the service of converting the raw 8-bit binary octet stream to a stream of printable ASCII characters, called Radix-64 encoding or ASCII Armor.



  -----BEGIN PGP MESSAGE-----
  Version: OpenPrivacy 0.99
  
  yDgBO22WxBHv7O8X7O/jygAEzol56iUKiXmV+XmpCtmpqQUKiQrFqclFqUDBovzS
  vBSFjNSiVHsuAA==
  =njUN
  -----END PGP MESSAGE-----
ASCII (characterEncoding, appeared 1963)
Stands for: American Standard Code for Information Interchange
Origin: American National Standards Institute
Country: United States

Started out as 7 bits. Now 8.

ASCII ( ( listen) ASS-kee), abbreviated from American Standard Code for Information Interchange, is a character encoding standard for electronic communication. ASCII codes represent text in computers, telecommunications equipment, and other devices. Most modern character-encoding schemes are based on ASCII, although they support many additional characters. ASCII is the traditional name for the encoding system; the Internet Assigned Numbers Authority (IANA) prefers the updated name US-ASCII, which clarifies that this system was developed in the US and based on the typographical symbols predominantly in use there.
AsciiDoc (textMarkup, appeared 2002)
Website: http://asciidoc.org/


AsciiDoc is a human-readable document format, semantically equivalent to DocBook XML, but using plain-text mark-up conventions.  AsciiDoc documents can be created using any text editor and read “as-is”, or rendered to HTML or any other format supported by a DocBook tool-chain, i.e. PDF, TeX, Unix manpages, e-books, slide presentations, etc.
AsciiDots (esolang, appeared 2017)
Creators: Aaron Janse
Website: http://ajanse.me/asciidots/



GitHub description: Esolang inspired by ASCII art

/-&         `` This is where the program ends!
|
\-\ /-\
  | | |
/-/ | \-\
\---/   |
        |
        \-. `` Here's where the program starts
ASIC (pl, appeared 1992)
Origin: 80/20 Software
Country: United States


ASIC is a programming language, a BASIC dialect and shareware compiler for DOS systems.  Written by Dave Visti of 80/20 Software, it achieved brief popularity in the 1990s as one of the few BASIC compilers legally available for download from BBSes.  However, ASIC understood only a small subset of the BASIC language, with most versions having little or no support for logical operators, control structures, and floating-point arithmetic.  These shortcomings are the reason for the software's tongue-in-cheek motto, "ASIC: It's almost BASIC!"Notably, however, ASIC did feature a rudimentary integrated development environment and an RS-232 communications library for writing terminal and BBS software, as well not requiring line numbers.  The last release of ASIC, version 5.00, was more compatible with GW-BASIC and offered a utility to convert GW-BASIC programs to ASIC syntax. ASIC allows compiling to a DOS EXE file or COM file. The low overhead of the COM file format lets ASIC make one of the smallest compiled executables of the Hello world program, typically 360 bytes.
Asm.js (ir, appeared 2013)
Origin: Mozilla
Website: http://asmjs.org/


asm.js is an intermediate programming language designed to allow computer software written in languages such as C to be run as web applications while maintaining performance characteristics considerably better than standard JavaScript, the typical language used for such applications. asm.js consists of a strict subset of JavaScript, into which code written in statically-typed languages with manual memory management (such as C) is translated by a source-to-source compiler such as Emscripten (based on LLVM). Performance is improved by limiting language features to those amenable to ahead-of-time optimization and other performance improvements. Mozilla Firefox was the first web browser to implement asm.js-specific optimizations, starting with version 22.
ASN.1 (idl, appeared 1984)
Origin: International Telecommunication Union
International Electrotechnical Commission
Country: United Kingdom


Abstract Syntax Notation One (ASN.1) is an interface description language for defining data structures that can be serialized and deserialized in a standard, cross-platform way. It's broadly used in telecommunications and computer networking, and especially in cryptography. Protocol developers define data structures in ASN.1 modules, which are generally a section of a broader standards document written in the ASN.1 language. Because the language is both human-readable and machine-readable, modules can be automatically turned into libraries that process their data structures, using an ASN.1 compiler. ASN.1 is similar in purpose and use to protocol buffers and Apache Thrift, which are also interface description languages for cross-platform data serialization. Like those languages, it has a schema (in ASN.1, called a "module"), and a set of encodings, typically type-length-value encodings. However, ASN.1, defined in 1984, predates them by many years. It also includes a wider variety of basic data types, some of which are obsolete, and has more options for extensibility. A single ASN.1 message can include data from multiple modules defined in multiple standards, even standards defined years apart.


FooProtocol DEFINITIONS ::= BEGIN

    FooQuestion ::= SEQUENCE {
        trackingNumber INTEGER,
        question       IA5String
    }

    FooAnswer ::= SEQUENCE {
        questionNumber INTEGER,
        answer         BOOLEAN
    }

END
AspectJ (pl, appeared 2001)
Origin: Eclipse Foundation
Country: Canada
Website: http://www.eclipse.org/aspectj/
File extensions: aj


AspectJ is an aspect-oriented programming (AOP) extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become a widely used de facto standard for AOP by emphasizing simplicity and usability for end users. It uses Java-like syntax, and included IDE integrations for displaying crosscutting structure since its initial public release in 2001.
Assembly language (assembly, appeared 1960)
Also known as: assembly


An assembly (or assembler) language, often abbreviated asm, is any low-level programming language in which there is a very strong correspondence between the program's statements and the architecture's machine code instructions.Each assembly language is specific to a particular computer architecture and operating system. In contrast, most high-level programming languages are generally portable across multiple architectures but require interpreting or compiling. Assembly language may also be called symbolic machine code.Assembly language usually has one statement per machine instruction, but assembler directives, macros and symbolic labels of program and memory locations are often also supported. Assembly code is converted into executable machine code by a utility program referred to as an assembler. The conversion process is referred to as assembly, or assembling the source code.
AssemblyScript (pl, appeared 2017)
Origin: The AssemblyScript Project
Country: Ukraine and Germany
Website: https://assemblyscript.org



GitHub description: A TypeScript-like language for WebAssembly.

/** Calculates the n-th Fibonacci number. */
export function fib(n: i32): i32 {
  var a = 0, b = 1
  if (n > 0) {
    while (--n) {
      let t = a + b
      a = b
      b = t
    }
    return b
  }
  return a
}
Astatine (pl, appeared 2022)
Creators: Spydr06
Origin: https://github.com/Spydr06
Country: Germany
Website: https://github.com/Spydr06/astatine/



GitHub description: Astatine is a is a mid-level, statically typed, procedural programming language with some functional components.

module Main where
import * from IO
-- prints 'Hello, World' to stdout
main :: (args [String]) -> Int32
    = do
        IO::puts("Hello, World")
        0
    end
Asterisk (application, appeared 1999)
Origin: Sangoma Technologies Corporation
Country: United States
Website: https://wiki.asterisk.org/wiki/display/AST/Dialplan


Asterisk is a software implementation of a telephone private branch exchange (PBX); it allows attached telephones to make calls to one another, and to connect to other telephone services, such as the public switched telephone network (PSTN) and Voice over Internet Protocol (VoIP) services. Its name comes from the asterisk symbol "*". Asterisk is released with a dual license model, using the GNU General Public License (GPL) as a free software license and a proprietary software license to permit licensees to distribute proprietary, unpublished system components. Asterisk was created in 1999 by Mark Spencer of Digium. Originally designed for Linux, Asterisk runs on a variety of operating systems, including NetBSD, OpenBSD, FreeBSD, macOS, and Solaris, and can be installed in embedded systems based on OpenWrt and on flash drives.
Asymptote (application, appeared 2004)
Creators: Andy Hammerlindl
John C. Bowman
Tom Prince
Origin: University of Alberta
Country: Canada


Asymptote is a descriptive vector graphics language — developed by Andy Hammerlindl, John C. Bowman (University of Alberta), and Tom Prince — which provides a natural coordinate-based framework for technical drawing. Asymptote runs on all major platforms (Unix, Mac OS, Microsoft Windows). It is free software, available under the terms of the GNU Lesser General Public License (LGPL).
Atari BASIC (pl, appeared 1983)
Origin: Shepardson Microsystems
Country: United States


Atari BASIC is an interpreter for the BASIC programming language that shipped with the Atari 8-bit family of 6502-based home computers. Unlike most 8-bit BASICs, Atari BASIC is not a derivative of Microsoft BASIC, and differs in significant ways. It includes keywords for Atari-specific features and lacks support for string arrays, for example. The language was originally an 8 KB ROM cartridge for the first machines in the 8-bit series, the 400, 800 and 1200XL. Starting with the 600XL and 800XL, BASIC was built-in to the machines, but can be disabled by holding down the OPTION key while booting. The XEGS disables BASIC if powered without the keyboard attached. The complete annotated source code and design specifications of Atari BASIC were published as The Atari BASIC Source Book in 1983.
Atari Microsoft BASIC (pl, appeared 1981)
Origin: Microsoft


The Atari Microsoft BASIC and Atari Microsoft BASIC II variants of the BASIC programming language were ROM cartridge or floppy disk packaged versions of the Microsoft BASIC dialect ported to the Atari 8-bit machines. Atari originally licensed Microsoft BASIC for use in their 8-bit computers, but were unable to fit it in an 8 KB ROM cartridge, the largest cartridge size available at the time. They outsourced to another company, Shepardson Microsystems Inc. (SMI), who had similar problems fitting the language onto an 8k cartridge. SMI proposed creating an entirely new version of BASIC for the new platforms, and built Atari BASIC instead. Atari Microsoft BASIC, unlike Atari BASIC, didn't allow abbreviations for keywords; keywords had to be fully spelled out. Syntax checking occurred after running a program, not immediately after entering the line. Also, arithmetic operations with integers resulted in an integer result.  Atari Microsoft BASIC came in two packages:  Floppy disk – CX8126 ROM cartridge – RX8035. Since the cartridge could only hold 16 KB, the remaining 11 KB file was included on an "extension" disk. The cartridge version was called Atari Microsoft BASIC II.Although more feature filled than Atari BASIC, Microsoft BASIC never had the popularity that Atari BASIC had. The biggest problems were:  increased memory needed (at least 32 KB) disk drive required performance (faster than Atari BASIC, but slower than Turbo-Basic XL and BASIC XL) not compatible with Atari BASIC added costThe cartridge version eliminated the first two requirements, but a disk drive was needed for all of its features.
Atari ST BASIC (pl, appeared 1985)
Origin: MetaComCo
Country: England


Atari ST BASIC (or ST Basic) was the first dialect of BASIC that was produced for the Atari ST line of computers. It was bundled with all new STs in the early years of the ST's lifespan, and quickly became the standard BASIC for that platform. However, many users disliked it, and improved dialects of BASIC quickly came out to replace it.
ATLAS Transformation Language (pl, appeared 2005)
Origin: Eclipse Foundation
Country: Canada
Website: https://www.eclipse.org/atl/
File extensions: atl


ATL (ATLAS Transformation Language) is a model transformation language and toolkit developed and maintained by OBEO and AtlanMod. It was initiated by the AtlanMod team (previously called ATLAS Group). In the field of Model-Driven Engineering (MDE), ATL provides ways to produce a set of target models from a set of source models. Released under the terms of the Eclipse Public License, ATL is an M2M (Eclipse) component, inside of the Eclipse Modeling Project (EMP).


rule TreeNodeRoot2RootElement {
 from
   rt : MMTree!Node (rt.isTreeNodeRoot()) 
 to
   lstRt : MMElementList!RootElement (
     name <- rt.name,
     elements <- elmLst
   ),
   elmLst : distinct MMElementList!CommonElement foreach(leaf in rt.getAllChildren())(
     name <- leaf.name
   )
}
Atmel AVR (pl, appeared 1996)
Origin: Norwegian Institute of Technology
Country: Norway


AVR is a family of microcontrollers developed since 1996 by Atmel, acquired by Microchip Technology in 2016. These are modified Harvard architecture 8-bit RISC single-chip microcontrollers. AVR was one of the first microcontroller families to use on-chip flash memory for program storage, as opposed to one-time programmable ROM, EPROM, or EEPROM used by other microcontrollers at the time. AVR microcontrollers find many applications as embedded systems. They are especially common in hobbyist and educational embedded applications, popularized by their inclusion in many of the Arduino line of open hardware development boards.
Atomese (pl, appeared 2007)
Origin: OpenCog Foundation
Country: Various
Website: https://wiki.opencog.org/w/Atomese

Atomese was originally intended to be a language for knowledge representation (KR): that is, a way of encoding facts and hypothesis, in a machine-readable way, such that the knowledge can be manipulated, data-mined, reasoned with. This language subset was vaguely inspired by Prolog and Datalog. More correctly, it was constructed by layering concepts from mathematical logic onto a graph database: representing logical, symbolic statements as graphs.



(define find-animals
  (BindLink
    ;; The variable to be bound
    (VariableNode "$var")
    ;; The pattern to be searched for
    (InheritanceLink
       (VariableNode "$var")
       (ConceptNode "animal")
    )
    ;; The value to be returned.
    (VariableNode "$var")
  )
)
 
;; Run the above pattern
(cog-bind find-animals)
ATS (pl, appeared 2013)
Also known as: ATS/Postiats
Postiats
Stands for: Applied Type System
Creators: Hongwei Xi
Origin: Boston University
Country: United States
Website: http://www.ats-lang.org/
Keywords: abstype
abst0ype
absprop
absview
absvtype
absviewtype
absvt0ype
absviewt0ype
as
and
assume
begin
classdec
datasort
datatype
dataprop
dataview
datavtype
dataviewtype
do
end
extern
extype
extvar
exception
fn
fnx
fun
prfn
prfun
praxi
castfn
if
then
else
ifcase
in
infix
infixl
infixr
prefix
postfix
implmnt
implement
primplmnt
primplement
import
let
local
macdef
macrodef
nonfix
symelim
symintr
overload
of
op
rec
sif
scase
sortdef
sta
stacst
stadef
static
staload
dynload
try
tkindef
typedef
propdef
viewdef
vtypedef
viewtypedef
prval
var
prvar
when
where
with
withtype
withprop
withview
withvtype
withviewtype


ATS (Applied Type System) is a programming language designed to unify programming with formal specification. ATS has support for combining theorem proving with practical programming through the use of advanced type systems. A past version of The Computer Language Benchmarks Game has demonstrated that the performance of ATS is comparable to that of the C and C++ programming languages. By using theorem proving and strict type checking, the compiler can detect and prove that its implemented functions are not susceptible to bugs such as division by zero, memory leaks, buffer overflow, and other forms of memory corruption by verifying pointer arithmetic and reference counting before the program compiles. Additionally, by using the integrated theorem-proving system of ATS (ATS/LF), the programmer may make use of static constructs that are intertwined with the operative code to prove that a function attains its specification.
Augeas (pl, appeared 2007)
Origin: Red Hat Software
Country: United States
Website: http://augeas.net/


Augeas is a free software  configuration-management library, written in the C programming language.  It is licensed under the terms of the GNU Lesser General Public License. Augeas uses programs called  lenses (in reference to the Harmony Project) to map a filesystem to an XML tree which can then be parsed using an XPath syntax, using a bidirectional transformation. Writing such lenses extends the amount of files Augeas can parse.
AUI (pl, appeared 2002)
Origin: University of Saskatchewan
Queen's University
Country: Canada


AUI may stand for:  Ethernet's Attachment Unit Interface, a 15-pin D-connector The constructed language aUI (language) The National Rail code for Ardlui railway station, United Kingdom Associated Universities, Inc., the corporation that operates the National Radio Astronomy Observatory (NRAO) Amiga User International, a monthly magazine dedicated to the Amiga computer Al Akhawayn University,  a university located in Ifrane, Morocco Adaptive user interface Audible user interface, for blind people to use digital devices Attentive user interface
Austral (pl, appeared 2018)
Creators: Fernando Borretti
Origin: https://github.com/austral/
Country: Unknown
Website: https://austral-lang.org/

Austral is a new systems programming language. You can think of it as Rust: The Good Parts or a modernized, stripped-down Ada. It features a strong static type system, linear types, capability-based security, and strong modularity.


GitHub description: Systems language with linear types and capability-based security.

let db: Db := connect("localhost");
close(db);
-- The below is tuple destructuring notation.
let { first as db1: Db, second: Rows } := query(db, "SELECT ...");
close(db); -- error: `db` consumed again.
-- another error: `db1` never consumed.
AUTOCAD (application, appeared 1982)
Origin: Autodesk
Country: United States


AutoCAD is a commercial computer-aided design (CAD) and drafting software application. Developed and marketed by Autodesk, AutoCAD was first released in December 1982 as a desktop app running on microcomputers with internal graphics controllers. Before AutoCAD was introduced, most commercial CAD programs ran on mainframe computers or minicomputers, with each CAD operator (user) working at a separate graphics terminal. Since 2010, AutoCAD was released as a mobile- and web app as well, marketed as AutoCAD 360. AutoCAD is used across a wide range of industries, by architects, project managers, engineers, graphic designers, town planners and many other professionals. It was supported by 750 training centers worldwide in 1994.
Autocode (pl, appeared 1954)
Origin: University of Manchester
University of Cambridge
University of London
Country: England


Autocode is the name of a family of "simplified coding systems", later called programming languages, devised in the 1950s and 1960s for a series of  digital computers at the Universities of Manchester, Cambridge and London. Autocode was a generic term; the autocodes for different machines were not necessarily closely related as are, for example, the different versions of the single language FORTRAN. Today the term is used to refer to the family of early languages descended from the Manchester Mark 1 autocoder systems, which were generally similar. In the 1960s, the term autocoders was used more generically as to refer to any high-level programming language using a compiler.  Examples of languages referred to as autocodes are COBOL and Fortran.