pldb/PLDB huggingface dataset:
XL (pl, appeared 2000)
Creators: Christophe de Dinechin
Website: http://xlr.sourceforge.net/


XL ("eXtensible Language") is the first and so far the only computer programming language designed to support concept programming.XL features programmer-reconfigurable syntax and semantics. Compiler plug-ins can be used to add new features to the language. A base set of plug-ins implements a relatively standard imperative language. Programmers can write their own plug-ins to implement application-specific notations, such as symbolic differentiation, which can then be used as readily as built-in language features.

GitHub description: A minimalist, general-purpose programming language based on meta-programming and parse tree rewrites

0! is 1
N! is N * (N-1)!

for I in 1..5 loop
    print "The factorial of ", I, " is ", I!
XML Metadata Interchange (xmlFormat, appeared 2015)
Stands for: XML Metadata Interchange
Website: https://www.omg.org/spec/XMI/About-XMI/


The XML Metadata Interchange (XMI) is an Object Management Group (OMG) standard for exchanging metadata information via Extensible Markup Language (XML). It can be used for any metadata whose metamodel can be expressed in Meta-Object Facility (MOF). The most common use of XMI is as an interchange format for UML models, although it can also be used for serialization of models of other languages (metamodels).
XML-GL (queryLanguage, appeared 1998)
Creators: Stefano Ceri
Sara Comai
Ernesto Damiani
Piero Fraternali
Stefano Paraboschi
Letizia Tanca

A Graphical Language for Querying and Reshaping XML Documents.  XML-GL is not a visual interface over a conventional, textual query language, but a graph-based query language with both its syntax and semantics defined in terms of graph structures and operations.
XML Query Language (queryLanguage, appeared 1998)

We propose a query language for XML, called XML-QL, as one possible answer to these questions. The language has a SELECT-WHERE construct, like SQL, and borrows features of query languages recently developed by the database research community for semistructured data.



WHERE <book>
        <publisher><name>Addison-Wesley</></>
        <title> $t</>
        <author> $a</>
      </> IN "www.a.b.c/bib.xml"
CONSTRUCT <result>
             <author> $a</>
             <title> $t</>
          </>
XML (dataNotation, appeared 1996)
Stands for: Extensible Markup Language


In computing, Extensible Markup Language (XML) is a markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable. The W3C's XML 1.0 Specification and several other related specifications—all of them free open standards—define XML. The design goals of XML emphasize simplicity, generality, and usability across the Internet. It is a textual data format with strong support via Unicode for different human languages. Although the design of XML focuses on documents, the language is widely used for the representation of arbitrary data structures such as those used in web services. Several schema systems exist to aid in the definition of XML-based languages, while programmers have developed many application programming interfaces (APIs) to aid the processing of XML data.
XMTC (pl, appeared 1990)


XMTC (for explicit multi-threading C) is a shared-memory parallel programming language.  It is an extension of the C programming language which strives to enable easy PRAM-like programming based on the explicit multi-threading paradigm.  It is developed as part of the XMT PRAM-On-Chip vision by a research team at the University of Maryland, College Park, led by Dr. Uzi Vishkin.  The philosophy of XMTC and the whole XMT project is that parallel programming is a hard intellectual task and the approach of building a hardware system first and then figuring out how to program them has not had much success.  For that reason a robust algorithmic theory and a reasonably easy hardware abstraction should be the specifications that guide how to build a new parallel architecture and programming language.  For parallel algorithms the algorithmic theory that has the largest body of literature is called PRAM (parallel random-access machine ).  This is not a coincidence, since PRAM is a natural way in which to think algorithmically in parallel.  In the early 1990s the PRAM model was deemed unrealistic because the hardware abstraction it was based on could not be implemented (because of low inter-chip bandwidth and high latency).  Now that multiple processors can be put on a single chip, these limitations are no longer present. The XMT architecture takes advantage of this excess on-chip real estate to implement a PRAM abstraction. The XMTC language is a modest extension of C and a work in progress.  The basic premise is that the programmer is responsible for exposing all the available parallelism.  While this sounds simple and many earlier approaches share this ideal, in practice, if the programmer defines too large a number of parallel tasks and the tasks are short, the program will perform very poorly. The way around that is to combine short parallel tasks into a longer one, which is usually the responsibility of the programmer.  In XMTC it is possible for the language to do that automatically, lifting the burden from the programmer. Software release of XMTC: PRAM-like programming allows experimenting with XMTC programming on standard computers.
Xoc (compiler, appeared 2008)
Creators: Russ Cox
Tom Bergan†
Austin T. Clements
Frans Kaashoek
Eddie Kohler
Origin: MIT CSAIL
UCLA
Website: https://pdos.csail.mit.edu/archive/xoc/

