pldb/PLDB huggingface dataset:
DOT (textMarkup, appeared 2007)
Also known as: Graphviz DOT
Origin: AT&T Labs Research
Country: United States


DOT is a plain text graph description language. DOT graphs are typically files with the file extension gv or dot. The extension gv is preferred to avoid confusion with the extension dot used by early (pre-2007) versions of Microsoft Word. Various programs can process DOT files. Some, such as dot, neato, twopi, circo, fdp, and sfdp, can read a DOT file and render it in graphical form. Others, such as gvpr, gc, acyclic, ccomps, sccmap, and tred, read DOT files and perform calculations on the represented graph. Finally, others, such as lefty, dotty, and grappa, provide an interactive interface. The GVedit tool combines a text editor with noninteractive image viewer. Most programs are part of the Graphviz package or use it internally.


 // The graph name and the semicolons are optional
graph graphname {
    a -- b -- c;
    b -- d;
}
D++ (pl, appeared 1999)
Creators: Daniel Smith
Origin: https://www.pagemac.com
Country: United States
Website: http://www.pagemac.com/dpp/home
File extensions: dpp
dpl
Keywords: continue
do
else
endif
exit_do
exit_for
exit_function
for
function
if
loop
newvar
next
return
step
then
to
until
var
while
Draco (pl, appeared 1987)
Creators: Chris Gray
Origin: https://web.archive.org/web/20090221030835/http://www.graysage.com/
Country: United States


Draco was a shareware programming language created by Chris Gray. First developed for CP/M sytems, Amiga version followed in 1987.Although Draco, a blend of Pascal and C, was well suited for general purpose programming, its uniqueness as a language was its main weak point. Gray used Draco for the Amiga to create a port of Peter Langston's game Empire.
DRAKON (pl, appeared 1996)
Creators: Stepan Mitkin
Origin: Soviet space program
Country: Russia
Website: https://drakon-editor.com/


DRAKON is an algorithmic visual programming language developed within the Buran space project following ergonomic design principles. The language provides a uniform way to represent flowcharts of any complexity that are easy to read and understand. The DRAKON Editor, which was released in September 2011, is an implementation of the language available in the public domain. It can be used for creating documentation, or for creating visual programs that can be converted to source code in other languages. Unlike UML's philosophy, DRAKON language philosophy is based on being augmented if needed, by using a hybrid language, which can be illustrated as "incrustating code snippets from text language used into shape DRAKON requires". This way, DRAKON stays an all-way simple visual language per se, that can be used as an augmentation for a programmer, who is interested in making own project code easier for support or other long-term needs, i.e. improving ergonomics of coding process or to make code easy to review and understand. Name DRAKON is Russian acronym for "Дружелюбный Русский Алгоритмический [язык], Который Обеспечивает Наглядность", which translates"Friendly Russian algorithmic [language] that provides illustrativeness (or clarity)".  The word "наглядность" (pronounced approximately as "naa-glya-dno-st-th") refers to a quality of concept or idea being easy to imagine and understand, and may be translated as "clarity" as well.  It is to note, that DRAKON language can be used both as modelling\"markup" language (which is considered a standalone "pure DRAKON" program making) and as programming language (as part of a hybrid language). Integration of stricter, "academic" variant of a markup language into programming, which any DRAKON-(programming language used) provides, supposedly (as intended by initial philosophy of DRAKON development) adds syntactic sugar to such extent users of different text programming language can comprehend each other's input into the overall project and criticize it upon necessity.

GitHub description: DRAKON Editor
Drupal (application, appeared 2000)
Origin: Drupal community
Country: Various
Website: https://www.drupal.org


