pldb/PLDB huggingface dataset:
Crystallographic Information File (textDataFormat, appeared 1991)
Origin: International Union of Crystallography
Country: United Kingdom and Germany


Crystallographic Information File (CIF) is a standard text file format for representing crystallographic information, promulgated by the International Union of Crystallography (IUCr). CIF was developed by the IUCr Working Party on Crystallographic Information in an effort sponsored by the IUCr Commission on Crystallographic Data and the IUCr Commission on Journals. The file format was initially published by Hall, Allen, and Brown and has since been revised, most recently version 1.1. Full specifications for the format are available at the IUCr website. Many computer programs for molecular viewing are compatible with this format, including Jmol.  Closely related is mmCIF, macromolecular CIF, which is intended as an alternative to the Protein Data Bank (PDB) format. Also closely related is Crystallographic Information Framework, a broader system of exchange protocols based on data dictionaries and relational rules expressible in different machine-readable manifestations, including, but not restricted to, Crystallographic Information File and XML.
CIL (pl, appeared 2000)
Also known as: Microsoft Intermediate Language MSIL
Stands for: Common Intermediate Language
Origin: Microsoft


Common Intermediate Language (CIL, pronounced either sil or kil), formerly called Microsoft Intermediate Language (MSIL), is the lowest-level human-readable programming language defined by the Common Language Infrastructure (CLI) specification and is used by the .NET Framework and Mono. Languages which target a CLI-compatible runtime environment compile to CIL, which is assembled into an object code that has a bytecode-style format. CIL is an object-oriented assembly language, and is entirely stack-based. Its bytecode is translated into native code or—most commonly—executed by a virtual machine. CIL was originally known as Microsoft Intermediate Language (MSIL) during the beta releases of the .NET languages. Due to standardization of C# and the Common Language Infrastructure, the bytecode is now officially known as CIL.


.assembly Hello {}
.assembly extern mscorlib {}
.method static void Main()
{
    .entrypoint
    .maxstack 1
    ldstr "Hello, world!"
    call void [mscorlib]System.Console::WriteLine(string)
    ret
}
CIL (pl, appeared 1994)
Origin: Intel
Country: United States
Website: http://www.cilk.com/


Cilk, Cilk++ and Cilk Plus are general-purpose programming languages designed for multithreaded parallel computing. They are based on the C and C++ programming languages, which they extend with constructs to express parallel loops and the fork–join idiom. Originally developed in the 1990s at the Massachusetts Institute of Technology (MIT) in the group of Charles E. Leiserson, Cilk was later commercialized as Cilk++ by a spinoff company, Cilk Arts. That company was subsequently acquired by Intel, which increased compatibility with existing C and C++ code, calling the result Cilk Plus.
cimfast (pl, appeared 1991)
Origin: DEC
Country: United States
File extensions: cel

CIMfast was an event driven language for "computer integrated manufacturing", developed in the early 1990's. It was high level language used to control BaseStar. BaseStar was a software library for manufacturing support (basically it was messaging middleware, nothing specific for any kind of industry),  developed and sold by DEC. It had C API. CIMfast was language intended to replace the need for low level C. CIMfast controlled manufacturing line was deployed by Fiat.
CIR (ir, appeared 2020)
Stands for: Clang IR
Origin: Engineering at Meta
Country: United States
Website: https://facebookincubator.github.io/clangir/

Clang IR (CIR) is a new IR for Clang.


GitHub description: A new high-level IR for clang.

// Read from local variable, address in %0.
%1 = cir.load %0 : !cir.ptr<i32>, i32

// Load address from memory at address %0. %3 is used by at least one
// operation that dereferences a pointer.
%3 = cir.load deref %0 : cir.ptr <!cir.ptr<i32>>
Ć (pl, appeared 2011)
Creators: Piotr Fusik
Origin: http://fusik.info/piotr/
Country: Unknown
Website: https://github.com/pfusik/cito

Ć programming language. Translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C.


GitHub description: Ć programming language. Translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C.

public class HelloCi
{
    public static string GetMessage()
    {
        return "Hello, world!";
    }
}
CLAIRE (pl, appeared 2004)
Creators: Yves Caseau
Origin: Bouygues' e-Lab research laboratory
Country: France


