pldb/PLDB huggingface dataset:
CWEB (textMarkup, appeared 1987)
Creators: Donald Knuth
Origin: Stanford University
Country: Netherlands
Website: http://www-cs-faculty.stanford.edu/~uno/cweb.html


CWEB is a computer programming system created by Donald Knuth and Silvio Levy as a follow-up to Knuth's WEB literate programming system, using the C programming language (and to a lesser extent the C++ and Java programming languages) instead of Pascal. Like WEB, it consists of two primary programs: CTANGLE, which produces compilable C code from the source texts, and CWEAVE, which produces nicely-formatted printable documentation using TeX.


\datethis
@*Intro. This program generates clauses for the transition relation
from time $t$ to time $t+1$ in Conway's Game of Life, assuming that
all of the potentially live cells at time $t$ belong to a pattern
that's specified in |stdin|. The pattern is defined by one or more
lines representing rows of cells, where each line has `\..' in a
cell that's guaranteed to be dead at time~$t$, otherwise it has `\.*'.
The time is specified separately as a command-line parameter.

The Boolean variable for cell $(x,y)$ at time $t$ is named by its
so-called ``xty code,'' namely by the decimal value of~$x$, followed
by a code letter for~$t$, followed by the decimal value of~$y$. For
example, if $x=10$ and $y=11$ and $t=0$, the variable that indicates
liveness of the cell is \.{10a11}; and the corresponding variable
for $t=1$ is \.{10b11}.

Up to 19 auxiliary variables are used together with each xty code,
in order to construct clauses that define the successor state.
The names of these variables are obtained by appending one of
the following two-character combinations to the xty code:
\.{A2}, \.{A3}, \.{A4},
\.{B1}, \.{B2}, \.{B3}, \.{B4},
\.{C1}, \.{C2}, \.{C3}, \.{C4},
\.{D1}, \.{D2},
\.{E1}, \.{E2},
\.{F1}, \.{F2},
\.{G1}, \.{G2}.
These variables are derived from the Bailleux--Boufkhad method
of encoding cardinality constraints:
The auxiliary variable \.{A$k$} stands for the condition
``at least $k$ of the eight neighbors are alive.'' Similarly,
\.{B$k$} stands for ``at least $k$ of the first four neighbors
are alive,'' and \.{C$k$} accounts for the other four neighbors.
Codes \.D, \.E, \.F, and~\.G refer to pairs of neighbors.
Thus, for instance, \.{10a11C2} means that at least two of the
last four neighbors of cell $(10,11)$ are alive.

Those auxiliary variables receive values by means of up to 77 clauses per cell.
For example, if $u$ and~$v$ are the neighbors of cell~$z$ that correspond
to a pairing of type~\.D, there are six clauses
$$\bar u d_1,\quad
  \bar v d_1,\quad
Cyber (pl, appeared 2022)
Website: https://cyberscript.dev/

Cyber is a new language for fast, efficient, and concurrent scripting.


GitHub description: Fast and concurrent scripting.

import m 'math'

worlds = ['World', '世界', 'दुनिया']
worlds.append(m.random())
for worlds each w:
    print 'Hello, {w}!'

func fib(n int) int:
    coyield
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

count = 0    -- Counts iterations.
fiber = coinit fib(30)
while fiber.status() != #done:
    res = coresume fiber
    count += 1
print '{res} {count}'
CYBIL (pl, appeared 1980)
Origin: Control Data Corporation
Country: United States


Cybil (short for the Cyber Implementation Language of the Control Data Network Operating System) was a Pascal-like language developed at Control Data Corporation.  Cybil was used as the implementation language for the NOS/VE operating system on the CDC Cyber series and was also used to write the eOS operating system for the ETA10 supercomputer in the 1980s.
CYCL (pl, appeared 1988)
Origin: Cycorp, Inc
Country: United States
Website: https://cyc.com/


CycL in computer science and artificial intelligence is an ontology language used by Doug Lenat's Cyc artificial intelligence project. Ramanathan V. Guha was instrumental in the design of early versions of the language. There is a close variant of CycL known as MELD. The original version of CycL was a frame language, but the modern version is not.  Rather, it is a declarative language based on classical first-order logic, with extensions for modal operators and higher order quantification. CycL is used to represent the knowledge stored in the Cyc Knowledge Base, available from Cycorp.  The source code written in CycL released with the OpenCyc system is licensed as open source, to increase its usefulness in supporting the semantic web.
Cyclone (pl, appeared 2001)
Origin: AT&T Labs
Country: United States
Website: http://cyclone.thelanguage.org