Drupal  is  a free and open source content-management framework written in PHP and distributed under the GNU General Public License. Drupal provides a back-end framework for at least 2.3% of all web sites worldwide – ranging from personal blogs to corporate, political, and government sites. Systems also use Drupal for knowledge management and for business collaboration. As of November 2017, the Drupal community is composed of more than 1.3 million members, including 109,000 users actively contributing, resulting in more than 39,000 free modules that extend and customize Drupal functionality, over 2,500 free themes that change the look and feel of Drupal, and at least 1,180 free distributions that allow users to quickly and easily set up a complex, use-specific Drupal in fewer steps. The standard release of Drupal, known as Drupal core, contains basic features common to content-management systems. These include user account registration and maintenance, menu management, RSS feeds, taxonomy, page layout customization, and system administration. The Drupal core installation can serve as a simple Web site, a single- or multi-user blog, an Internet forum, or a community Web site providing for user-generated content. Drupal also describes itself as a Web application framework. When compared with notable frameworks Drupal meets most of the generally accepted feature requirements for such web frameworks. Although Drupal offers a sophisticated API for developers, basic Web-site installation and administration of the framework require no programming skills. Drupal runs on any computing platform that supports both a Web server capable of running PHP and a database to store content and configuration.
Document Structure Description (xmlFormat, appeared 2000)
Origin: AT&T Labs Research
QinetiQ Ltd
Country: United States and Denmark
Website: https://www.brics.dk/DSD/


Document Structure Description, or DSD, is a schema language for XML, that is, a language for describing valid XML documents. It's an alternative to DTD or the W3C XML Schema. An example of DSD in its simplest form:  <dsd xmlns="http://www.brics.dk/DSD/2.0"  xmlns:my="http://example.com">    <if><element name="my:foo"/>   <declare>    <attribute name="first"/>    <attribute name="second"/>    <contents>     <element name="my:bar"/>    </contents>   </declare>  </if>    <if><element name="my:bar"/>   <declare>    <contents>    </contents>   </declare>  </if>   </dsd>  This says that element named "foo" in the XML namespace "http://example.com" may have two attributes, named "first" and "second". A "foo" element may not have any character data. It must contain one subelement, named "bar", also in the "http://example.com" namespace. A "bar" element is not allowed any attributes, character data or subelements. One XML document that would be valid according to the above DSD would be:  <foo xmlns="http://example.com" second="2">  <bar/> </foo>


<dsd xmlns="http://www.brics.dk/DSD/2.0[permanent dead link]"
 xmlns:my="http://example.com">
 
 <if><element name="my:foo"/>
  <declare>
   <attribute name="first"/>
   <attribute name="second"/>
   <contents>
    <element name="my:bar"/>
   </contents>
  </declare>
 </if>
 
 <if><element name="my:bar"/>
  <declare>
   <contents>
   </contents>
  </declare>
 </if>
 
</dsd>
dslx (pl, appeared 2020)
Origin: Google
Country: United States

DSLX is a domain specific, functional language to build hardware that can also run effectively as host software. The DSL targets the XLS compiler (by conversion to XLS IR) to enable flows for FPGAs and ASICs (note that other frontends will become available in the future). DSLX mimics Rust, while being an immutable expression-based dataflow DSL with hardware-oriented features; e.g. arbitrary bitwidths, entirely fixed size objects, fully analyzeable call graph, etc. To avoid arbitrary new syntax/semantics choices the DSL mimics Rust where it is reasonably possible; for example, integer conversions all follow the same semantics as Rust.



fn cast_to_array(x: u6) -> u2[3] {
  x as u2[3]
}

fn cast_from_array(a: u2[3]) -> u6 {
  a as u6
}

fn concat_arrays(a: u2[3], b: u2[3]) -> u2[6] {
  a ++ b
}

