pldb/PLDB huggingface dataset:
concept-script (notation, appeared 1879)
Creators: Gottlob Frege

Frege initiated an ambitious program to use a precise notation which would help in the rigorous development of mathematics. Although his efforts were almost entirely focused on the natural numbers, he discussed possible applications to geometry, analysis, mechanics, physics of motion, and philosophy. The precise notation of Frege was introduced in Concept Script (Begriffschrift) in 1879. This was a two-dimensional notation whose powers he compared to a microscope. The framework in which he set up his Concept Script was quite simple -- we live in a world of objects and concepts, and we deal with statements about these in a manner subject to the laws of logic. Thus Frege had only one model in mind, the real world. Let us refer to this as the absolute universe. From this he was going to distill the numbers and their properties. The absolute universe approach to mathematics via logic was dominant until 1930 -- we see it in the work of Whitehead and Russell (1910-1913). His formal system with two-dimensional notation had the universal quantifier, negation, implication, predicates of several variables, axioms for logic, and rules of inference. The explicit universal quantifier, predicates of several variables and the rules of inference were new to formal systems!
Conceptual (pl, appeared 2019)
Also known as: Antipurity
Origin: https://github.com/Antipurity/conceptual
Country: Unknown
Website: https://github.com/Antipurity/conceptual

The Conceptual language aims to completely separate all features and quirks of programming and bring them to the realm of concepts, bridging machines and minds. This language is not a goal in itself, but a platform for the future; understanding this future allows to put its features into their proper context.


GitHub description: An experimental programming language / IDE of evil.