Today’s system programmers go to great lengths to extend the languages in which they program. For instance, system-specific compilers find errors in Linux and other systems, and add support for specialized control flow to Qt and event-based programs. These compilers are difficult to build and cannot always understand each other’s language changes. However, they can greatly improve code understandability and correctness, advantages that should be accessible to all programmers. We describe an extension-oriented compiler for C called xoc. An extension-oriented compiler, unlike a conventional extensible compiler, implements new features via many small extensions that are loaded together as needed. Xoc gives extension writers full control over program syntax and semantics while hiding many compiler internals. Xoc programmers concisely define powerful compiler extensions that, by construction, can be combined; even some parts of the base compiler, such as GNU C compatibility, are structured as extensions.
XOTcl (pl, appeared 2000)
Creators: Gustaf Neumann
Uwe Zdun


XOTcl is an object-oriented extension for the Tool Command Language created by Gustaf Neumann and Uwe Zdun. It is a derivative of MIT OTcl. XOTcl is based on a dynamic object system with metaclasses which as influenced by CLOS. Class and method definitions are completely dynamic. XOTcl provides language support for design patterns via filters and decorator mixins.
XPages (application, appeared 2008)
Website: http://xpages.info/


XPages is an IBM extension of Java Server Faces with a server side JavaScript runtime and the built-in NoSQL database IBM Domino. It allows data from IBM Notes and Relational Databases to be displayed to browser clients on all platforms. The programming model is based on web development languages and standards including JavaScript, Ajax, Java, the Dojo Toolkit, Server-side JavaScript and JavaServer Faces. XPages uses IBM Domino, IBM's rapid application development platform, including functionality such as the document-oriented database.
XPL (pl, appeared 1967)
Stands for: XPL Programming Language


XPL is a programming language based on PL/I, a portable one-pass compiler written in its own language, and a parser generator tool for easily implementing similar compilers for other languages. XPL was designed in 1967 as a way to teach compiler design principles and as starting point for students to build compilers for their own languages. XPL was designed and implemented by William McKeeman and David B. Wortman at University of California, Santa Cruz and James J. Horning and others at Stanford University. XPL was first announced at the 1968 Fall Joint Computer Conference. The methods and compiler are described in detail in the 1971 textbook A Compiler Generator. They called the combined work a 'compiler generator'. But that implies little or no language- or target-specific programming is required to build a compiler for a new language or new target. A better label for XPL is a translator writing system. It helps to write a compiler with less new or changed programming code.
XPL0 (pl, appeared 1976)


XPL0 is a computer programming language that is essentially a cross between Pascal and C. It was created in 1976 by Peter J. R. Boyle who wanted a high-level language for his microcomputer and wanted something more sophisticated than BASIC, which was the dominant language for personal computers at the time. XPL0 is based on PL/0, an example compiler in the book Algorithms + Data Structures = Programs by Niklaus Wirth. The first XPL0 compiler was written in ALGOL. It generated instructions for a pseudo-machine that was implemented as an interpreter on a Digital Group computer based on the 6502 microprocessor. The compiler was converted from ALGOL to XPL0 and was then able to compile itself and run on a microcomputer. XPL0 soon proved its worth in a variety of products based on the 6502. These embedded systems would otherwise have had their code written in assembly language, which is much more tedious to do. Boyle used XPL0 to write a disk operating system called Apex. Beginning in 1980 this was sold, along with XPL0, as an alternative to Apple DOS for the Apple II computer, which was based on the 6502. Since those early years XPL0 has migrated to other processors and many features have been added. Open source versions of the compilers for IBM-style PCs are available from the link below.
XProc (pl, appeared 1990)