test cast_to_array {
  let a_value: u6 = u6:0b011011;
  let a: u2[3] = cast_to_array(a_value);
  let a_array = u2[3]:[1, 2, 3];
  let _ = assert_eq(a, a_array);
  // Note: converting back from array to bits gives the original value.
  let _ = assert_eq(a_value, cast_from_array(a));

  let b_value: u6 = u6:0b111001;
  let b_array: u2[3] = u2[3]:[3, 2, 1];
  let b: u2[3] = cast_to_array(b_value);
  let _ = assert_eq(b, b_array);
  let _ = assert_eq(b_value, cast_from_array(b));

  // Concatenation of bits is analogous to concatenation of their converted
  // arrays. That is:
  //
  //  convert(concat(a, b)) == concat(convert(a), convert(b))
  let concat_value: u12 = a_value ++ b_value;
  let concat_array: u2[6] = concat_value as u2[6];
  let _ = assert_eq(concat_array, concat_arrays(a_array, b_array));

  // Show a few classic "endianness" example using 8-bit array values.
  let x = u32:0xdeadbeef;
  let _ = assert_eq(x as u8[4], u8[4]:[0xde, 0xad, 0xbe, 0xef]);
  let y = u16:0xbeef;
  let _ = assert_eq(y as u8[2], u8[2]:[0xbe, 0xef]);

  ()
}
dsym (binaryDataFormat, appeared 2011)
Origin: Apple
Country: United States

On Apple platforms, debug symbols are optionally emitted during the build process as dSYM file(s). Apple uses the term "symbolicate" to refer to the replacement of addresses in diagnostic files with human readable values. If you are distributing your app via the App Store, or conducting a beta test using Test Flight, you will be given the option of including the dSYM file when uploading your archive to iTunes Connect. In the submission dialog, check “Include app symbols for your application…”. Uploading your dSYM file is necessary to receive crash reports collected from TestFlight users and customers who have opted to share diagnostic data.
DTD (grammarLanguage, appeared 1996)
Stands for: document type definition
Origin: International Organization for Standardization
Country: Switzerland


A document type definition (DTD) is a set of markup declarations that define a document type for an SGML-family markup language (SGML, XML, HTML). A Document Type Definition (DTD) defines the legal building blocks of an XML document. It defines the document structure with a list of legal elements and attributes. A DTD can be declared inline inside an XML document, or as an external reference. XML uses a subset of SGML DTD. As of 2009, newer XML namespace-aware schema languages (such as W3C XML Schema and ISO RELAX NG) have largely superseded DTDs. A namespace-aware version of DTDs is being developed as Part 9 of ISO DSDL. DTDs persist in applications that need special publishing characters, such as the XML and HTML Character Entity References, which derive from larger sets defined as part of the ISO SGML standard effort.
DTrace (pl, appeared 2005)
Origin: Sun Microsystems
Country: United States
Website: http://dtrace.org/

DTrace is a comprehensive dynamic tracing framework created by Sun Microsystems for troubleshooting kernel and application problems on production systems in real time.

DTrace is a comprehensive dynamic tracing framework created by Sun Microsystems for troubleshooting kernel and application problems on production systems in real time. Originally developed for Solaris, it has since been released under the free Common Development and Distribution License (CDDL) and has been ported to several other Unix-like systems. DTrace can be used to get a global overview of a running system, such as the amount of memory, CPU time, filesystem and network resources used by the active processes. It can also provide much more fine-grained information, such as a log of the arguments with which a specific function is being called, or a list of the processes accessing a specific file. In 2010, Oracle Corporation acquired Sun Microsystems. In October 2011, Oracle announced the porting of DTrace to Linux, but for several years only an unofficial DTrace port to Linux was available, with no changes in licensing terms.In August 2017, Oracle released DTrace kernel code under the GPLv2+ license, and user space code under GPLv2 and UPL licensing. In September 2018 Microsoft announced that they had ported DTrace from FreeBSD to Windows.In September 2016 the OpenDTrace effort began on github with both code and comprehensive documentation of the system's internals.  The OpenDTrace effort maintains the original CDDL licensing for the code from OpenSolaris with additional code contributions coming under a BSD 2 Clause license.  The goal of OpenDTrace is to provide an OS agnostic, portable implementation of DTrace that is acceptable to all consumers, including macOS, FreeBSD, OpenBSD, NetBSD, and Linux as well as embedded systems.