Claire is a high-level functional and object-oriented programming language with rule processing abilities. It was designed by Yves Caseau at Bouygues' e-Lab research laboratory, and received its final definition in 2004. Claire provides:  a simple object system with parametric classes and methods polymorphic and parametric functional programming production rules triggered by events versioned snapshots of the state of the whole system, or any part, supporting rollback and easy exploration of search spaces explicit relations between entities; for example, two entities might be declared inverses of one another first-class sets with convenient syntax for set-based programming an expressive set-based type system allowing both second-order static and dynamic typingClaire's reference implementation, consisting of an interpreter and compiler, was fully open-sourced with the release of version 3.3.46 in February 2009. Another implementation, WebClaire, is commercially supported.
Clarion (pl, appeared 1986)
Origin: Jensen & Partners International
Clarion International
SoftVelocity
Country: United States
Website: http://www.softvelocity.com


Clarion is a commercial, 4GL, multi-paradigm, programming language and Integrated Development Environment from SoftVelocity used to program database applications. It is compatible with ISAM, SQL and ADO data access methods, reads and writes several flat file desktop database formats including ASCII, CSV, DOS (Binary), FoxPro, Clipper, dBase, and some relational databases via ODBC, MS SQL Server, Sybase SQL Anywhere and Oracle through the use of accelerated native database drivers, and XML, Clarion can be used to output to HTML, XML, plaintext, and PDF, among others. The Clarion Development Environment (IDE) sits on top of the Clarion Programming Language. The IDE provides code generation facilities via a system of templates which allow programmers to describe the program from an abstract level higher than actual code statements. The generator then turns this higher level into code, which in turn is then compiled and linked using a normal compiler and linker. This generation layer is sometimes referred to as 4GL programming. The generation layer is not required. It is possible to create programs completely at the code level (the so-called 3GL layer), bypassing all the code generation facilities. If the templates are used to generate code then programmers are able to inject their own code into the generated code to alter, or extend, the functionality offered by the template layer. This process of embedding code can be done while viewing the surrounding generated code. This mixing of template code and generated code allows the template settings to be updated, and the code regenerated, without the loss of the embedded code. The templates (from which the code is generated) are provided in source form and developers are free to create their own templates. A large collection of templates have been written by various developers some of which are offered as commercial add-ons and some of which are free. There are several Clarion products available; Clarion Professional Edition, Clarion Enterprise Edition and Clarion.Net.
Clausal Language (pl, appeared 1997)
Also known as: cl
Origin: Comenius University Bratislava
Country: Slovakia
Website: http://ii.fmph.uniba.sk/cl/view.php/

CL (Clausal Language) is a declarative programming language with the look and feel of a modern functional programming language. CL identifies the domain of symbolic expressions of LISP with the domain of natural numbers.
clay (pl, appeared 2010)
Creators: KS Sreeram
Joe Groff
Origin: https://claylabs.com/
Country: Various
Website: http://claylabs.com/clay



GitHub description: The Clay programming language

import printer.(println);

factorial1(n) {
    if (n == 0)
        return 1;
    return n*factorial1(n-1);
}

factorial2(n) {
    var p = 1;
    again :
    if (n == 0)
        return p;
    p *: n;
    n -: 1;
    goto again;
}

factorial3(n) {
    var p = 1;
    while (true) {
        if (n == 0) break;
        p *: n;
        n -: 1;
    }
    return p;
}

factorial4(n) {
    var p = 1;
    for (i in range(n))
        p *: i+1;
    return p;
}

main() {
    var n = 7;
    n -: 1;
    var f = factorial4(n);
    println("factorial(", n, ") = ", f);
    return 0;
}
Clean (pl, appeared 1987)
Origin: Radboud University Nijmegen
Country: Netherlands
Website: http://clean.cs.ru.nl
File extensions: icl
dcl
abc
sapl
Keywords: case
ccall
class
code
code
inline
derive
export
foreign
generic
if
in
infix
infixl
infixr
instance
let
of
otherwise
special
stdcall
where
with


Clean is a general-purpose purely functional computer programming language. For much of the language's active development history it was called Concurrent Clean, but this was dropped at some point.
Assembly CLI (library, appeared 2005)
Also known as: cli
Origin: Microsoft
Country: United States