The Cyclone programming language is intended to be a safe dialect of the C language. Cyclone is designed to avoid buffer overflows and other vulnerabilities that are possible in C programs, without losing the power and convenience of C as a tool for system programming. Cyclone development was started as a joint project of AT&T Labs Research and Greg Morrisett's group at Cornell in 2001. Version 1.0 was released on May 8, 2006.
Cypher Query Language (queryLanguage, appeared 2011)
Origin: Neo4j
Country: Various
Website: https://neo4j.com/developer/cypher-query-language/
Keywords: ALL
AND
AS
ASC
ASCENDING
BY
CALL
CASE
CONTAINS
CREATE
DELETE
DESC
DESCENDING
DETACH
DISTINCT
ELSE
END
ENDS
EXISTS
IN
IS
LIMIT
MANDATORY
MATCH
MERGE
NOT
ON
ON
OPTIONAL
OR
ORDER
REMOVE
RETURN
SET
SKIP
STARTS
THEN
UNION
UNWIND
WHEN
WHERE
WITH
XOR
YIELD

Cypher is a declarative, SQL-inspired language for describing patterns in graphs visually using an ascii-art syntax. It allows us to state what we want to select, insert, update or delete from our graph data without requiring us to describe exactly how to do it. A language with neo4j.

Cypher is a declarative graph query language that allows for expressive and efficient querying and updating of a property graph. Cypher is a relatively simple but still very powerful language. Very complicated database queries can easily be expressed through Cypher. This allows users to focus on their domain instead of getting lost in database access.Cypher was largely an invention of Andrés Taylor while working for Neo4j, Inc.(formerly Neo Technology) in 2011. Cypher was originally intended to be used with the graph database Neo4j, but was opened up through the openCypher project in October 2015.
Cython (pl, appeared 2007)
Origin: https://github.com/sagemath
Country: Various
Website: http://cython.org


Cython is a superset of the Python programming language, designed to give C-like performance with code which is mostly written in Python. Cython is a compiled language that generates CPython extension modules. These extension modules can then be loaded and used by regular Python code using the import statement. Cython is written in Python and works on Windows, macOS, and Linux, producing source files compatible with CPython 2.6, 2.7, and 3.3 through 3.7.
D (pl, appeared 2001)
Creators: Walter Bright
Andrei Alexandrescu
Origin: Digital Mars
Country: United States
Website: https://dlang.org
File extensions: d


The D programming language is an object-oriented, imperative, multi-paradigm system programming language created by Walter Bright of Digital Mars and released in 2001. Bright was joined in the design and development effort in 2007 by Andrei Alexandrescu. Though it originated as a re-engineering of C++, D is a distinct language, having redesigned some core C++ features while also taking inspiration from other languages, notably Java, Python, Ruby, C#, and Eiffel. D's design goals attempt to combine the performance and safety of compiled languages with the expressive power of modern dynamic languages. Idiomatic D code is commonly as fast as equivalent C++ code, while being shorter and memory-safe. Type inference, automatic memory management and syntactic sugar for common types allow faster development, while bounds checking, design by contract features and a concurrency-aware type system help reduce the occurrence of bugs.
D2 (textMarkup, appeared 1995)
Stands for: Declarative Diagramming
Origin: Terrastruct, Inc
Country: United States
Website: https://d2-lang.com/

D2 is a domain-specific language (DSL) that stands for Declarative Diagramming. Declarative, as in, you write in text what you want diagrammed, we generate it.



aws: {
  load_balancer -> api
  api -> db
}
gcloud: {
  auth -> db
}

gcloud -> aws

explanation: |md
  # Why do we use AWS?
  - It has more uptime than GCloud
  - We have free credits
| {
  near: aws
}
D3.js (library, appeared 2011)
Creators: Mike Bostock
Origin: https://github.com/d3
Country: United States
Website: https://d3js.org/


D3.js (or just D3 for Data-Driven Documents) is a JavaScript library for producing dynamic, interactive data visualizations in web browsers. It makes use of the widely implemented SVG, HTML5, and CSS standards. It is the successor to the earlier Protovis framework. In contrast to many other libraries, D3.js allows great control over the final visual result. Its development was noted in 2011, as version 2.0.0 was released in August 2011.D3.js is used on hundreds of thousands of websites. Some popular uses include creating interactive graphics for online news websites, information dashboards for viewing data, and producing maps from GIS map making data. In addition, the exportable nature of SVG enables graphics created by D3 to be used in print publications.