# Syscall count by syscall
dtrace -n 'syscall:::entry { @num[probefunc] = count(); }'
# Syscall count by process
dtrace -n 'syscall:::entry { @num[pid,execname] = count(); }'
.dwg (binaryDataFormat, appeared 1982)
Origin: Autodesk
Open Design Alliance
others
Country: United States

Autodesk estimates that in 1998 there were in excess of two billion DWG files in existence.

DWG (from drawing) is a proprietary binary file format used for storing two- and three- dimensional design data and metadata. It is the native format for several  CAD packages including DraftSight, AutoCAD, IntelliCAD (and its variants), Caddie and Open Design Alliance compliant applications. In addition, DWG is supported non-natively by many other CAD applications. The .bak (drawing backup), .dws (drawing standards), .dwt (drawing template) and .sv$ (temporary automatic save) files are also DWG files.
AutoCAD DXF (application, appeared 1982)
Origin: Autodesk
Country: United States


AutoCAD DXF (Drawing Interchange Format, or Drawing Exchange Format) is a CAD data file format developed by Autodesk for enabling data interoperability between AutoCAD and other programs. DXF was originally introduced in December 1982 as part of AutoCAD 1.0, and was intended to provide an exact representation of the data in the AutoCAD native file format, DWG (Drawing), for which Autodesk for many years did not publish specifications. Because of this, correct imports of DXF files have been difficult. Autodesk now publishes the DXF specifications as a PDF on its website. Versions of AutoCAD from Release 10 (October 1988) and up support both ASCII and binary forms of DXF.  Earlier versions support only ASCII. As AutoCAD has become more powerful, supporting more complex object types, DXF has become less useful. Certain object types, including ACIS solids and regions, are not documented. Other object types, including AutoCAD 2006's dynamic blocks, and all of the objects specific to the vertical market versions of AutoCAD, are partially documented, but not well enough to allow other developers to support them. For these reasons many CAD applications use the DWG format which can be licensed from Autodesk or non-natively from the Open Design Alliance. DXF coordinates are always without dimensions so that the reader or user needs to know the drawing unit or has to extract it from the textual comments in the sheets.
Dylan (pl, appeared 1992)
Origin: Apple
Country: United Kingdom
Website: http://opendylan.org
Keywords: local
in
end
below
until
from
then
for
use
case
elseif
else
by
cleanup
finally
when
begin
above
select
let
if
otherwise
signal
afterwards
unless
while
define
rename
create
to
export


Dylan  is a multi-paradigm programming language that includes support for functional and object-oriented programming, and is dynamic and reflective while providing a programming model designed to support efficient machine code generation, including fine-grained control over dynamic and static behaviors. It was created in the early 1990s by a group led by Apple Computer. A concise and thorough overview of the language may be found in the Dylan Reference Manual. Dylan derives from Scheme and Common Lisp and adds an integrated object system derived from the Common Lisp Object System (CLOS). In Dylan, all values (including numbers, characters, functions, and classes) are first-class objects. Dylan supports multiple inheritance, polymorphism, multiple dispatch, keyword arguments, object introspection, pattern-based syntax extension macros, and many other advanced features. Programs can express fine-grained control over dynamism, admitting programs that occupy a continuum between dynamic and static programming and supporting evolutionary development (allowing for rapid prototyping followed by incremental refinement and optimization). Dylan's main design goal is to be a dynamic language well-suited for developing commercial software. Dylan attempts to address potential performance issues by introducing "natural" limits to the full flexibility of Lisp systems, allowing the compiler to clearly understand compilable units (i.e., libraries). Although deriving much of its semantics from Scheme and other Lisps—some implementations were in fact initially built within existing Lisp systems—Dylan has an ALGOL-like syntax rather than a Lisp-like prefix syntax.
DYNAMO (pl, appeared 1959)
Origin: Massachusetts Institute of Technology
IBM
Country: United States


