pldb/PLDB huggingface dataset:
Croc (pl, appeared 2006)
Creators: Jarrett Billingsley
Origin: http://www.dsource.org/projects/minid
Country: United States
Website: https://web.archive.org/web/20120625151120/http://jfbillingsley.com/croc/

Croc is a small, dynamically-typed language most closely related to Lua, with C-style syntax. Its semantics are borrowed mainly from Lua, D, Squirrel, and Io, though many other languages served as inspirations.

The MiniD (has been renamed Croc) programming language is a small, lightweight, extension language in the vein of Lua or Squirrel, but designed to be used mainly with the D programming language.  It supports both object-oriented and imperative programming paradigms, as well as some simple functional aspects. Distributed under the licence of zlib/libpng, MiniD is free software.

GitHub description: Croc is an extensible extension language in the vein of Lua, which also wishes it were a standalone language. Also it's fun. 

module samples.interfaces

class Method
{
    _name
    _numParams

    this(name: string, numParams: int)
    {
        :_name = name
        :_numParams = numParams
    }

    function name() =
        :_name

    function implements(f: function) =
        f.numParams() == :_numParams

    function toString() =
        "{} ({} params)".format(:_name, :_numParams)
}

class Interface
{
    _name
    _methods
    _implementors

    this(name: string, methods: array)
    {
        if(!methods.all(\m -> m as Method))
            throw TypeError("All methods must be Methods")

        :_name = name
        :_methods = methods.dup()
        :_implementors = {}
    }

    function implement(T: class)
    {
        foreach(m; :_methods)
        {
            local name = m.name()

            if(!hasMethod(T, name) || !m.implements(T.(name)))
                throw TypeError("Class {} does not implement method '{}' from {}".format(nameOf(T), m, :_name))
        }

        :_implementors[T] = true
    }

    function opCall(val: instance)
    {
        if(superOf(val) not in :_implementors)
            :implement(superOf(val))

        return true
    }
}