Defined by Microsoft for use in recent versions of Windows, an assembly in the Common Language Infrastructure (CLI) is a compiled code library used for deployment, versioning, and security. There are two types: process assemblies (EXE) and library assemblies (DLL). A process assembly represents a process that will use classes defined in library assemblies. CLI assemblies contain code in CIL, which is usually generated from a CLI language, and then compiled into machine language at run time by the just-in-time compiler. In the .NET Framework implementation, this compiler is part of the Common Language Runtime (CLR). An assembly can consist of one or more files. Code files are called modules. An assembly can contain more than one code module. And since it is possible to use different languages to create code modules, it is technically possible to use several different languages to create an assembly. Visual Studio however does not support using different languages in one assembly.
CLIPS (pl, appeared 1985)
Stands for: C Language Integrated Production System
Origin: NASA
Country: United States
Website: http://www.clipsrules.net/


CLIPS is a public domain software tool for building expert systems.  The name is an acronym for "C Language Integrated Production System." The syntax and name was inspired by Charles Forgy's OPS ("Official Production System," although there was nothing really official about it). The first versions of CLIPS were developed starting in 1985 at NASA-Johnson Space Center (as an alternative for existing system ART*Inference) until the mid-1990s when the development group's responsibilities ceased to focus on expert system technology. The original name of the project was NASA's AI Language (NAIL). CLIPS is probably the most widely used expert system tool. CLIPS incorporates a complete object-oriented language (hence the acronym COOL) for writing expert systems. CLIPS itself is written in C, extensions can be written in C, and CLIPS can be called from C. Its user interface closely resembles that of the programming language Lisp. COOL combines the programming paradigms of procedural, object oriented and logical (theorem proving) languages.


 (deftemplate car_problem
     (slot name)
     (slot status))

 (deffacts trouble_shooting
     (car_problem (name ignition_key) (status on))
     (car_problem (name engine) (status wont_start))
     (car_problem (name headlights) (status work)))

 (defrule rule1
     (car_problem (name ignition_key) (status on))
     (car_problem (name engine) (status wont_start))
      =>
     (assert (car_problem (name starter) (status faulty))))
CLISP (pl, appeared 1973)
Origin: Xerox PARC
Country: United States


In computing, CLISP is an implementation of the programming language Common Lisp originally developed by Bruno Haible and Michael Stoll for the Atari ST. Today it supports the Unix and Microsoft Windows  operating systems. CLISP includes an interpreter, a bytecode compiler, debugger, socket interface, high-level foreign language interface, strong internationalization support, and two object systems: Common Lisp Object System (CLOS) and metaobject protocol (MOP). It is written in C and Common Lisp. It is now part of the GNU Project and is free software, available under the terms of the GNU General Public License (GPL).
CLIST (pl, appeared 1990)
Origin: IBM
Country: United States


CLIST (Command List) (pronounced "C-List") is a procedural programming language for TSO in MVS systems. It originated in OS/360 Release 20 and has assumed a secondary role since the availability of Rexx in TSO/E Version 2. The term CLIST is also used for command lists written by users of NetView.In its basic form, a CLIST program (or "CLIST" for short) can take the form of a simple list of commands to be executed in strict sequence (like a DOS batch file (*.bat) file).  However, CLIST also features If-Then-Else logic as well as loop constructs. CLIST is an interpreted language.  That is, the computer must translate a CLIST every time the program is executed.  CLISTs therefore tend to be slower than programs written in compiled languages such as COBOL, FORTRAN, or PL/1.  (A program written in a compiled language is translated once to create a "load module" or executable.) CLIST can read/write MVS files and read/write from/to a TSO terminal. It can read parameters from the caller and also features a function to hold global variables and pass them between CLISTs. A CLIST can also call an MVS application program (written in COBOL or  PL/I, for example). CLISTs can be run in background (by running JCL which executes the TSO control program (IKJEFT01)). TSO I/O screens and menus using ISPF dialog services can be displayed by CLISTs. Compare the function of CLIST with that provided by REXX.
CLiX markup (xmlFormat, appeared 1998)
Origin: University College London
Country: England
Website: http://www.clixml.org/

CLiX is a constraint language based on first order logic. It was first specified in 1998, when XML was not yet ubiquitous, in research at University College London. The language has since been developed and taken forward by Systemwire Ltd., a spin-off company that provides rule-based validation products around CLiX. Even though a commercial implementation is available, the language specification is published, and free for anybody to implement. It is hosted at http://www.clixml.org.