DYNAMO (DYNAmic MOdels) is a discontinued a simulation language and accompanying graphical notation developed within the system dynamics analytical framework.  It was originally for industrial dynamics but was soon extended to other applications, including population and resource studies and urban planning.DYNAMO was initially developed under the direction of Jay Wright Forrester in the late 1950s, by Dr. Phyllis Fox, Alexander L. Pugh III, Grace Duren, and others at the M.I.T. Computation Center. The earliest versions were written in assembly language for the IBM 704, then for the IBM 709 and IBM 7090.  DYNAMO II was written in AED-0, an extended version of Algol 60. Dynamo II/F, in 1971, generated portable FORTRAN code and both Dynamo II/F and Dynamo III improved the system's portability by being written in FORTRAN.DYNAMO was used for the system dynamics simulations of global resource-depletion reported in the Club of Rome's Limits to Growth. Originally designed for batch processing on mainframe computers, it was made available on minicomputers in the late 1970s, and became available as "micro-Dynamo" on personal computers in the early 1980s. The language went through several revisions from DYNAMO II up to DYNAMO IV in 1983, but has since fallen into disuse.
dyvil (pl, appeared 2014)
Origin: https://github.com/Dyvil
Country: Germany
Website: https://reddit.com/r/Dyvil

<a href='https://github.com/Dyvil/Dyvil'>Dyvil</a> is a multi-paradigm, general purpose programming language that is based on Java and the JVM. It is a compiled, statically and strongly typed language that supports object-oriented, functional and imperative programming styles. The language features many high-level constructs as well as an extensible and expressive syntax, making it highly useful for both rapid and safe prototyping, and the creation of domain-specific languages.


GitHub description: The Dyvil programming language
E (pl, appeared 1997)
Creators: Mark S. Miller
Origin: Combex, Inc.
Country: United States
Website: http://erights.org/

E is an object-oriented programming language for secure distributed computing.

E is an object-oriented programming language for secure distributed computing, created by Mark S. Miller, Dan Bornstein, and others at Electric Communities in 1997.  E is mainly descended from the concurrent language Joule and from Original-E, a set of extensions to Java for secure distributed programming.  E combines message-based computation with Java-like syntax.  A concurrency model based on event loops and promises ensures that deadlock can never occur.


def factorial(n :int) :int {
  if (n == 1) {
    return 1
  } else if (n > 0) {
    return n * factorial(n-1)
  } else {
    throw("invalid argument to factorial: "+n)
  }
}
# E snippet from
# http://wiki.erights.org/wiki/Walnut/Distributed_Computing/Promises
when (tempVow) -> {
    #...use tempVow
} catch prob {
    #.... report problem
} finally {
    #....log event
}
Eagle (application, appeared 1988)
Origin: Autodesk, Inc.
Country: United States


EAGLE is a scriptable electronic design automation (EDA) application with schematic capture, printed circuit board (PCB) layout, auto-router and computer-aided manufacturing (CAM) features. EAGLE stands for Easily Applicable Graphical Layout Editor (German: Einfach Anzuwendender Grafischer Layout-Editor) and is developed by CadSoft Computer GmbH. The company was acquired by Autodesk Inc. in 2016.
Earl Grey (pl, appeared 2014)
Creators: Olivier Breuleux
Origin: https://github.com/breuleux/earl-grey/issues
Country: Canada
Website: https://web.archive.org/web/20200813015200/http://www.earl-grey.io/



GitHub description: Programming language compiling to JavaScript

count-words(text) =
   counts = new Map()
   words = text.split(R"\W+")
   words each word ->
      current-count = counts.get(word) or 0
      counts.set(word, current-count + 1)
   consume(counts.entries()).sort(compare) where
      compare({w1, c1}, {w2, c2}) = c2 - c1