pldb/PLDB huggingface dataset:
Business Basic (pl, appeared 1970)
Origin: MAI Systems
Country: United States


Business Basic is a category of variants of the BASIC computer programming language which were specialised for business use on minicomputers in the 1970s and 1980s. Business Basics added indexed file access methods to the normal set of BASIC commands, and were optimised for other input/output access, especially display terminal control. The two major families of Business Basic are MAI Basic Four and Data General Business Basic.  In addition the Point 4 company, which developed the IRIS operating system, had their own version of BASIC.  The UniBASIC owned by Dynamic Concepts of Irvine is a derivative of the Point 4 BASIC. In the 1980s, Business Basics were ported from their original proprietary environments to many Unix platforms, CP/M, and to DOS. In the 1990s, some Business Basics were ported to Linux and Windows, and Business Basic integrated development environments became available.  Business Basic continues to be widely used due to the very large base of application software.
Business Object Notation (notation, appeared 1989)
Origin: Eiffel Software
Country: United States
Website: http://www.bon-method.com/index_normal.htm

The BON method for analysis and design of object-oriented software was developed 1989-93 by Jean-Marc Nerson and Kim Waldén as a means of extending the higher-level concepts of the Eiffel programming language into the realm of analysis and design aided by a graphical notation. The core idea is simplicity and well-defined semantics, since from our industrial experience we know that anything complex and/or ambiguous becomes useless in practice, and tends to be a hindrance rather than an aid to successful completion of software projects.  In this respect, BON could be viewed as the direct opposite of the widely publicized UML/RUP approach.

In software engineering, Business Object Notation (BON) is a method and graphical notation for high-level object-oriented analysis and design. The method was developed 1989–93 by Jean-Marc Nerson and Kim Waldén as a means of extending the higher-level concepts of the Eiffel programming language. It claims to be much simpler than its competition - the UML - but it didn't enjoy its commercial success.
BPML (pl, appeared 2002)
Origin: Business Modeling
Integration Domain Task Force


Business Process Modeling Language (BPML) is an XML-based language for business process modeling. It was maintained by the Business Process Management Initiative (BPMI) until June 2005 when BPMI and OMG (Object Management Group) announced the merger of their respective Business Process Management (BPM) activities to form the Business Modeling and Integration Domain Task Force (BMI DTF)[1]. It is deprecated since 2008. BPML was useful to OMG in order to enrich UML with process notation.
business-rule-language (pl, appeared 2012)
Also known as: BRL
Website: https://webfocusinfocenter.informationbuilders.com/wfappent/TLs/TL_ra/TL_rg/source/ACrg20.htm

Business Rule Language (BRL) allows IF/THEN testing on certain information available when the rules execute. Your own cancel message can be included within the rules you create by using special message variables. BRL is a non-procedural, high-level application development language that allows you to develop sophisticated programs with less effort than conventional programming languages. BRL rules consist of three parts: the rule name, which serves as a comment or description, and is not syntactically necessary to the rule; a supporting condition (antecedent) or procedure statement; and a conclusion.
Bython (pl, appeared 2016)
Country: Norway

Python with braces. Because python is awesome, but whitespace is awful.


GitHub description: Python with braces. Because python is awesome, but whitespace is awful.

def print_message(num_of_times) {
    for i in range(num_of_times) {
        print("Bython is awesome!");
    }
}

if __name__ == "__main__" {
    print_message(10);
}
C-- (pl, appeared 1997)
Creators: Simon Peyton Jones
Origin: Tufts University
Country: United States
Website: http://www.cs.tufts.edu/~nr/c--/index.html


C-- (pronounced cee minus minus) is a C-like programming language. Its creators, functional programming researchers Simon Peyton Jones and Norman Ramsey, designed it to be generated mainly by compilers for very high-level languages rather than written by human programmers. Unlike many other intermediate languages, its representation is plain ASCII text, not bytecode or another binary format.
C/AL (pl, appeared 1987)
Creators: Michael Nielsen
Origin: Microsoft
Country: United States