function implements(T: class, vararg)
{
    for(i; 0 .. #vararg)
    {
        local p = vararg[i]

        if(!(p as Interface))
            throw TypeError("All varargs must be Interfaces")

        p.implement(T)
    }

    return T
}

local IStream = Interface("IStream",
[
    Method("read", 3)
    Method("write", 3)
    Method("seek", 2)
])

class DerpStream
{
    function read(m, offset, size) {}
    function write(m, offset, size) {}
    function seek(offset, whence) {}
}

function streamSomething(s: @IStream)
{
    s.read()
    writeln("yay!")
}

function main()
{
    local d = DerpStream()
    streamSomething(d)
}
crush (pl, appeared 2020)
Creators: Axel Liljencrantz
Origin: https://github.com/liljencrantz/
Country: Sweden

Crush is an attempt to make a traditional command line shell that is also a modern programming language. It has the features one would expect from a modern programming language like a type system, closures and lexical scoping, but with a syntax geared toward both batch and interactive shell usage.


GitHub description: Crush is a command line shell that is also a powerful modern programming language.
Cryptol (pl, appeared 2014)
Creators: Adam C. Foltzer
Origin: Galois,Inc
Country: United States
Website: https://galois.com/


Cryptol is a domain specific programming language for cryptography developed by the Portland, Oregon based software development firm, Galois, Inc.. The language was originally developed for use by the United States National Security Agency. The language is also used by private firms that provide information technology systems, such as the American company Rockwell Collins provides to aerospace and defense contractors in the United States.The programming language is used for all aspects of developing and using cryptography, such as the design and implementation of new ciphers and the verification of existing cryptographic algorithms.  Cryptol is designed to allow the cryptographer to watch how stream processing functions in the program manipulate the ciphers or encryption algorithms.

GitHub description: Cryptol: The Language of Cryptography
Crystal (pl, appeared 2014)
Creators: Ary Borenszweig
Juan Wajnerman
Brian Cardiff
Origin: https://forum.crystal-lang.org/
Country: Argentina and Germany and Turkey
Website: https://crystal-lang.org
File extensions: cr
Keywords: abstract
do
if
nil?
self
unless
alias
else
in
of
sizeof
until
as
elsif
include
out
struct
when
as?
end
instance_sizeof
pointerof
super
while
asm
ensure
is_a?
private
then
with
begin
enum
lib
protected
true
yield
break
extend
macro
require
type
case
false
module
rescue
typeof
class
for
next
return
uninitialized
def
fun
nil
select
union


In computer software programming languages, Crystal is a general-purpose, object-oriented programming language, designed and developed by Ary Borenszweig and Juan Wajnerman and more than 200 contributors. With syntax inspired by the language Ruby, it is a compiled language with static type-checking, but specifying the types of variables or method arguments is generally unneeded. Types are resolved by an advanced global type inference algorithm. Crystal is in active development. It is released as free and open-source software under the Apache License version 2.0

GitHub description: The Crystal Programming Language
CS-Script (pl, appeared 2004)
Origin: https://github.com/oleg-shilo
Country: Australia


CS-Script (www.csscript.net) is a CLR (Common Language Runtime) based scripting system which uses ECMA-compliant C# as a programming language. CS-Script currently targets Microsoft implementation of CLR (.NET 2.0/3.0/3.5/4.0) and with full support for Mono. CS-Script as well as a few other .NET languages (e.g. Boo) is a statically typed language and it allows unlimited access to .NET/CLR functionality with plain vanilla C# syntax. CS-Script as a scripting environment offers stand alone script execution as well as hosting the script engine from CLR application. Because of statically typed nature of the script execution CS-Script demonstrates no performance degradation comparing to the compiled managed binaries. Existing .NET development tools (e.g. MS Visual Studio, Sharp Develop) can be used, allowing editing and debugging scripts within traditional .NET Development environment. In addition to this in 2013 an Open Source CS-Script plugin for Notepad++ has been made publicly available. CS-Script has been used in a number of open-source and proprietary products of different scale and complexity (e.g. FlashDevelop, MediaPortal). CS-Script is released under the custom "liberal" license, which is allows free commercial use and free access to the source code.
CodeStudAssembler (assembly, appeared 2017)
Origin: https://github.com/v8
Country: Various




  test al,0x1
  jz not_string
  movq rbx,[rax-0x1]
  cmpb [rbx+0xb],0x80
  jnc not_string
  movq rax,[rax+0xf]
  retl
not_string:
  movq rax,[r13-0x60]
  retl
C# (pl, appeared 2000)
Creators: Anders Hejlsberg
Origin: Microsoft
Country: United States
Website: https://docs.microsoft.com/dotnet/csharp/language-reference/
File extensions: cs
Keywords: abstract
add
alias
as
ascending
async
await
base
bool
break
byte
case
catch
char
checked
class
const
continue
decimal
default
delegate
descending
do
double
dynamic
else
enum
event
explicit
extern
false
finally
fixed
float
for
foreach
from
get
global
goto
group
if
implicit
in
int
interface
internal
into
is
join
let
lock
long
namespace
new
null
object
operator
orderby
out
override
params
partial
private
protected
public
readonly
record
ref
remove
return
sbyte
sealed
select
set
short
sizeof
stackalloc
static
string
struct
switch
this
throw
true
try
typeof
uint
ulong
unchecked
unsafe
ushort
using
value
var
virtual
void
volatile
where
while
yield


C# (pronounced as see sharp) is a multi-paradigm programming language encompassing strong typing, imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming disciplines. It was developed by Microsoft within its .NET initiative and later approved as a standard by Ecma (ECMA-334) and ISO (ISO/IEC 23270:2006). C# is one of the programming languages designed for the Common Language Infrastructure. C# is a general-purpose, object-oriented programming language. Its development team is led by Anders Hejlsberg. The most recent version is C# 11, which was released in 2022 along with .NET 7. The language is being actively developed with a new version being released yearly along with the latest .NET version. The Unity game engine uses C# as its primary scripting language.
Csound (pl, appeared 1985)
Origin: Massachusetts Institute of Technology
Country: United States
Website: http://csound.com
File extensions: csd
sco


Csound is a computer programming language for sound, also known as a sound compiler or an audio programming language, or more precisely, an audio DSL. It is called Csound because it is written in C, as opposed to some of its predecessors. It is free software, available under the LGPL. Csound was originally written at MIT by Barry Vercoe in 1985, based on his earlier system called Music 11, which in its turn followed the MUSIC-N model initiated by Max Mathews at the Bell Labs.  Its development continued throughout the 1990s and 2000s, led by John ffitch at the University of Bath.  The first documented version 5 release is version 5.01 on March 18, 2006.  Many developers have contributed to it, most notably Istvan Varga, Gabriel Maldonado, Robin Whittle, Richard Karpen, Michael Gogins, Matt Ingalls,  Steven Yi, Richard Boulanger, and Victor Lazzarini. Developed over many years, it currently has nearly 1700 unit generators.  One of its greatest strengths is that it is completely modular and extensible by the user.  Csound is closely related to the underlying language for the Structured Audio extensions to MPEG-4, SAOL.
CSP (pl, appeared 1978)
Stands for: Communicating Sequential Processes
Origin: Oxford University
Country: United States
United Kingdom


In computer science, communicating sequential processes (CSP) is a formal language for describing patterns of interaction in concurrent systems. It is a member of the family of mathematical theories of concurrency known as process algebras, or process calculi, based on message passing via channels. CSP was highly influential in the design of the occam programming language, and also influenced the design of programming languages such as Limbo, RaftLib, Go, Crystal, and Clojure's core.async. CSP was first described in a 1978 paper by Tony Hoare, but has since evolved substantially. CSP has been practically applied in industry as a tool for specifying and verifying the concurrent aspects of a variety of different systems, such as the T9000 Transputer, as well as a secure ecommerce system. The theory of CSP itself is also still the subject of active research, including work to increase its range of practical applicability (e.g., increasing the scale of the systems that can be tractably analyzed).


COPY = *[c:character; west?c → east!c]
CSpydr (pl, appeared 2021)
Creators: Spydr06
Origin: https://github.com/spydr06/
Country: Germany
Website: https://github.com/spydr06/cspydr
File extensions: csp



GitHub description: A static typed low-level compiled programming language inspired by Rust and C

# fibonacci.csp
import "io.csp";
fn fib(n: i32): i32 {
    let a = 0;
    let b = 0;
    for 0 .. n {
        a + b |> (a = b, b = $);
    }
    <- a;
}
fn main(): i32 {
    let n = 10;
    std::io::printf("fib(%i) = %i\n", n, fib(n));
    <- 0;
}
CSS Doodle (pl, appeared 2017)
Creators: Yuan Chuan
Origin: https://github.com/css-doodle
Country: Various
Website: https://css-doodle.com/



GitHub description: 🎨  A web component for drawing patterns with CSS.

@grid: 14 / 80%;

@random {
  border-left: 1px solid #5d81bc;
}
@random {
  border-top: 1px solid #5d81bc;
}
@random(.25) {
  background: linear-gradient(
    @p(#fff, tan, #5d81bc), @lp
  )
  50% / @r(60%) @lr
  no-repeat;
}
@random {
  filter: drop-shadow(0 0 10px #fff);
}
CSS (stylesheetLanguage, appeared 1996)
Stands for: Cascading Style Sheets
Creators: Håkon Wium Lie
Origin: Conseil Européen pour la Recherche Nucléaire
Country: Switzerland


Cascading Style Sheets (CSS) is a style sheet language used for describing the presentation of a document written in a markup language. Although most often used to set the visual style of web pages and user interfaces written in HTML and XHTML, the language can be applied to any XML document, including plain XML, SVG and XUL, and is applicable to rendering in speech, or on other media. Along with HTML and JavaScript, CSS is a cornerstone technology used by most websites to create visually engaging webpages, user interfaces for web applications, and user interfaces for many mobile applications. CSS is designed primarily to enable the separation of presentation and content, including aspects such as the layout, colors, and fonts. This separation can improve content accessibility, provide more flexibility and control in the specification of presentation characteristics, enable multiple HTML pages to share formatting by specifying the relevant CSS in a separate .css file, and reduce complexity and repetition in the structural content. Separation of formatting and content makes it possible to present the same markup page in different styles for different rendering methods, such as on-screen, in print, by voice (via speech-based browser or screen reader), and on Braille-based tactile devices. It can also display the web page differently depending on the screen size or viewing device. Readers can also specify a different style sheet, such as a CSS file stored on their own computer, to override the one the author specified. Changes to the graphic design of a document (or hundreds of documents) can be applied quickly and easily, by editing a few lines in the CSS file they use, rather than by changing markup in the documents. The CSS specification describes a priority scheme to determine which style rules apply if more than one rule matches against a particular element. In this so-called cascade, priorities (or weights) are calculated and assigned to rules, so that the results are predictable. The CSS specifications are maintained by the World Wide Web Consortium (W3C). Internet media type (MIME type) text/css is registered for use with CSS by RFC 2318 (March 1998). The W3C operates a free CSS validation service for CSS documents.
CSV (dataNotation, appeared 1972)
Stands for: comma-separated values
File extensions: csv


In computing, a comma-separated values (CSV) file stores tabular data (numbers and text) in plain text. Each line of the file is a data record. Each record consists of one or more fields, separated by commas. The use of the comma as a field separator is the source of the name for this file format. The CSV file format is not standardized. The basic idea of separating fields with a comma is clear, but that idea gets complicated when the field data may also contain commas or even embedded line-breaks. CSV implementations may not handle such field data, or they may use quotation marks to surround the field. Quotation does not solve everything: some fields may need embedded quotation marks, so a CSV implementation may include escape characters or escape sequences. In addition, the term "CSV" also denotes some closely related delimiter-separated formats that use different field delimiters. These include tab-separated values and space-separated values. A delimiter that is not present in the field data (such as tab) keeps the format parsing simple. These alternate delimiter-separated files are often even given a .csv extension despite the use of a non-comma field separator. This loose terminology can cause problems in data exchange. Many applications that accept CSV files have options to select the delimiter character and the quotation character.


Year,Make,Model,Length
1997,Ford,E350,2.34
2000,Mercury,Cougar,2.38
CSVw (dataValidationLanguage, appeared 2014)
Stands for: CSV on the Web
Creators: Ivan Herman
Origin: CSV on the Web Working Group
CSV on the Web Community Group
Country: Various

The CSV on the Web Working Group has developed standard ways to express useful metadata about CSV files and other kinds of tabular data.


GitHub description: Documents produced by the CSV on the Web Working Group

{
  "@context": "http://www.w3.org/ns/csvw",
  "url": "countries.csv",
  "tableSchema": {
    "aboutUrl": "http://example.org/country/{code}",
    "columns": [{
      "titles": "country",
      "name": "code"
    },{
      "titles": "country group"
    },{
      "titles": "name (en)",
      "lang": "en"
    },{
      "titles": "name (fr)",
      "lang": "fr"
    },{
      "titles": "name (de)",
      "lang": "de"
    },{
      "titles": "latitude",
      "datatype": "number"
    },{
      "titles": "longitude",
      "datatype": "number"
    }]
  }
}
ctalk-lang (pl, appeared 1989)
Origin: École des Mines de Saint-Étienne
Country: France

The CTalk programming language: a strategic evolution of APL



// When working with the CTalk interpreter,
// every result is printed
2+3;
// = 5
2*3+5*10;
// = 56
// Variables are implicitely declared when
// they are used for the first time
a=2; b=3; a+b;
// = 2
// = 3
// = 5
CUDA (pl, appeared 2007)
Stands for: Compute Unified Device Architecture
Origin: Nvidia
Website: https://developer.nvidia.com/cuda-zone


CUDA is a parallel computing platform and application programming interface (API) model created by Nvidia. It allows software developers and software engineers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing – an approach termed GPGPU (General-Purpose computing on Graphics Processing Units). The CUDA platform is a software layer that gives direct access to the GPU's virtual instruction set and parallel computational elements, for the execution of compute kernels. The CUDA platform is designed to work with programming languages such as C, C++, and Fortran. This accessibility makes it easier for specialists in parallel programming to use GPU resources, in contrast to prior APIs like Direct3D and OpenGL, which required advanced skills in graphics programming. Also, CUDA supports programming frameworks such as OpenACC and OpenCL. When it was first introduced by Nvidia, the name CUDA was an acronym for Compute Unified Device Architecture, but Nvidia subsequently dropped the use of the acronym.
Cue (dataNotation, appeared 2018)
Creators: Marcel van Lohuizen
Origin: https://github.com/cue-lang
Country: United Kingdom and United States and Switzerland
Website: https://cuelang.org/



GitHub description: CUE has moved to https://github.com/cue-lang/cue

#Spec: {
  kind: string

  name: {
    first:   !=""  // must be specified and non-empty
    middle?: !=""  // optional, but must be non-empty when specified
    last:    !=""
  }

  // The minimum must be strictly smaller than the maximum and vice versa.
  minimum?: int & <maximum
  maximum?: int & >minimum
}

// A spec is of type #Spec
spec: #Spec
spec: {
  knid: "Homo Sapiens" // error, misspelled field

  name: first: "Jane"
Curl (pl, appeared 1998)
Creators: Steve Ward
Origin: Curl, Inc
Sumisho Computer Systems Corp
SCSK Corporation
Country: Japan
United States
Website: http://www.curl.com


Curl is a reflective object-oriented programming language for interactive web applications whose goal is to provide a smoother transition between formatting and programming. It makes it possible to embed complex objects in simple documents without needing to switch between programming languages or development platforms. The Curl implementation initially consisted of just an interpreter, but a compiler was added later. Curl combines text markup (as in HTML), scripting (as in JavaScript), and heavy-duty computing (as in Java, C#, or C++) within one unified framework. It is used in a range of internal enterprise, B2B, and B2C applications. Curl programs may be compiled into Curl applets, that are viewed using the Curl RTE, a runtime environment with a plugin for web browsers. Currently, it is supported on Microsoft Windows, Linux, and macOS. Curl supports "detached applets", which is a web deployed applet which runs on the user's desktop independent of a browser window much as in Silverlight 3 and Adobe AIR.
Curry (pl, appeared 1990)
Creators: Michael Hanus
Sergio Antoy
Origin: University of Kiel
Country: Germany


Curry is an experimental functional logic programming language, based on the Haskell language. It merges elements of functional and logic programming, including constraint programming integration. It is nearly a superset of Haskell, lacking support mostly for overloading using type classes, which some implementations provide anyway as a language extension, such as the Münster Curry Compiler.
cuscus (pl, appeared 2019)
Creators: Mariana Marasoiu
Detlef Nauck
Alan F. Blackwell
Origin: University of Cambridge
Applied Research
Country: United Kingdom

We present Cuscus, a tool for data visualisation that is informed by ethnographic fieldwork across different professional sectors. Cuscus allows end-users to create novel visualisations by defining visual properties in a spreadsheet. We also report on user studies in the contexts of data journalism and business analytics, and discuss further extensions to this new interaction paradigm.
Committee on Uniform Security Identification Procedures (schema, appeared 1968)
Stands for: Committee on Uniform Security Identification Procedures
Origin: Committee on Uniform Security Identification Procedures
Country: United States


A CUSIP is a nine-character alphanumeric code that identifies a North American financial security for the purposes of facilitating clearing and settlement of trades.  The CUSIP was adopted as an American National Standard under Accredited Standards X9.6. The CUSIP system is owned by the American Bankers Association and is operated by S&P Global Market Intelligence. The operating body, CUSIP Global Services (CGS), also serves as the national numbering agency (NNA) for North America, and the CUSIP serves as the National Securities Identification Number (NSIN) for products issued from both the United States and Canada. In its role as the NNA, CUSIP Global Services (CGS) also assigns all US-based ISINs.