Constraint Language in XML (CLiX) used to constrain the content of XML documents. It is based on first order logic and XPath, and its purpose is to enable the specification of constraints on the structure and content of XML documents. CLiX constraints can be used both to constraint documents internally and to execute inter-document checks between a number of documents.  The goal of CLiX is to enable users and developers to express business properties and complex constraints that cannot be handled in traditional schema languages, and to automate checks that would otherwise have to be hard-coded.


<forall var="dates" in="//fpml:calculationPeriodDates>
  <less op1="$dates/fpml:effectiveDate/fpml:unadjustedDate" 
        op2="$dates/fpml:terminationDate/fpml:unadjustedDate"/>
</forall>
Clojure (pl, appeared 2007)
Creators: Rich Hickey
Origin: Cognitect, Inc
Country: United States
Website: https://clojure.org
File extensions: clj
cljs
cljc
edn


Clojure ( , like "closure") is a dialect of the Lisp programming language. Clojure is a general-purpose programming language with an emphasis on functional programming. It runs on the Java virtual machine and the Common Language Runtime. Like other Lisps, Clojure treats code as data and has a macro system. The current development process is community-driven, overseen by Rich Hickey as its benevolent dictator for life (BDFL). Clojure encourages immutability and immutable data structures. While its type system is entirely dynamic, recent efforts have also sought the implementation of gradual typing. Clojure encourages programmers to be explicit about managing state and identity. This focus on programming with immutable values and explicit progression-of-time constructs is intended to facilitate developing more robust programs, especially multithreaded ones. Clojure is used in industry by firms such as Funding Circle, Walmart, Puppet, and other large software firms. Commercial support for Clojure is provided by Cognitect. Annual Clojure conferences are organised every year across the globe, the most famous of them being Clojure/conj (US east coast), Clojure/West (US west coast), and EuroClojure (Europe). The latest stable version of Clojure is 1.8, released on January 19, 2016. The first stable release was version 1.0, released on May 4, 2009. Clojure is free software released under the Eclipse Public License.

GitHub description: The Clojure programming language
CLOS (pl, appeared 1988)


The Common Lisp Object System (CLOS) is the facility for object-oriented programming which is part of ANSI Common Lisp. CLOS is a powerful dynamic object system which differs radically from the OOP facilities found in more static languages such as C++ or Java. CLOS was inspired by earlier Lisp object systems such as MIT Flavors and CommonLoops, although it is more general than either. Originally proposed as an add-on, CLOS was adopted as part of the ANSI standard for Common Lisp and has been adapted into other Lisp dialects such as EuLisp or Emacs Lisp.
CLPR (pl, appeared 1986)
Origin: Monash University
Country: Australia


CLP(R) is a declarative programming language. It stands for constraint logic programming (Real) where real refers to the real numbers. It can be considered and is generally implemented as a superset or add-on package for a Prolog implementation.


3*X + 4*Y - 2*Z = 8,
X - 5*Y + Z = 10,
2*X + 3*Y -Z = 20.
CLU (pl, appeared 1975)
Creators: Barbara Liskov
Origin: Massachusetts Institute of Technology
Country: United States
Website: http://www.pmg.lcs.mit.edu/CLU.html


CLU is a programming language created at the Massachusetts Institute of Technology (MIT) by Barbara Liskov and her students between 1974 and 1975. While it did not find extensive use, it introduced many features that are used widely now, and is seen as a step in the development of object-oriented programming (OOP). Key contributions include abstract data types, call-by-sharing, iterators, multiple return values (a form of parallel assignment), type-safe parameterized types, and type-safe variant types. It is also notable for its use of classes with constructors and methods, but without inheritance.
CLX (pl, appeared 1985)
Origin: https://github.com/sharplispers
Country: Various


The acronym CLX can refer to a number of things:  160 in Roman numerals Cargolux, an airline using the ICAO code CLX CLX (Common Lisp), a Common Lisp computer library CLX Communications, a telecommunications and cloud communications platform as a service company, based in Stockholm, Sweden Component Library for Cross Platform (CLX), a cross-platform visual component-based framework
CMake (application, appeared 2000)
Origin: Kitware, Inc
Country: United States
Website: https://cmake.org/