C/AL (Client/server Application Language) is the programming language used within C/SIDE the Client/Server Integrated Development Environment in Microsoft Dynamics NAV (Formerly known as Navision Attain). C/AL is a Database specific programming language, and is primarily used for retrieving, inserting and modifying records in a Navision database. C/AL resembles the Pascal language on which it is based. The original C/AL compiler was written by Michael Nielsen.
C∀ (pl, appeared 2018)
Stands for: C-for-all
Origin: University of Waterloo
Huawei
Country: Canada and China
Website: https://cforall.uwaterloo.ca/

C∀ (C-for-all) is an open-source project extending ISO C with modern safety and productivity features, while still ensuring backwards compatibility with C and its programmers. C∀ is designed to have an orthogonal feature-set based closely on the C programming paradigm (non-object-oriented) and these features can be added incrementally to an existing C code-base allowing programmers to learn C∀ on an as-needed basis. In many ways, C∀ is to C as Scala is to Java, providing a research vehicle for new typing and control-flow capabilities on top of a highly popular programming language allowing immediate dissemination.
C shell (pl, appeared 1978)
Origin: University of California, Berkeley
Country: United States
Website: http://mx.gw.com


The C shell (csh or the improved version, tcsh) is a Unix shell created by Bill Joy while he was a graduate student at University of California, Berkeley in the late 1970s. It has been widely distributed, beginning with the 2BSD release of the Berkeley Software Distribution (BSD) that Joy began distributing in 1978. Other early contributors to the ideas or the code were Michael Ubell, Eric Allman, Mike O'Brien and Jim Kulp. The C shell is a command processor typically run in a text window, allowing the user to type commands. The C shell can also read commands from a file, called a script. Like all Unix shells, it supports filename wildcarding, piping, here documents, command substitution, variables and control structures for condition-testing and iteration. What differentiated the C shell from others, especially in the 1980s, were its interactive features and overall style. Its new features made it easier and faster to use. The overall style of the language looked more like C and was seen as more readable. On many systems, such as Mac OS X and Red Hat Linux, csh is actually tcsh, an improved version of csh. Often one of the two files is either a hard link or a symbolic link to the other, so that either name refers to the same improved version of the C shell. On Debian and some derivatives (including Ubuntu), there are two different packages: csh and tcsh. The former is based on the original BSD version of csh and the latter is the improved tcsh. tcsh added filename and command completion and command line editing concepts borrowed from the Tenex system, which is the source of the "t". Because it only added functionality and did not change what was there, tcsh remained backward compatible with the original C shell. Though it started as a side branch from the original source tree Joy had created, tcsh is now the main branch for ongoing development. tcsh is very stable but new releases continue to appear roughly once a year, consisting mostly of minor bug fixes.
c-smile (pl, appeared 2002)
Creators: Andrew Fedoniouk
Origin: terra informatica
deeptown
Country: Unknown
Website: http://c-smile.sourceforge.net/

C-SMILE is a scripting language, which inherits it's syntax and structure from C, C++, Java(tm) and JavaScript. On hypothetical "axis of programming languages" it resides somewhere between Java(tm) and JavaScript. In the same way as in JavaScript, all variables are typeless and as in Java it is mandatory to declare variables before usage. C-SMILE has a compiler, a virtual machine running bytecodes, and a C/C++ extensible runtime. C-SMILE is intended to run in standalone or embedded mode.
c-talk (pl, appeared 1999)
Creators: Konstantin Knizhnik
Origin: Moscow State Industrial University
Country: Russia
Website: http://www.garret.ru/ctalk.html

C-Talk is interpreted scripting language with C-like syntax and dynamic type checking. Variables in C-Talk have no type. So there is no compile time type checking in C-Talk, all checking is performed at runtime. To preserve reference integrity, explicit memory deallocation is prohibited in C-Talk, unused objects are automatically deallocated by garbage collector.



CtkObject myPrimitive(int nArgs, CtkObject* args) {
    char*       s;
    ctk_integer i;
    ctk_real    r;
    CtkObject   o;
    ctkParseArguments(nArgs, args, "siro", &s, &i, &r, &o);
    ...
}
C (pl, appeared 1972)
Creators: Dennis Ritchie
Origin: Bell Labs
Country: United States
Keywords: auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while