GitHub description: Bring data to life with SVG, Canvas and HTML. :bar_chart::chart_with_upwards_trend::tada:
D4 (pl, appeared 2001)
Origin: Softwise Inc
Country: Unknown


Dataphor is an open-source truly-relational database management system (RDBMS) and its accompanying user interface technologies, which together are designed to provide highly declarative software application development.  The Dataphor Server has its own storage engine or it can be a virtual, or federated, DBMS, meaning that it can utilize other database engines for storage. Dataphor has been praised for its adherence to relational principles, more closely so than any SQL product.
DAD (pl, appeared 2015)
Creators: Scott Ambler
Mark Lines
Country: Canada


Disciplined agile delivery (DAD) is the software development portion of the Disciplined Agile Toolkit. DAD enables teams to make simplified process decisions around incremental and iterative solution delivery. DAD builds on the many practices espoused by advocates of agile software development, including scrum, agile modeling, lean software development, and others.
Dafny (pl, appeared 2009)
Creators: K. Rustan M. Leino
Origin: Microsoft
Website: https://www.microsoft.com/en-us/research/project/dafny-a-language-and-program-verifier-for-functional-correctness/


Dafny is an imperative compiled language that targets C# and supports formal specification through preconditions, postconditions, loop invariants and loop variants.  The language combines ideas primarily from the Functional and Imperative paradigms, and includes limited support for Object-Oriented Programming.  Features include generic classes, dynamic allocation, inductive datatypes and a variation of separation logic known as implicit dynamic frames for reasoning about side effects.  Dafny was created by Rustan Leino at Microsoft Research after his previous work on developing ESC/Modula-3, ESC/Java, and Spec#.  Dafny is been used widely in teaching and features regularly in software verification competitions (e.g. VSTTE'08, VSCOMP'10, COST'11, and VerifyThis'12). Dafny was designed to provide a simple introduction to formal specification and verification and has been used widely in teaching.  Dafny follows in the lineage of many previous tools, including SPARK/Ada, ESC/Java, Spec#, Whiley, Why3 and Frama-C.  Such tools rely on the use of automated theorem proving to discharge proof obligations unlike, for example, those based on dependent types (e.g. Idris, Agda) which require more human intervention.  Dafny builds on the Boogie intermediate language which uses the Z3 automated theorem prover for discharging proof obligations.

GitHub description: Dafny is a verification-aware programming language
Daisy Systems (pl, appeared 1983)
Origin: Daisy Systems Corporation
Country: United States


Daisy Systems Corporation incorporated in 1981 in Mountain View, California, was a computer-aided engineering, company, a pioneer in the electronic design automation (EDA) industry. It was a manufacturer of computer hardware and software for EDA, including schematic capture, logic simulation, parameter extraction and other tools for printed circuit board design and semiconductor chip layout. In mid-1980s, it had a subsidiary in Germany, Daisy Systems GmbH and one in Israel. The company merged with Cadnetix Corporation of Boulder, Colorado in 1988, with the resulting company then known officially as Daisy/Cadnetix, Inc. with the trade name DAZIX. It filed for protection under Chapter 11 of the Federal Bankruptcy Code in 1990 and was acquired by Intergraph later that year. Intergraph incorporated DAZIX into its EDA business unit, which was later spun off as an independent subsidiary named VeriBest, Inc. VeriBest was ultimately acquired by Mentor Graphics in late 1999. Daisy Systems was founded by Aryeh Finegold and David Stamm; its original investors were Fred Adler and Oak Investment Partners. Daisy along with Valid Logic Systems and Mentor Graphics, collectively known as DMV, added front end design to the existing computer-aided design aspects of computer automation.
Dak (pl, appeared 2022)
Creators: Naitik Shah
Origin: https://github.com/daaku/dak/issues
Country: Dubai
Website: https://www.daklang.com/

Dak is a Lisp like language that transpiles to JavaScript.


GitHub description: Dak is a Lisp like language that transpiles to JavaScript.

; Functions are varied and colorful.

; Simple function:
(fn add [a b]
  (+ a b))
(prn (add 40 1))

; Async function:
(fn@ add-promises [a b]
  (+ @a @b))
(prn @(add-promises (Promise.resolve 40) (Promise.resolve 2)))

; Generator function:
(fn* powers [n count]
  (let [current 1]
    (for [i 0 count]
      (yield (*= current n)))))
(for-of [v (powers 2 5)]
  (prn v))