XProc is a W3C Recommendation to define an XML transformation language to define XML Pipelines. Below is an example abbreviated XProc file:  This is a pipeline that consists of two atomic steps, XInclude and Validate. The pipeline itself has three inputs, “source” (a source document), “schemas” (a list of W3C XML Schemas) and  “parameters” (for passing parameters). The XInclude step reads the pipeline input “source” and produces a result document. The Validate step reads the pipeline input “schemas” and the output from the XInclude step and produces a result document. The result of the validation, “result”, is the result of the pipeline. Here is an equivalent less abbreviated XProc pipeline:
XQL (queryLanguage, appeared 1998)
Creators: Hiroshi Ishikawa
Kazumi Kubota
Yasuhiko Kanemasa
Country: Japan

XQL: A Query Language for XML Data



select result:<$book.title, $book.author>
from bib:URL "www.a.b.c/bib.xml", book:$bib.book
where $book.publisher.name ="Addison-Wesley"
groupby $book.title
XQuery (pl, appeared 2007)
Origin: W3C
Website: http://www.w3.org/XML/Query/
File extensions: xq
xql
xqm
xqy
xquery


XQuery (XML Query) is a query and functional programming language that queries and transforms collections of structured and unstructured data, usually in the form of XML, text and with vendor-specific extensions for other data formats (JSON, binary, etc.). The language is developed by the XML Query working group of the W3C. The work is closely coordinated with the development of XSLT by the XSL Working Group; the two groups share responsibility for XPath, which is a subset of XQuery. XQuery 1.0 became a W3C Recommendation on January 23, 2007. XQuery 3.0 became a W3C Recommendation on April 8, 2014. XQuery 3.1 became a W3C Recommendation on March 21, 2017.  "The mission of the XML Query project is to provide flexible query facilities to extract data from real and virtual documents on the World Wide Web, therefore finally providing the needed interaction between the Web world and the database world. Ultimately, collections of XML files will be accessed like databases".
xs (pl, appeared 2019)
Creators: Sturm Mabie

xs is a dynamically typed, dynamically scoped, concatenative array language inspired by kdb+/q and released into the public domain. The interpreter and builtin functions are written in OCaml. The name “xs” either stands for: eXtra Small or The plural of “x”.



gcd:{([`x`y]):..;if y==0(x)(y gcd x mod y)};
XSD (dataValidationLanguage, appeared 2001)
Stands for: XML Schema Definition


XSD (XML Schema Definition), a recommendation of the World Wide Web Consortium (W3C), specifies how to formally describe the elements in an Extensible Markup Language (XML) document. It can be used by programmers to verify each piece of item content in a document. They can check if it adheres to the description of the element it is placed in.Like all XML schema languages, XSD can be used to express a set of rules to which an XML document must conform in order to be considered "valid" according to that schema. However, unlike most other schema languages, XSD was also designed with the intent that determination of a document's validity would produce a collection of information adhering to specific data types. Such a post-validation infoset can be useful in the development of XML document processing software.


<xs:element name="PurchaseOrder" type="PurchaseOrderType"/>

<xs:element name="gift">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="birthday" type="xs:date"/>
   <xs:element ref="PurchaseOrder"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>
xsharp (pl, appeared 2015)
Website: https://www.xsharp.info

X# is an open source development language for .NET, based on the xBase language.