C (, as in the letter c) is a general-purpose, imperative computer programming language, supporting structured programming, lexical variable scope and recursion, while a static type system prevents many unintended operations. By design, C provides constructs that map efficiently to typical machine instructions, and therefore it has found lasting use in applications that had formerly been coded in assembly language, including operating systems, as well as various application software for computers ranging from supercomputers to embedded systems. C was originally developed by Dennis Ritchie between 1969 and 1973 at Bell Labs, and used to re-implement the Unix operating system. It has since become one of the most widely used programming languages of all time, with C compilers from various vendors available for the majority of existing computer architectures and operating systems. C has been standardized by the American National Standards Institute (ANSI) since 1989 (see ANSI C) and subsequently by the International Organization for Standardization (ISO). C is an imperative procedural language. It was designed to be compiled using a relatively straightforward compiler, to provide low-level access to memory, to provide language constructs that map efficiently to machine instructions, and to require minimal run-time support. Despite its low-level capabilities, the language was designed to encourage cross-platform programming. A standards-compliant and portably written C program can be compiled for a very wide variety of computer platforms and operating systems with few changes to its source code. The language has become available on a very wide range of platforms, from embedded microcontrollers to supercomputers.
C3 (pl, appeared 2019)
Creators: Christoffer Lernö
Origin: The C3 Language Project
Country: Sweden
Website: http://www.c3-lang.org/
File extensions: c3
c3i

C3 is a programming language that builds on the syntax and semantics of the C language, with the goal of evolving it while still retaining familiarity for C programmers.


GitHub description: The C3 compiler.

module stack <Type>;
// Above: the parameterized type is applied to the entire module.
import std::mem;

struct Stack
{
    usize capacity;
    usize size;
    Type* elems;
}

// The type methods offers dot syntax calls,
// so this function can either be called 
// Stack.push(&my_stack, ...) or
// my_stack.push(...)
fn void Stack.push(Stack* this, Type element)
{
    if (this.capacity == this.size)
    {
        this.capacity *= 2;
        this.elems = mem::realloc(this.elems, $sizeof(Type) * this.capacity);
    }
    this.elems[this.size++] = element;
}

fn Type Stack.pop(Stack* this)
{
    assert(this.size > 0);
    return this.elems[--this.size];
}

fn bool Stack.empty(Stack* this)
{
    return !this.size;
}
CA-Realizer (pl, appeared 1992)
Origin: Within Technologies
Country: United States


CA-Realizer was a BASIC-language software development product originally developed by Within Technologies, but first commercially released by Computer Associates, as CA-Realizer 1.0 in 1992. Several versions were released, that provided a version of the BASIC programming language, a Rapid application development tool, including forms building and some powerful built-in components, that was comparable to, and competitive with Microsoft Visual Basic, in its early days.  It offered some functionality (like a fairly useful spreadsheet) and cross-platform capability. There were versions for 16-bit Windows 3.1, 32-bit Windows 95, and 32-bit IBM OS/2.  The final version was CA-Realizer 3.0, released around 1996. As MS Visual Basic 4.0, and later continued to advance in functionality, CA-Realizer was left behind, and was quietly retired from CA's product offerings in the late 1990s. In the 1996 to 1999 versions of Accpac ERP for Windows, CA Realizer was responsible for the dreaded "CarlZ Error" which would periodically hang up the software. This error disappeared in the 2000 version of the software when it under went a rewrite in C compiler.
ca65 Assembly (assembly, appeared 1998)
Origin: MU software development
Country: Germany




       Label:                          ; A label and a comment
               lda     #$20            ; A 6502 instruction plus comment
       L1:     ldx     #$20            ; Same with label
       L2:     .byte   "Hello world"   ; Label plus control command
               mymac   $20             ; Macro expansion
               MySym = 3*L1            ; Symbol definition
       MaSym   = Label                 ; Another symbol
Caché Basic (queryLanguage, appeared 1997)
Origin: InterSystems Corporation
Country: United States

Caché is a high-performance object database with several built-in general-purpose programming languages. It supports multiple processes and provides concurrency control. Each process has direct, efficient access to the data.