CMake is cross-platform free and open-source software for managing the build process of software using a compiler-independent method. It supports directory hierarchies and applications that depend on multiple libraries. It is used in conjunction with native build environments such as make, Apple's Xcode, and Microsoft Visual Studio. It has minimal dependencies, requiring only a C++ compiler on its own build system.
CMIX (pl, appeared 1980)
Creators: Paul Lansky
Origin: Princeton University
Country: United States

CMIX is a computer music "language" designed to create and manipulate soundfiles, or files containing raw binary data which can be converted into sound on a computer equipped with an appropriate digital-to-analog convertor. It is somewhat similar to CSOUND and CMUSIC (two other popular software synthesis and signal-processing computer music packages). All three of these languages are in one way or another derived from the work done by Max Matthews and others at Bell Laboratories in the late 1950's and 1960's.
CMS-2 (pl, appeared 1968)
Creators: Vincent Cecil Secades
David Clark Rummler
Origin: Naval Postgraduate School
Country: United States


CMS-2 is an embedded systems programming language used by the United States Navy. It was an early attempt to develop a standardized high-level computer programming language intended to improve code portability and reusability. CMS-2 was developed primarily for the US Navy’s tactical data systems (NTDS).CMS-2 was developed by RAND Corporation in the early 1970s and stands for "Compiler Monitor System". The name "CMS-2" is followed in literature by a letter designating the type of target system. For example, CMS-2M targets Navy 16-bit processors, such as the AN/AYK-14.
EXEC (pl, appeared 1966)
Origin: IBM
Country: United States


CMS EXEC, or EXEC, is an interpreted, command procedure control, computer scripting language used by the CMS EXEC Processor supplied with the IBM Virtual Machine/Conversational Monitor System (VM/CMS) operating system. EXEC was written in 1966 by Stuart Madnick at MIT on the model of CTSS RUNCOM. He originally called this processor COMMAND, and it was later renamed EXEC. CMS EXEC has been superseded by EXEC 2 and REXX. All three — CMS EXEC, EXEC 2 and REXX — continue to be supported by the IBM CMS product.
CMS Pipelines (pl, appeared 1986)
Also known as: TSO Pipelines
Origin: IBM


CMS Pipelines implements the pipeline concept under the VM/CMS operating system. The programs in a pipeline operate on a sequential stream of records. A program writes records that are read by the next program in the pipeline. Any program can be combined with any other because reading and writing is done through a device independent interface.


PIPE (end ?) 
   < input txt 
 | a: locate /Hello/ 
 | insert / World!/ after
 | i: faninany
 | > newfile txt a
 ? a:
 | xlate upper
 | i:
CMU Common Lisp (pl, appeared 1980)
Also known as: cmucl
Origin: CMUCL Project
Country: United States
Website: https://www.cons.org/cmucl/


CMUCL is a free Common Lisp implementation, originally developed at Carnegie Mellon University. CMUCL runs on most Unix-like platforms, including Linux and BSD; there is an experimental Windows port as well. Steel Bank Common Lisp is derived from CMUCL. The Scieneer Common Lisp is a commercial derivative from CMUCL.
CobolScript (pl, appeared 1999)
Origin: Deskware
Country: United States
Website: https://web.archive.org/web/20010402110850/http://deskware.com/


CobolScript is a programming language created by Matthew Dean and Charles Schereda of Deskware in 1999. The language was intended to provide web-enabled COBOL, and was targeted at businesses using legacy software written in that language.
Cobra (pl, appeared 2006)
Creators: Charles Esterbrook
Origin: Cobra Language LLC
Country: United States
Website: http://cobra-language.com/
File extensions: cobra


Cobra is a general-purpose, object-oriented programming language. Cobra is designed by Charles Esterbrook, and runs on the Microsoft .NET and Mono platforms. It is strongly influenced by Python, C#, Eiffel, Objective-C, and other programming languages. It supports both static and dynamic typing. It has support for unit tests and contracts. It has lambda expressions, closures, list comprehensions, and generators. Cobra is an open-source project; it was released under the MIT License on February 29, 2008. Updates are posted to the Cobra news forum with progress on features, fixes, documentation and related projects since the last update.