FUNCTION start AS VOID 
 LOCAL oErr AS OBJECT
 LOCAL nI AS LONG
 LOCAL f AS FLOAT
 oErr := Error{} 
 f := Seconds()
 nI := 0
 FOR VAR nX := 1 TO 10_000_000
    IF IsInstanceOf(oErr, #Error)
       nI++
    ENDIF
 NEXT 
 ? Seconds() - f, nI
 f := Seconds()
 FOR VAR nX := 1 TO 10_000_000
    IF oErr IS Error
       nI++
    ENDIF
 NEXT 
 ? Seconds() - f, nI
 WAIT
xt3d (grammarLanguage, appeared 2000)
Creators: Shriram Krishnamurthi
Kathryn E. Gray
Paul T. Graunke

We have designed and implemented xt3d, a highly declarative xml specification language. It demands little more from users than a knowledge of the expected input and desired output. We illustrate the power of xt3d with several examples, including one reminiscent of polytypic programming that greatly simplifies the import of xml values into general-purpose languages. . xt3d is itself an xml language, so users do not need to learn a new surface syntax.  The principal advantage of xt3d over xslt is that it provides an extremely simple, declarative language for describing transformations over xml elements.



<xt3d-output>
 <ul>
  <li><xt3d-use name="name"/></li>
  <li><b><xt3d-use name="num"/></b> <xt3d-.../></li>
  <li><i><xt3d-use name="fmt"/></i> <xt3d-.../></li>
 </ul>
</xt3d-output>
xTAO Modeling Language (xmlFormat, appeared 2005)
Also known as: xTAO

Enabling a declarative approach to the specification of multi-agent systems



<Goal>
 <Name>table_comparison</Name>
 <DesiredState>
 <Description>
 <Name>compareOK</Name>
 <LanguageName>TAOLanguage</LanguageName>
 <Data>srcTable EQ destTable |
 srcTable NEQ destTable | NO</Data>
 </Description>
 </DesiredState>
 <Params>
 <Description>
 <Name>srcTable</Name>
 <LanguageName/>
 <Data/>
 </Description>
 <Description>
 <Name>destTable</Name>
 <LanguageName/>
 <Data/>
 </Description>
 </Params>
</Goal>
Xtend (pl, appeared 2011)
Creators: Sven Efftinge
Sebastian Zarnekow
Website: http://www.xtend-lang.org


Xtend is a general-purpose high-level programming language for the Java Virtual Machine. Syntactically and semantically Xtend has its roots in the Java programming language but focuses on a more concise syntax and some additional functionality such as type inference, extension methods, and operator overloading. Being primarily an object-oriented language, it also integrates features known from functional programming, e.g. lambda expressions. Xtend is statically typed and uses Java's type system without modifications. It is compiled to Java code and thereby seamlessly integrates with all existing Java libraries. The language Xtend and its IDE is developed as a project at Eclipse.org and participates in the annual Eclipse release train. The code is open source under the Eclipse Public License. Yet, the language can be compiled and run independent of the Eclipse platform.
Xtext (grammarLanguage, appeared 2006)
Website: https://www.eclipse.org/Xtext/
File extensions: xtext


Xtext is an open-source software framework for developing programming languages and domain-specific languages (DSLs). Unlike standard parser generators, Xtext generates not only a parser, but also a class model for the abstract syntax tree, as well as providing a fully featured, customizable Eclipse-based IDE.Xtext is being developed in the Eclipse Project as part of the Eclipse Modeling Framework Project and is licensed under the Eclipse Public License.

GitHub description: Eclipse Xtext™ is a language development framework 

grammar org.eclipse.xtext.common.Terminals 
    hidden(WS, ML_COMMENT, SL_COMMENT)
 
import "http://www.eclipse.org/emf/2002/Ecore" as ecore
 
terminal ID: 
    '^'?('a'..'z'|'A'..'Z'|'_')('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
 
terminal INT returns ecore::EInt: 
    ('0'..'9')+;
 
terminal STRING: 
    '"' ( '\\'('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') | !('\\'|'"') )* '"' |
    "'" ( '\\'('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') | !('\\'|"'") )* "'";
 
terminal ML_COMMENT: 
    '/*' -> '*/';
 
terminal SL_COMMENT: 
    '//' !('\n'|'\r')* ('\r'? '\n')?;
 
terminal WS: 
    (' '|'\t'|'\r'|'\n')+;
 
terminal ANY_OTHER: 
    .;
XUML (pl, appeared 2002)


Executable UML (xtUML or xUML) is both a software development method and a highly abstract software language. It was described for the first time in 2002 in the book "Executable UML: A Foundation for Model-Driven Architecture". The language "combines a subset of the UML (Unified Modeling Language) graphical notation with executable semantics and timing rules." The Executable UML method is the successor to the Shlaer–Mellor method. Executable UML models "can be run, tested, debugged, and measured for performance.", and can be compiled into a less abstract programming language to target a specific implementation. Executable UML supports model-driven architecture (MDA) through specification of platform-independent models, and the compilation of the platform-independent models into platform-specific models.
xxl (pl, appeared 2016)



GitHub description: a minimal vector programming language

// enclose (c)urly(b)races, (s)quare(b)brackets, (q)uotes:
'ecb is {"{",x,"}"}; 'esb is {"[",x,"]"}; 'eq is {"\"",x,"\""}; 
'jc is {join ","}; 'jac is {each y jc};  // join x with commas; apply y to each of x then join with commas
'pair is {encode,":",(y encode)};        // key:val pair for dict
'dict is {key as 'k; x val as 'v; [k],v >: pair jc ecb}; // get keys/vals, pair merge, commas, braces
// wrap non-scalar values in appropriate way:
'many is {as 'el type case ('char, {el str eq}, 'dict, {el dict}, {el jac encode esb})};
'encode is {ravel[many,str]};            // ravel calls x y[0] for arrays (len > 1), x y[1] for scalars
Yabasic (pl, appeared 1995)


Yabasic (Yet Another BASIC) is a free and open-source BASIC interpreter for Windows and Unix platforms. Yabasic was originally developed by Marc-Oliver Ihm, who released the last stable version 2.77.3 in 2016. From version 2.77.1, the project has adopted the MIT Licence as well as the source code being moved to GitHub to encourage others to participate in its development.
Yacas (pl, appeared 1999)
Stands for: Yet Another Computer Algebra System
Website: http://www.yacas.org/

a general-purpose computer algebra system. The name is an acronym for Yet Another Computer Algebra System.

Yacas  is a general-purpose computer algebra system.  The name is an acronym for Yet Another Computer Algebra System. Released under the GNU Lesser General Public License, Yacas is free software. YACAS is a program for symbolic manipulation of mathematical expressions. It uses its own programming language designed for symbolic as well as arbitrary-precision numerical computations. The system has a library of scripts that implement many of the symbolic algebra operations; new algorithms can be easily added to the library. YACAS comes with extensive documentation covering the scripting language, the functionality that is already implemented in the system, and the algorithms used. Its development started in early 1999.Yacas handles input and output in plain ASCII or in OpenMath, either interactively or in batch mode.


record["name"]:="Isaia";
record["occupation"]:="prophet";
record["is alive"]:=False;
Yacc (grammarLanguage, appeared 1975)
Stands for: Yet Another Compiler-Compiler
Country: United States


Yacc (Yet Another Compiler-Compiler) is a computer program for the Unix operating system. It is a Look Ahead Left-to-Right (LALR) parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specifically a LALR parser, based on an analytic grammar written in a notation similar to Backus–Naur Form (BNF). Yacc itself used to be available as the default parser generator on most Unix systems, though it has since been supplanted as the default by more recent, largely compatible, programs.
YAML (dataNotation, appeared 2001)
Stands for: YAML Ain't Markup Language
Website: http://www.yaml.org/spec/1.2/spec.html#Introduction


YAML (YAML Ain't Markup Language) is a human-readable data serialization language. It is commonly used for configuration files, but could be used in many applications where data is being stored (e.g. debugging output) or transmitted (e.g. document headers). YAML targets many of the same communications applications as XML, but has taken a more minimal approach which intentionally breaks compatibility with SGML. YAML 1.2 is a superset of JSON, another minimalist data serialization format where braces and brackets are used instead of indentation. Custom data types are allowed, but YAML natively encodes scalars (such as strings, integers, and floats), lists, and associative arrays (also known as hashes or dictionaries). These data types are based on the Perl programming language, though all commonly used high-level programming languages share very similar concepts. YAML supports both Python-style indentation to indicate nesting, and a more compact format that uses [] for lists and {} for hashes. The colon-centered syntax used to express key-value pairs is inspired by electronic mail headers as defined in RFC 0822, and the document separator "---" is borrowed from MIME (RFC 2045). Escape sequences are reused from C, and whitespace wrapping for multi-line strings is inspired from HTML. Lists and hashes can contain nested lists and hashes, forming a tree structure; arbitrary graphs can be represented using YAML aliases (similar to XML in SOAP). YAML is intended to be read and written in streams, a feature inspired by SAX. Support for reading and writing YAML is available for several programming languages. Some source code editors such as Emacs and various integrated development environments have features that make editing YAML easier, such as folding up nested structures or automatically highlighting syntax errors.
YAP (pl, appeared 1985)


YAP is an open-source, high-performance implementation of the Prolog  programming language developed at LIACC/Universidade do Porto and at COPPE Sistemas/UFRJ. Its Prolog engine is based in the WAM (Warren Abstract Machine), with several optimizations for better performance. YAP follows the Edinburgh tradition, and is largely compatible with the ISO-Prolog standard and with Quintus Prolog and SICStus Prolog. YAP has been developed since 1985. The original version was written in assembly, C and Prolog, and achieved high performance on m68k-based machines.