' RightTriangle compute area and hypotenuse of a right triangle
' this routine contains examples of Cache Basic features */
 
Sub Run() 
println "Compute the area and hypotenuse of a right triangle"
println "given the lengths of its two sides."    
println
println "First, choose a unit of measurement. " 
input "(i)nches, (f)eet, (m)iles, " _
      , "(c)entimeters, m(e)ters, (k)ilometers: ", units
println
' translate units to a full word
select case left(units, 1)
    case "i" units = "inches"
    case "f" units = "feet"
    case "m" units = "miles"
    case "c" units = "centimeters"
    case "e" units = "meters"
    case "k" units = "kilometers"
    case else units = "units"
end select
 
do
    println
    input "Length of side 1: ", side1
    if (side1) = "" then exit do
loop while IsNegative( side1 )
if (side1 = "") then exit sub
 
do
    println
    input "Length of side 2: ", side2
    if (side2) = "" then exit do
loop while IsNegative( side2 )
if (side2 = "") then exit sub
 
Compute(units, side1, side2)
end sub
 
public function IsNegative(ByVal num As %String) As %Boolean
' is num negative?
    ' check in range "1" through "9"
    if (num < chr(49)) or (num > chr(57)) then
        print "  Enter a positive number." 
        return True
    else
        print "  Accepted."
        return False
    end if
end function
 
private function Compute(ByVal units As %String, _
                         ByVal A As %Integer, _
                         ByVal B As %Integer)
' compute and display area and hypotenuse
 
area  = round((( A * B ) / 2), 2)
hypot = round(sqr(( A ^ 2 ) + ( B ^ 2 )), 2)
  
println : println
println "The area of this triangle is ", area, " square ", units, "."
println
println "The hypotenuse is ", hypot, " ", units, "."
end function
Caché ObjectScript (pl, appeared 1997)
Origin: InterSystems
Country: United States


Caché ObjectScript is a part of the Caché database system sold by InterSystems. The language is a functional superset of the ANSI-standard MUMPS programming language. Since Caché is at its core a MUMPS implementation, it can run ANSI MUMPS routines with no change. To appeal as a commercial product, Caché implements support for object-oriented programming, a macro preprocessing language, embedded SQL for ANSI-standard SQL access to M's built-in database, procedure and control blocks using C-like brace syntax, procedure-scoped variables, and relaxed whitespace syntax limitations. The language has private and public variables and globals. Global has a different meaning in this language than in most; such variables are global across routines, processes, and sessions. Thus, editing a global variable is making permanent and immediate changes to a system-universal database (which survives reboots, etc.).  The scope of a private variable is the local function, the scope of a public variable is the entire process. Variables, private and public, may be single elements or complete multi-dimensional arrays. The great majority of Caché's feature-set is inherited from the ANSI MUMPS standard.  See that article for details on how data is represented and the different ways a programmer can think about the data during development.
CAL Actor Language (pl, appeared 2001)
Origin: University of California, Berkeley
Country: United States


CAL (the Cal Actor Language) is a high-level programming language for writing (dataflow) actors, which are stateful operators that transform input streams of data objects (tokens) into output streams. CAL has been compiled to a variety of target platforms, including single-core processors, multicore processors, and programmable hardware. It has been used in several application areas, including video and processing, compression and cryptography. The MPEG Reconfigurable Video Coding (RVC) working group has adopted CAL as part of their standardization efforts.
Calc4 (pl, appeared 2018)
Creators: Yuya Watari
Origin: https://github.com/proprowataya
Country: Japan
Website: https://github.com/proprowataya/calc4

Calc4 is a programming language where everything in its code is an operator.


GitHub description: The Calc4 Programming Language - Every code element is an operator, allowing programming in the style of a calculator

[fib2|x, a, b|x ? ((x-1) ? ((x-1) {fib2} (a+b) {fib2}a) ? a) ? b] 38{fib2}1{fib2}0
Cali-Lang (pl, appeared 2015)
Origin: https://github.com/cali-lang
Country: Unknown
Website: https://web.archive.org/web/20160820093952/http://cali-lang.com/