; Async generator function:
(fn@* foo [a b]
  (yield (inc @a))
  (yield (inc @b)))
(for@ [v (foo (Promise.resolve 41) (Promise.resolve -43))]
  (prn v))

; Exported function:
(fn ^:export plus [a b]
  (+ a b))

; Exported default function:
(fn ^:export ^:default [a b]
  (- a b))

; Declaration syntax:
(fn ^:decl TheClass [a]
  (set this.answer a))
(prn (TheClass. 42))

; Explicit return is available:
(fn until [a]
  (while true
    (if (= (++ a) 42)
      (return :boom))))
(prn :returned (until 40))

; Yield & Yield* are available:
(fn* it [a]
  (yield (++ a))
  (yield* [(++ a) (++ a)]))
(for-of [v (it 39)]
  (prn "it:" v))
DAML+OIL (pl, appeared 2001)
Origin: Defense Advanced Research Projects Agency
Country: United States


DAML+OIL is a successor language to DAML and OIL that combines features of both. In turn, it was superseded by Web Ontology Language (OWL). DAML stands for DARPA Agent Markup Language. OIL stands for Ontology Inference Layer or Ontology Interchange Language. The DAML program ended in early 2006.
DARPA Agent Markup Language (xmlFormat, appeared 1999)
Stands for: DARPA Agent Markup Language
Origin: Defense Advanced Research Projects Agency
Country: United States


The DARPA Agent Markup Language (DAML) was the name of a US funding program at the US Defense Advanced Research Projects Agency (DARPA) started in 1999 by then-Program Manager James Hendler, and later run by Murray Burke,  Mark Greaves and Michael Pagels. The program focused on the creation of machine-readable representations for the Web. One of the Investigators working on the program was Tim Berners-Lee and to a great degree through his influence, working with the program managers, the effort worked to create technologies and demonstrations for what is now called the Semantic Web and this in turn led to the growth of Knowledge Graph technology. A primary outcome of the DAML program was the DAML language, an  agent markup language based on  RDF.  This language was then followed by an extension entitled DAML+OIL which included researchers outside of the DARPA program in the design. The 2002 submission of the DAML+OIL language to the World Wide Web Consortium (W3C) captures the work done by DAML contractors and the EU/U.S. ad hoc Joint Committee on Markup Languages.  This submission was the starting point for the language (later called OWL) to be developed by W3C's web ontology working group, WebOnt. DAML+OIL was a syntax, layered on RDF and XML, that could be used to describe sets of facts making up an ontology. DAML+OIL had its roots in three main languages - DAML, as described above,  OIL (Ontology Inference Layer) and  SHOE, an earlier US research project. A major innovation of the languages was to use RDF and XML for a basis, and to use RDF namespaces to organize and assist with the integration of arbitrarily many different and incompatible ontologies. Articulation ontologies can link these competing ontologies through codification of analogous subsets in a neutral point of view, as is done in the Wikipedia. Current ontology research derived in part from DAML is leading toward the expression of ontologies and rules for reasoning and action.  Much of the work in DAML has now been incorporated into RDF Schema, the OWL and their successor languages and technologies including schema.org
DAP FORTRAN (pl, appeared 1975)
Origin: International Computers Limited
Country: United Kingdom


DAP FORTRAN was an extension of the non IO parts of FORTRAN with constructs that supported parallel computing for the ICL Distributed Array Processor (DAP). The DAP had a Single Instruction Multiple Data (SIMD) architecture with 64x64 single bit processors. DAP FORTRAN had the following major features:  It had matrix and vector operations. Assignments could be performed under a logical mask so only some elements in the target of an assignment were changed. On the negative side - operations were performed using the size of the underlying hardware i.e. on a 64x64 matrix or 64 element vector.In a declaration either one or two extents could be omitted as in:  The omitted dimension was taken as 64, the size of one side of the DAP. The speed of arithmetic operations depended strongly on the number of bits in the value. INTEGER*n reserved 8n bits where n is 1 to 8, and REAL*n reserved 8n bits where n is 3 to 8. LOGICAL reserved a single bit. However, DAP FORTRAN fell between two conflicting objectives. It needed to effectively exploit the DAP facilities. But also had to be accessible to the scientific computing community whose primary language, with a design closely tied to serial architectures, was FORTRAN. The dialect used was ICL's 2900-series FORTRAN which was based on an early version of the FORTRAN 77 standard and had mismatches with both FORTRAN 77 and the older FORTRAN 66 standard. DAP FORTRAN was significantly different from either standard FORTRAN and the machine was not capable of accepting or optimising standard FORTRAN programs. On the other hand, compared with other contemporary languages which were by design extensible (notably ALGOL-68), FORTRAN was less than well suited to this task. The result was noticeably inelegant and did require a great deal of new learning. Operationally, there was an overhead to transfer computational data into and out of the array, and problems which did not fit the 64x64 matrix imposed additional complexity to handle the boundaries (65x65 was perhaps the worst case!) – but for problems which suited the architecture, it could outperform the current Cray pipeline architectures by two orders of magnitude. A later version of the DAP used Fortran-Plus instead which was based on FORTRAN 77 and had more flexible indexing. In particular it automatically mapped user sized arrays onto the underlying hardware.
DarkBASIC (pl, appeared 2000)
Origin: https://github.com/TheGameCreators
Country: United Kingdom
Website: https://www.thegamecreators.com/