concept
(
map
txt	'(examples F): Returns examples of usage of a function, in `(… (CodeString BecomesString) …)` format.
(examples): Returns all available examples in a (… (Name … (CodeString BecomesString) …) …) format.'
call	(_jsEval "function(f) {
  if (_isArray(f)) return error
  if (f === undefined) {
    // Accumulate all examples (from parse.ctx).
    const result = [map]
    parse.ctx.forEach((v,k) => {
      if (k[0] === '_') return
      const r = _getDataOverride(v, examples)
      if (r !== undefined)
        result.push(v, r)
    })
    return result
  } else
    return _checkOverride(f, examples, f)
}"
concurnas (pl, appeared 2018)
Origin: https://github.com/Concurnas
Country: England
Website: http://concurnas.com/




def gcd(x int, y int){//greatest common divisor of two integers
  while(y){
    (x, y) = (y, x mod y)
  }
  x
}
calc1 = gcd(8, 20)!//run this calculation in a isolate
calc2 = gcd(6, 45)!//run this calculation in a separate isolate
calc3 = calc1 if calc1 > calc2 else calc2
//^^^ wait for the results of calc1 and calc2 before assigning calc3
Concurrent METATEM (pl, appeared 1993)
Origin: Manchester Metropolitan University
Country: United Kingdom


Concurrent MetateM is a multi-agent language in which each agent is programmed using a set of (augmented) temporal logic specifications of the behaviour it should exhibit. These specifications are executed directly to generate the behaviour of the agent. As a result, there is no risk of invalidating the logic as with systems where logical specification must first be translated to a lower-level implementation. The root of the MetateM concept is Gabbay's separation theorem; any arbitrary temporal logic formula can be rewritten in a logically equivalent past → future form. Execution proceeds by a process of continually matching rules against a history, and firing those rules when antecedents are satisfied. Any instantiated future-time consequents become commitments which must subsequently be satisfied, iteratively generating a model for the formula made up of the program rules.
Concurrent ML (pl, appeared 1993)
Origin: Bell Labs, Lucent Technologies
Country: United States


Concurrent ML (CML) is a concurrent extension of the Standard ML programming language characterized by its ability to allow programmers to create composable communication abstractions that are first class rather than built into the language. The design of CML and its primitive operations have been adopted in several other programming languages such as GNU Guile, Racket, and Manticore.
Cone (pl, appeared 2017)
Creators: Jonathan Goodwin
Origin: https://github.com/jondgoodwin/cone
Country: Australia and Belgium and France and Sweden and Indonesia
Website: http://cone.jondgoodwin.com/

Acorn2's passion is the 3D web and his <a href='http://web3d.jondgoodwin.com/'>Pegasus3D</a> browser, and the web is powered by languages. His <a href='https://github.com/jondgoodwin/cone'>Cone</a> language powers the 3D web. Cone is statically-typed, and uses LLVM to generate native efficient executables. Cone will also be a test bed for implementing gradual memory management. His previous work, <a href='http://web3d.jondgoodwin.com/acorn/index.html'>Acorn</a> is a dynamic language with some of the same features.


GitHub description: Cone Programming Language
Connection Machine (pl, appeared 1990)
Origin: Massachusetts Institute of Technology
Country: United States


A Connection Machine (CM) is a member of a series of massively parallel supercomputers that grew out of doctoral research on alternatives to the traditional von Neumann architecture of computers by Danny Hillis at the Massachusetts Institute of Technology (MIT) in the early 1980s. Starting with CM-1, the machines were intended originally for applications in artificial intelligence and symbolic processing, but later versions found greater success in the field of computational science.
Context Diff (diffFormat, appeared 1981)
Origin: University of California, Berkeley




*** /path/to/original	timestamp
--- /path/to/new	timestamp
***************
*** 1,3 ****
--- 1,9 ----
+ This is an important
+ notice! It should
+ therefore be located at
+ the beginning of this
+ document!
+
  This part of the
  document has stayed the
  same from version to
***************
*** 8,20 ****
  compress the size of the
  changes.

- This paragraph contains
- text that is outdated.
- It will be deleted in the
- near future.

  It is important to spell
! check this dokument. On
  the other hand, a
  misspelled word isn't
  the end of the world.
--- 14,21 ----
  compress the size of the
  changes.

  It is important to spell
! check this document. On
  the other hand, a
  misspelled word isn't
  the end of the world.
***************
*** 22,24 ****
--- 23,29 ----
  this paragraph needs to
  be changed. Things can
  be added after it.
+
+ This paragraph contains
+ important new additions
+ to this document.
Classroom Object Oriented Language (pl, appeared 1996)
Stands for: Classroom Object Oriented Language
Creators: Alexander Aiken
Origin: Stanford University
Country: United States


Cool, an acronym for Classroom Object Oriented Language, is a computer programming language designed by Alexander Aiken for use in an undergraduate compiler course project. While small enough for a one term project, Cool still has many of the features of modern programming languages, including objects, automatic memory management, strong static typing and simple reflection. The reference Cool compiler is written in C++, built fully on the public domain tools. It generates code for a MIPS simulator, SPIM. Thus, the language should port easily to other platforms. It has been used for teaching compilers at many institutions (such as the University of California at Berkeley, where it was first used or Shahid Beheshti University of Iran) and the software is stable. This language is unrelated to the COOL language included in CLIPS.
Matrix Market Coordinate Format (textDataFormat, appeared 1996)
Origin: National Institute of Standards and Technology
Country: United States
Website: https://math.nist.gov/MatrixMarket/formats.html#MMformat


The Matrix Market exchange formats are a set of human readable, ASCII-based file formats designed to facilitate the exchange of matrix data.  The file formats were designed and adopted for the Matrix Market, a NIST repository for test data for use in comparative studies of algorithms for numerical linear algebra.


1    0      0       6      0
0   10.5    0       0      0
0    0    .015      0      0å
0  250.5    0     -280    33.32
0    0      0       0     12
Copilot (pl, appeared 2021)
Origin: NASA
https://github.com/Copilot-Language
Country: United States
Website: https://copilot-language.github.io/

Copilot is a realtime programming language and Runtime Verification framework. It allows users to write concise programs in a simple but powerful way using a stream-based approach. Programs can be interpreted for testing, or translated C99 code to be incorporated in a project, or as a standalone application. The C99 backend ensures us that the output is constant in memory and time, making it suitable for systems with hard realtime requirements.



-- Raw temperature from sensor, range -50.0C to 100.0C.
temp :: Stream Word8
temp = extern "temperature" Nothing

-- Transform the temperature to Celsius.
ctemp :: Stream Float
ctemp = (unsafeCast temp) * (150.0 / 255.0) - 50.0

-- Bind two triggers with a 3.0C hysteresis.
spec = do
  trigger "heaton"  (ctemp < 18.0) [arg ctemp]
  trigger "heatoff" (ctemp > 21.0) [arg ctemp]
Coq (pl, appeared 1989)
Origin: The Coq development team
Country: France
Website: https://coq.inria.fr/


In computer science, Coq is an interactive theorem prover. It allows the expression of mathematical assertions, mechanically checks proofs of these assertions, helps to find formal proofs, and extracts a certified program from the constructive proof of its formal specification. Coq works within the theory of the calculus of inductive constructions, a derivative of the calculus of constructions. Coq is not an automated theorem prover but includes automatic theorem proving tactics and various decision procedures. The Association for Computing Machinery rewarded Thierry Coquand, Gérard Pierre Huet, Christine Paulin-Mohring, Bruno Barras, Jean-Christophe Filliâtre, Hugo Herbelin, Chetan Murthy, Yves Bertot and Pierre Castéran with the 2013 ACM Software System Award for Coq.
CORAL (pl, appeared 1964)
Stands for: Computer On-line Real-time Applications Language
Origin: Royal Radar Establishment
Country: United Kingdom

CORAL (Computer On-line Real-time Applications Language) is a programming language originally developed in 1964 at the Royal Radar Establishment (RRE), Malvern, UK, as a subset of JOVIAL

CORAL (Computer On-line Real-time Applications Language) is a programming language originally developed in 1964 at the Royal Radar Establishment (RRE), Malvern, UK, as a subset of JOVIAL. Coral 66 was subsequently developed by I. F. Currie and M. Griffiths under the auspices of IECCA (Inter-Establishment Committee for Computer Applications). Its official definition, edited by Woodward, Wetherall and Gorman, was first published in 1970.
CorelScript (pl, appeared 1994)
Origin: Corel Corporation
Country: United States
Website: http://www.corel.com/en/

CorelSCRIPT is a dialect of Basic that serves as the macro extension language for many products from Corel Corp, including their line of graphics products. While the syntax of CorelSCRIPT is nearly identical to that of Microsoft's Visual Basic, it is distinguished by the large number of built-in functions that it provides for the end-user. In versions of CorelDraw 6.0 and later, for example, essentially every function the drawing tool can perform is available to the CorelSCRIPT programmer. Also, Corel tools can compile scripts to speed execution; this capability is somewhat unusual for an application macro language. Like the Visual Basic language systems it resembles, CorelSCRIPT is compatible with MS-Windows OLE automation facility, allowing a CorelSCRIPT program to invoke and control any OLE-capable Windows application. CorelSCRIPT is a commercial product available only with Corel Corporation products. Meager information about the language is available on the WWW.
Corman Common Lisp (pl, appeared 1995)
Creators: Scott Fahlman
Richard P. Gabriel
David A. Moon
Kent Pitman
Guy Steele
Dan Weinreb
Roger Corman
Origin: Corman Technologies
Country: United States
Website: https://groups.google.com/g/cormanlisp


Corman Common Lisp is a commercial implementation of the Common Lisp programming language featuring support for the Windows operating system.
Cornell University Programming Language (pl, appeared 1967)
Origin: Cornell University
Country: United States


Cornell University Programming Language (also called CUPL) is a procedural computer programming language developed at Cornell University in the late 1960s. CUPL was based on an earlier Cornell-developed programming language, CORC.  It was used to teach introductory computer programming classes. CUPL was developed by R. W. Conway, W. L. Maxwell, G. Blomgren, Howard Elder, H. Morgan, C. Pottle, W. Riddle, and Robert Walker.  CUPL had a very simple syntax similar to BASIC and to PL/I. The processor was designed to offer extensive error correction and diagnostic capabilities.  This would allow student programs to execute even if they contained minor syntax errors.  The compiler also included spelling correction capabilities so that if a variable name is referenced only once, the compiler would assume that it was a misspelling of some other intended name. CUPL also offered an extensive set of matrix operations and offered dynamic run-time memory allocation.  At the time, Cornell's computer was an IBM System 360 Model 40 with only 64K of core memory.  CUPL was able to process a large batch of student programs quickly by remaining resident in core memory, but the compiler occupied 58K of memory, leaving only a small amount for the program code and variable storage.
CorVision (pl, appeared 1986)
Origin: Cortex Corporation
Country: United States


CorVision is a fourth generation programming tool (4GL) currently owned by Attunity, Inc. CorVision was developed by Cortex Corporation for the VAX/VMS ISAM environment. Although Cortex beta tested CorVision-10 which was generated for PCs but CorVision itself stayed anchored on VMS. CorVision-10 proved more difficult than hoped, and was never released.
CouchDB (application, appeared 2005)
Origin: https://github.com/apache/couchdb
Website: https://couchdb.apache.org/


Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang. CouchDB uses multiple formats and protocols to store, transfer, and process its data. It uses JSON to store data, JavaScript as its query language using MapReduce, and HTTP for an API.

GitHub description: Seamless multi-master syncing database with an intuitive HTTP/JSON API, designed for reliability
COWSEL (pl, appeared 1964)
Origin: University of Edinburgh
Country: United Kingdom


COWSEL (COntrolled Working SpacE Language) is a programming language designed between 1964 and 1966 by Robin Popplestone. It was based on an RPN form of Lisp combined with some ideas from CPL. COWSEL was initially implemented on a Ferranti Pegasus computer at the University of Leeds and on a Stantec Zebra at the Bradford Institute of Technology; later, Rod Burstall implemented it on an Elliot 4120 at the University of Edinburgh. COWSEL was renamed POP-1 during the summer of 1966 and development continued under that name from then on.
cperl (pl, appeared 2017)
Creators: Reini Urban
Origin: https://github.com/perl11/
Country: Various
Website: http://perl11.github.io/

cperl is a better variant of Perl 5 with many Perl 6 based features and improvements, but without breaking compatibility. CPAN works. It is a "perl 11", 5 + 6 = 11.


GitHub description: A perl5 with classes, types, compilable, company friendly, security
C++ (pl, appeared 1985)
Creators: Bjarne Stroustrup
Origin: Bell Labs
Country: United States
Website: http://isocpp.org/
Keywords: #define
#defined
#elif
#else
#endif
#error
#if
#ifdef
#ifndef
#include
#line
#pragma
#undef
alignas
alignof
and
and_eq
asm
atomic_cancel
atomic_commit
atomic_noexcept
auto
bitand
bitor
bool
break
case
catch
char
char16_t
char32_t
class
compl
concept
const
constexpr
const_cast
continue
decltype
default
delete
do
double
dynamic_cast
else
enum
explicit
export
extern
false
final
float
for
friend
goto
if
inline
int
import
long
module
mutable
namespace
new
noexcept
not
not_eq
nullptr
operator
or
or_eq
override
private
protected
public
register
reinterpret_cast
requires
return
short
signed
sizeof
static
static_assert
static_cast
struct
switch
synchronized
template
this
thread_local
throw
transaction_safe
transaction_safe_dynamic
true
try
typedef
typeid
typename
union
unsigned
using
virtual
void
volatile
wchar_t
while
xor
xor_eq


C++ ( pronounced cee plus plus) is a general-purpose programming language. It has imperative, object-oriented and generic programming features, while also providing facilities for low-level memory manipulation. It was designed with a bias toward system programming and embedded, resource-constrained and large systems, with performance, efficiency and flexibility of use as its design highlights. C++ has also been found useful in many other contexts, with key strengths being software infrastructure and resource-constrained applications, including desktop applications, servers (e.g. e-commerce, web search or SQL servers), and performance-critical applications (e.g. telephone switches or space probes). C++ is a compiled language, with implementations of it available on many platforms. Many vendors provide C++ compilers, including the Free Software Foundation, Microsoft, Intel, and IBM. C++ is standardized by the International Organization for Standardization (ISO), with the latest standard version ratified and published by ISO in December 2014 as ISO/IEC 14882:2014 (informally known as C++14). The C++ programming language was initially standardized in 1998 as ISO/IEC 14882:1998, which was then amended by the C++03, ISO/IEC 14882:2003, standard. The current C++14 standard supersedes these and C++11, with new features and an enlarged standard library. Before the initial standardization in 1998, C++ was developed by Bjarne Stroustrup at Bell Labs since 1979, as an extension of the C language as he wanted an efficient and flexible language similar to C, which also provided high-level features for program organization. The C++17 standard is due in July 2017, with the draft largely implemented by some compilers already, and C++20 is the next planned standard thereafter. Many other programming languages have been influenced by C++, including C#, D, Java, and newer versions of C.
cql (pl, appeared 1998)
Origin: AT&T Bell Laboratories
Country: United States


As an abbreviation, CQL can refer to:  Chess Query Language, a query language for interrogating chess databases Contextual Query Language (or common query language), for information retrieval Cassandra Query Language, for Apache Cassandra Classora Query Language, for Classora Knowledge Base CIM Query Language, a query language for the Common Information Model (CIM) standard from the Distributed Management Task Force (DMTF) Cypher Query Language a declarative graph query language that allows for expressive and efficient querying and updating of a property graph.
CRAM file format (binaryDataFormat, appeared 2011)
Origin: Global Alliance for Genomics and Health
Country: Canada

CRAM files typically vary from 30 to 60% smaller than BAM, depending on the data held within them.

CRAM is a compressed columnar file format for storing biological sequences aligned to a reference sequence, initially devised by Markus Hsi-Yang Fritz et al.CRAM was designed to be an efficient reference-based alternative to the Sequence Alignment Map (SAM) and Binary Alignment Map (BAM) file formats.  It optionally uses a genomic reference to describe differences between the aligned sequence fragments and the reference sequence, reducing storage costs.  Additionally each column in the SAM format is separated into its own blocks, improving compression ratio.  CRAM files typically vary from 30 to 60% smaller than BAM, depending on the data held within them.
Creative Basic (pl, appeared 2008)


Creative Basic (CB) is a third-generation event-driven programming language for Windows, with an integrated development environment (IDE). Current version executables are interpreted and require no runtime libraries be installed on the end-user's computer.  A planned future version will have compiled executables. Creative Basic has an extensive command set, and access to the application programming interface (API) libraries available in the Microsoft Windows operating system. Although this modern version dates from 2007, it is a development from, and is completely compatible with IBasic, which has been in use worldwide since 2002. Some notable projects are Jerry Muelver's WikiWriter, a WikiWriter to Chm Wizard by Alyce Watson, and Mike Rainey's manufacturing engineering programs. (see the Links below).
Crema (pl, appeared 2014)
Creators: Jacob Torrey
Jared Wright
Origin: Assured Information Security, Inc.
Country: United States
Website: https://github.com/ainfosec/crema/wiki
Keywords: as
bool
break
char
def
double
else
eq
extern
false
foreach
ge
gt
if
int
le
lt
neq
return
sdef
string
struct
true
uint
void

Crema is a LLVM front-end that aims to specifically execute in sub-Turing Complete space. Designed to be simple to learn, and practical for the majority of programming tasks needed, Crema can restrict the computational complexity of the program to the minimum needed to improve security.


GitHub description: Crema: A Sub-Turing Programming Language 

def int binarySearch(int values[], int searchTarget){
    int upperBound = list_length(values) - 1    # Upper index of seach region
    int lowerBound = 0                       # Lower index of seach region
    int delta = list_length(values)     # Distance between upperBound and lowerBound
    int middleValueIndex = 0    # Mid-point index between upper and lower bounds
    int middleValue = 0         # Value at the mid-point index
    int foundIndex = -1         # The index of the target number after finding

    foreach(values as value){
        # Check middle value to see if it matches target number
        middleValueIndex = ((upperBound + lowerBound) / 2)
        middleValue = values[middleValueIndex]
        if(middleValue == searchTarget){
            foundIndex = middleValueIndex
            break
        }

        #Re-adjust the lower and upper bounds for next itteration
        if(middleValue >= searchTarget){
            upperBound = middleValueIndex - 1
        }else{
            lowerBound = middleValueIndex + 1
        }
        delta = upperBound - lowerBound
    }
    return foundIndex
}
Creole (textMarkup, appeared 2007)
Origin: International Symposium on Wikis
Country: Denmark

Creole is a lightweight markup language, aimed at being a common markup language for wikis, enabling and simplifying the transfer of content between different wiki engines.

Creole is a lightweight markup language, aimed at being a common markup language for wikis, enabling and simplifying the transfer of content between different wiki engines.


* Bullet list
* Second item
** Sub item

# Numbered list
# Second item
## Sub item