Cali is an object oriented interpreted programming language written in Java. It is an efficiency (glue) language that is loosely typed. Cali has it's own standard library but anyone can create external Java modules to extend Cali. In fact, the entire standard library was written by wrapping Java code.


GitHub description: Base implementation of Cali interpreter.

include console;
include net.rpc;
include rpcDemoObj;        // Include demo object.
class rpcDemoServer : rpcServer
{
    public main(args)
    {
        rd = new rpcDemoServer();
        console
            .println('Starting up rpcDemoServer on localhost:9090')
            .println('Hit ctrl-c to kill the server.')
            .println('Waiting for calls ...\n')
        ;
        rd.start();
    }
    cart = [];
    public rpcDemoServer()
    {
        this    // Hosted methods
            .add('addToCart')
            .add('getCart')
        ;
    }
    public addToCart(object Item)
    {
        if(Item instanceof 'rpcDemoObj')
        {
            console.println("Adding item '" + Item.getModelName() + "' to cart.");
            this.cart @= Item;
            return true;
        }
        else { throw "Unexpected object found."; }
    }
    public getCart()
    {
        console.println('Returning shopping cart.');
        return this.cart;
    }
}
Caltech Intermediate Form (pl, appeared 1980)
Origin: California Institute of Technology
Country: United States


Caltech Intermediate Form (CIF) is a file format for describing integrated circuits. CIF provides a limited set of graphics primitives that are useful for describing the two-dimensional shapes on the different layers of a chip. The format allows hierarchical description, which makes the representation concise. In addition, it is a terse but human-readable text format.
Content Assembly Mechanism (xmlFormat, appeared 2002)
Origin: OASIS Content Assembly Technical Committee
Country: United States


Content Assembly Mechanism (CAM) is an XML-based standard for creating and managing information exchanges that are interoperable and deterministic descriptions of machine-processable information content flows into and out of XML structures. CAM is a product of the OASIS Content Assembly Technical Committee. The CAM approach aligns with the National Information Exchange Model (NIEM) approach and assists with producing Information Exchange Package Documentation (IEPD). The camprocessor tools enable creation of realistic XML examples from XSD schema structure definitions. These XML samples simulate test cases for use in interoperability testing and determination of templates for use in actual business information exchanges. The single most important problem that CAM is solving is simpler and more reliable interoperability for business information exchanges. Today's electronic commerce via the internet is extremely limited in the amount of automation or integration that is occurring. The ability to share accurate concise and verifiable information exchange definitions is a critical next step in enabling easier and cheaper global commerce. CAM is emerging as the definitive standard underlying effective management of information exchanges through the critical mass being generated by the open source solution.A broad range of OASIS standard definitions are now being documented, validated and enhanced using the CAM open source toolset and approach. To date these include EDXL, CIQ, and EML. CAM use is also extending to external industry groups such as PESC, MISMO, STAR Automotive, CAQH and then for government uses including stratML, LEXS and NIEM. Each group faces the same challenges in promoting localizations of their overall standards in ways that can be quickly verified and adopted. Using CAM they are able to take their existing XSD schema work and rapidly develop localization templates, XML test cases, new subset schemas for use with web services and create re-usable want lists and content hints. In addition CAM templates are used to build domain dictionaries directly from the XSD schema definitions and then produce cross-reference spreadsheets for individual templates to the master dictionary definitions. All these capabilities are aimed at improving the quality and speed of implementation and interoperability using business information exchanges based on XML.


<CAM CAMlevel="1" version="1.1">
<Header/>
<AssemblyStructure/>
<BusinessUseContext/>
<Extension/> <!-- Optional, repeatable -->
</CAM>
Cambridge Algebra System (pl, appeared 1973)
Origin: Cambridge University
Country: England


Cambridge Algebra System (CAMAL) is a computer algebra system written in Cambridge University by David Barton, Steve Bourne, and John Fitch. It was initially used for computations in celestial mechanics and general relativity. The foundation code was written in Titan computer assembler,.  In 1973, when Titan was replaced with an IBM370/85, it was rewritten in ALGOL 68C and then BCPL where it could run on IBM mainframes and assorted microcomputers.