The Game Creators Ltd (formerly Dark Basic Software Limited) is a British software house based in Macclesfield, England, which specialises in software for video game development. The company was established in March 1999 through a partnership between programmers Lee Bamber and Richard Vanner.
Dart (pl, appeared 2011)
Creators: Lars Bak
Origin: Google
Website: http://www.dartlang.org
File extensions: dart
Keywords: abstract
as
assert
async
await
break
case
catch
class
const
continue
covariant
default
deferred
do
dynamic
else
enum
export
extends
external
factory
false
final
finally
for
get
if
implements
import
in
is
library
new
null
operator
part
rethrow
return
set
static
super
switch
sync
this
throw
true
try
typedef
var
void
while
with
yield


Dart is a general-purpose programming language originally developed by Google and later approved as a standard by Ecma (ECMA-408). It is used to build web, server and mobile applications, and for Internet of Things (IoT) devices. It is open-source software under a permissive free software license (modified BSD license). Dart is an object-oriented, class defined, single inheritance language using a C-style syntax that transcompiles optionally into JavaScript. It supports interfaces, mixins, abstract classes, reified generics, optional typing, and a sound type system.
Dartmouth BASIC (pl, appeared 1964)
Creators: John G. Kemeny
Thomas E. Kurtz
Origin: Dartmouth College
Country: United States


Dartmouth BASIC is the original version of the BASIC programming language.  It is so named because it was designed and implemented at Dartmouth College by John Kemény and Thomas Kurtz. It was developed as part of the Dartmouth Time Sharing System (DTSS) and was one of the first programming languages intended to be used interactively. Several versions were produced at Dartmouth over the years, all implemented as compile and go compilers. They were implemented by teams of undergraduate programmers working for Kemény and Kurtz.  The first version ran on 1 May 1964, and it was opened to general users in June; upgrades followed, culminating in the seventh release in 1979. Dartmouth also introduced a dramatically updated version known as Structured BASIC (or SBASIC) in 1975, which added various structured programming concepts. SBASIC formed the basis of the ANSI-standard Standard BASIC efforts in the early 1980s. Most dialects of BASIC, notably Microsoft BASIC (MS BASIC), can trace their history to the Fifth Edition. In contrast to the Dartmouth compilers, most other BASICs were written as interpreters. They also lack some of the more advanced features, notably the matrix math commands. Cutting these features allowed these versions to run in the very small main memory of early microcomputers. By the early 1980s, tens of millions of home computers were running some variant of the MS interpreter. It became the de facto standard for BASIC, which led to the abandonment of the ANSI SBASIC efforts. Kemény and Kurtz later left Dartmouth to develop and promote a version of SBASIC known as True BASIC. Many of the early computer games of the mainframe computer era trace their history to Dartmouth BASIC and the DTSS system. A selection of these were collected, in HP 2000 versions, in the People's Computer Company book What to do after you hit Return. Many of the original source listings in BASIC Computer Games and related works also trace their history to Dartmouth BASIC.
Dashrep (pl, appeared 2011)
Creators: Richard Fobes
Origin: www.solutionscreative.com
Country: United States
Website: http://www.dashrep.org/

Dashrep™, the text-manipulation programming language that is powerful and fast, yet simple


GitHub description: Dashrep is a versatile descriptive programming language based on hyphenated phrases being successively expanded into replacement text. It is a much more flexible alternative to using a template language.

animal-type:
dolphin
----
characteristic-for-dolphin:
talkative
----
start-here:
The animal-type is characteristic-for
fenambee animal-type amenn no-space .
----