pldb/PLDB huggingface dataset:
txr (pl, appeared 2009)
Creators: Kaz Kylheku
Website: http://www.nongnu.org/txr/

Programming Language for Convenient Data Munging



@(bind special-words ("arch." "var." "ver." "anci." "fam."))
@(bind ahash @(hash :equal-based))
@(repeat)
@id @@ @alpha @@ @animal @@ @words
@  (rebind words @(split-str words " "))
@  (bind record (id alpha animal words))
@  (do (push record [ahash alpha]))
@(end)
@(bind sorted-rec-groups nil)
@(do
   (defun popularity-sort (recs)
     (let ((histogram [group-reduce (hash)
                                    third (do inc @1)
                                    recs 0]))
      [sort recs > [chain third histogram]]))

   (dohash (key records ahash)
     (let (contains does-not combined)
       (each* ((r records)
               (w [mapcar fourth r]))
         (if (isec w special-words)
           (push r contains)
           (push r does-not)))
       (push (append (popularity-sort does-not)                                 
                     (popularity-sort contains))                                
             sorted-rec-groups)))
   (set sorted-rec-groups [sort sorted-rec-groups :
                                [chain first second]]))
@(output)
@  (repeat)
@    (repeat)
@(rep)@{sorted-rec-groups} @@ @(last)@{sorted-rec-groups " "}@(end)
@    (end)
@  (end)
@(end)
Txt2tags (textMarkup, appeared 2001)
Creators: Aurelio Jargas
Florent Gallaire
Jendrik Seipp
Website: http://txt2tags.org/


txt2tags is a document generator software that uses a lightweight markup language. txt2tags is free software under GNU General Public License. Written in Python, it can export documents to several formats including: HTML, XHTML, SGML, LaTeX, Lout, roff, MediaWiki, Google Code Wiki, DokuWiki, MoinMoin, MagicPoint, PageMaker and plain text.


**bold text**
//italic text//
``monospace text``
__underlined__
--strike-through--
txtzyme (pl, appeared 2010)
Creators: Ward Cunningham
Website: http://txtzyme.com/welcome-visitors.html

Txtzyme was created around 2010-2012 by Ward Cunningham.  Txtzyme has the advantage that it is specifically oriented to I/O control and interaction - yet surprisingly simple.


GitHub description: DIY DSL Interpreter for Teensy (Arduino-like) Controllers
Tymshare SuperBasic (pl, appeared 1968)


Tymshare, Inc. was a time-sharing service and third-party hardware maintenance company competing with companies such as Four-Phase Systems, CompuServe, and Digital Equipment Corporation (DEC, Digital). Tymshare developed or acquired innovative technologies, including data networking (Tymnet), electronic data interchange (EDI), credit card and payment processing (Transaction Tracking System, Western29), telecommunications provisioning (COEES), office automation (August, Augment) and database technology (Magnum).  It was headquartered in Cupertino, California from 1964 to 1984. The computing platforms included the SDS 940, XDS 940 (Tymcom-IX), XDS Sigma 7, DEC PDP-10 models KA, KI, KL and KS (Tymcom-X/XX, Tenex, August, Tops-20), XKL Toad-1, IBM 360 & 370 (VM, MVS, GNOSIS) servers. Divisions:  INSD — Information Services Division STD — Systems Technology Division DND — Data Networks DivisionIn 1984 Tymshare was acquired by McDonnell Douglas, restructured, split up and portions were resold, spun off, and merged with other companies from 1984 through 2004 when most of its legacy network was finally shut down.  Islands of its network technology continued as part of EDI, at least into 2008. McDonnell Douglas was acquired by Boeing.  Consequently, rights to use technology developed by Tymshare are currently held by Boeing, British Telecom (BT), Verizon Communications, and AT&T Inc. due to the acquisitions and mergers from 1984 through 2005.
Tynker (visual, appeared 2012)
Website: https://www.tynker.com/


Tynker is an educational programming platform aimed at teaching children how to make games and programs.  Instead of typing the source code, you visually drag blocks of code and snap them together. The visual design and principles are based on the free Scratch, just like Hopscotch and Snap!. Tynker is based on HTML5 and JavaScript, and can be used in the browser without plugins, as well as on tablets and smartphones. Another difference is that Scratch is a free open source project, while Tynker is a commercial product, aimed at selling courses. Tynker offers self-paced online courses for children to learn coding at home, as well as an engaging programming curriculum for schools and camps. It makes it easier for kids to learn coding as it teaches kids coding through creating games like Minecraft, Hour of Code etc.
TypeScript (pl, appeared 2012)
Creators: Anders Hejlsberg
Origin: Microsoft
Website: http://www.typescriptlang.org/
File extensions: ts
tsx


TypeScript is a free and open-source programming language developed and maintained by Microsoft. It is a strict syntactical superset of JavaScript, and adds optional static typing to the language. Anders Hejlsberg, lead architect of C# and creator of Delphi and Turbo Pascal, has worked on the development of TypeScript. TypeScript may be used to develop JavaScript applications for client-side or server-side (Node.js) execution. TypeScript is designed for development of large applications and compiles to JavaScript. As TypeScript is a superset of JavaScript, existing JavaScript programs are also valid TypeScript programs. TypeScript supports definition files that can contain type information of existing JavaScript libraries, much like C++ header files can describe the structure of existing object files. This enables other programs to use the values defined in the files as if they were statically typed TypeScript entities. There are third-party header files for popular libraries such as jQuery, MongoDB, and D3.js. TypeScript headers for the Node.js basic modules are also available, allowing development of Node.js programs within TypeScript. The TypeScript compiler is itself written in TypeScript and compiled to JavaScript. It is licensed under the Apache 2 License. TypeScript is included as a first-class programming language in Microsoft Visual Studio 2013 Update 2 and later, beside C# and other Microsoft languages. An official extension allows Visual Studio 2012 to support TypeScript as well.

GitHub description: TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
Typographical Number Theory (notation, appeared 1979)
Creators: Douglas Hofstadter


Typographical Number Theory (TNT) is a formal axiomatic system describing the natural numbers that appears in Douglas Hofstadter's book Gödel, Escher, Bach.  It is an implementation of Peano arithmetic that Hofstadter uses to help explain Gödel's incompleteness theorems. Like any system implementing the Peano axioms, TNT is capable of referring to itself (it is self-referential).
U (pl, appeared 2013)
Creators: Yassen Bantchev
Website: http://www.math.bas.bg/bantchev/place/u.html

U is a small functional programming language, designed mainly for explorational and educational uses. Both its syntax and its operational rules are very simple and regular. U can be considered a functional-style calculator for several useful types of data, preloaded with a large number of built-in operators and extensible through defining new ones.


GitHub description: Implementation of the U programming language
Ubercode (pl, appeared 2005)


Ubercode is a high level programming language designed by Ubercode Software and released in 2005 for Microsoft Windows. Ubercode is influenced by Eiffel and BASIC. It is commercial software and can be tried out for free for 30 days. Ubercode has the following design goals:  Compilable language—compiled into Windows EXE files. Automatic memory management—memory is allocated / freed automatically, and the language has no memory management primitives. Pre and post conditions—these are run-time assertions which are attached to function declarations, as in Eiffel. High-level data types—resizable arrays, lists and tables may contain arbitrary components. Integrated file handling—primitives for transparent handling of text, binary, CSV, XML and dBase files. Ease of use—language structure is relatively simple, making the language accessible to beginners.
UCG (dataNotation, appeared 2017)
Stands for: Universal Configuration Grammar
Creators: Jeremy Wall
Website: https://ucg.marzhillstudios.com/
File extensions: ucg

UCG is a universal grammar for configuration. UCG's goal is not to define a configuration format like JSON, YAML, or TOML. It is not intended to replace the other serialization formats. Instead it is intended to provide a common grammar for generating those formats.


GitHub description: A Universal Configuration Grammar

let db_confs = import "db/mysql/hosts.ucg";
let consul_hosts = import "services/consul/hosts.ucg".host_pool;

let conf = {
    port = 8888,
    addr = "0.0.0.0",
    db = {
        host = db_confs.host_pool.addr,
        port = db_confs.host_pool.port,
        database = "myservicedb",
    },
    config_svc = consul_hosts.url,
};

out json conf;
UCL (dataNotation, appeared 2013)
Stands for: Universal Configuration Language



GitHub description: Universal configuration library parser

param = value;
section {
    param = value;
    param1 = value1;
    flag = true;
    number = 10k;
    time = 0.2s;
    string = "something";
    subsection {
        host = {
            host = "hostname";
            port = 900;
        }
        host = {
            host = "hostname";
            port = 901;
        }
    }
}
UDP (protocol, appeared 1980)
Stands for: User Datagram Protocol


In computer networking, the User Datagram Protocol (UDP) is one of the core members of the Internet protocol suite. The protocol was designed by David P. Reed in 1980 and formally defined in RFC 768. With UDP, computer applications can send messages, in this case referred to as datagrams, to other hosts on an Internet Protocol (IP) network. Prior communications are not required in order to set up communication channels or data paths. UDP uses a simple connectionless communication model with a minimum of protocol mechanism. UDP provides checksums for data integrity, and port numbers for addressing different functions at the source and destination of the datagram. It has no handshaking dialogues, and thus exposes the user's program to any unreliability of the underlying network; There is no guarantee of delivery, ordering, or duplicate protection. If error-correction facilities are needed at the network interface level, an application may use the Transmission Control Protocol (TCP) or Stream Control Transmission Protocol (SCTP) which are designed for this purpose. UDP is suitable for purposes where error checking and correction are either not necessary or are performed in the application; UDP avoids the overhead of such processing in the protocol stack. Time-sensitive applications often use UDP because dropping packets is preferable to waiting for packets delayed due to retransmission, which may not be an option in a real-time system.
ugBASIC (pl, appeared 2021)
Creators: Marco Spedaletti
Origin: https://github.com/spotlessmind1975/ugbasic/issues
Country: Italy
Website: https://ugbasic.iwashere.eu
File extensions: .bas

ugBASIC is an isomorphic and open source language, fully documented and designed to develop portable programs, without sacrificing efficiency. With a single source it is therefore possible to create games for numerous 8 bit platforms.


GitHub description: An isomorphic BASIC language compiler for retrocomputers
UIML (xmlFormat, appeared 2005)
Also known as: UsiXML


UIML (User Interface Markup Language) is an XML-based user interface markup language for defining user interfaces on computers. Basically UIML tries to reduce the work needed to develop user interfaces. It allows you to describe the user interface in declarative terms (i.e. as text) and abstract it. Abstracting means that you don't exactly specify how the user interface is going to look, but rather what elements are to be shown, and how should they behave. For example, to describe a message window, you could write:  In theory then you could use that description to generate user interfaces for different platforms, like PDAs. In practice, the different capabilities of those different platforms make a complete translation difficult. Other less ambitious domain-specific programming languages attempt only to describe the user interfaces (or other parts of the application or process) in a domain (for example Windows). See for example the Microsoft language XAML. These languages do a better job usually, but are less flexible. Today, UIML is being standardized by OASIS.A separate effort with the same goals as UIML is UsiXML.
ulisp (pl, appeared 2016)
Creators: David Johnson-Davies
Website: http://www.ulisp.com/show?3J

uLisp® is a version of the Lisp programming language specifically designed to run on microcontrollers with a limited amount of RAM.


GitHub description: A version of the Lisp programming language for ATmega-based Arduino boards.

(defun b (x) (pinmode 13 t) (digitalwrite 13 x) (delay 500) (b (not x)))
UML (xmlFormat, appeared 1996)
Stands for: Unified Modeling Language


The Unified Modeling Language (UML) is a general-purpose, developmental, modeling language in the field of software engineering, that is intended to provide a standard way to visualize the design of a system. UML was originally motivated by the desire to standardize the disparate notational systems and approaches to software design developed by Grady Booch, Ivar Jacobson and James Rumbaugh at Rational Software in 1994–1995, with further development led by them through 1996. In 1997 UML was adopted as a standard by the Object Management Group (OMG), and has been managed by this organization ever since. In 2005 UML was also published by the International Organization for Standardization (ISO) as an approved ISO standard. Since then the standard has been periodically revised to cover the latest revision of UML.


<?xml version="1.0"?>
<XMI xmi.version="1.2" xmlns:UML="org.omg/UML/1.4">
 <XMI.header>
  <XMI.documentation>
   <XMI.exporter>ananas.org stylesheet</XMI.exporter>
  </XMI.documentation>
  <XMI.metamodel xmi.name="UML" xmi.version="1.4"/>
 </XMI.header>
 <XMI.content>
  <UML:Model xmi.id="M.1" name="address" visibility="public"
              isSpecification="false" isRoot="false"
              isLeaf="false" isAbstract="false">
   <UML:Namespace.ownedElement>
    <UML:Class xmi.id="C.1" name="address" visibility="public"
               isSpecification="false" namespace="M.1" isRoot="true"
               isLeaf="true" isAbstract="false" isActive="false">
     <UML:Classifier.feature>
      <UML:Attribute xmi.id="A.1" name="name" visibility="private"
                     isSpecification="false" ownerScope="instance"/>
      <UML:Attribute xmi.id="A.2" name="street" visibility="private"
                     isSpecification="false" ownerScope="instance"/>
      <UML:Attribute xmi.id="A.3" name="zip" visibility="private"
                     isSpecification="false" ownerScope="instance"/>
      <UML:Attribute xmi.id="A.4" name="region" visibility="private"
                     isSpecification="false" ownerScope="instance"/>
      <UML:Attribute xmi.id="A.5" name="city" visibility="private"
                     isSpecification="false" ownerScope="instance"/>
      <UML:Attribute xmi.id="A.6" name="country" visibility="private"
                     isSpecification="false" ownerScope="instance"/>
     </UML:Classifier.feature>
    </UML:Class>
   </UML:Namespace.ownedElement>
  </UML:Model>
 </XMI.content>
</XMI>
UNCOL (ir, appeared 1958)


UNCOL (Universal Computer Oriented Language) was a proposed universal intermediate language for compilers introduced by Melvin E. Conway in 1958. It was never fully specified or implemented; in many ways it was more a concept than a language. UNCOL was intended to make compilers economically available for each new instruction set architecture and programming language. Each machine architecture would require just one compiler back end, and each programming language would require one compiler front end. This was a very ambitious goal in 1961 because compiler technology was in its infancy, and little was standardized in computer hardware and software. The concept of such a universal intermediate language is old: the SHARE report (1958) already says "[it has] been discussed by many independent persons as long ago as 1954." Macrakis (1993) summarizes its fate:  UNCOL was an ambitious effort for the early 1960s. An attempt to solve the compiler-writing problem, it ultimately failed because language and compiler technology were not yet mature. In the 1970s, compiler-compilers ultimately contributed to solving the problem that UNCOL set itself: the economical production of compilers for new languages and new machines.  UNCOL is sometimes used as a generic term for the idea of a universal intermediate language. The Architecture Neutral Distribution Format is an example of an UNCOL in this sense.
Unicode (characterEncoding, appeared 1987)


Unicode is a computing industry standard for the consistent encoding, representation, and handling of text expressed in most of the world's writing systems. The latest version contains a repertoire of 136,755 characters covering 139 modern and historic scripts, as well as multiple symbol sets. The Unicode Standard is maintained in conjunction with ISO/IEC 10646, and both are code-for-code identical. The Unicode Standard consists of a set of code charts for visual reference, an encoding method and set of standard character encodings, a set of reference data files, and a number of related items, such as character properties, rules for normalization, decomposition, collation, rendering, and bidirectional display order (for the correct display of text containing both right-to-left scripts, such as Arabic and Hebrew, and left-to-right scripts). As of June 2017, the most recent version is Unicode 10.0. The standard is maintained by the Unicode Consortium. Unicode's success at unifying character sets has led to its widespread and predominant use in the internationalization and localization of computer software. The standard has been implemented in many recent technologies, including modern operating systems, XML, Java (and other programming languages), and the .NET Framework. Unicode can be implemented by different character encodings. The Unicode standard defines UTF-8, UTF-16, and UTF-32, and several other encodings are in use. The most commonly used encodings are UTF-8, UTF-16 and UCS-2, a precursor of UTF-16. UTF-8, dominantly used by websites (over 90%), uses one byte for the first 128 code points, and up to 4 bytes for other characters. The first 128 Unicode code points are the ASCII characters; so an ASCII text is a UTF-8 text. UCS-2 simply uses two bytes (16 bits) for each character but can only encode the first 65,536 code points, the so-called Basic Multilingual Plane (BMP). With 1,114,112 code points on 17 planes being possible, and with over 120,000 code points defined so far, many Unicode characters are beyond the reach of UCS-2. Therefore, UCS-2 is obsolete, though still widely used in software. UTF-16 extends UCS-2, by using the same 16-bit encoding as UCS-2 for the Basic Multilingual Plane, and a 4-byte encoding for the other planes. As long as it contains no code points in the reserved range U+0D800-U+0DFFF, a UCS-2 text is a valid UTF-16 text. UTF-32 (also referred to as UCS-4) uses four bytes for each character. Like UCS-2, the number of bytes per character is fixed, facilitating character indexing; but unlike UCS-2, UTF-32 is able to encode all Unicode code points. However, because each character uses four bytes, UTF-32 takes significantly more space than other encodings, and is not widely used.
Unicon (pl, appeared 2008)
Creators: Clint Jeffery
Website: http://www.unicon.org/


Unicon is a programming language designed by American computer scientist Clint Jeffery with collaborators including Shamim Mohamed, Jafar Al Gharaibeh, Robert Parlett and others. Unicon descended from Icon and a preprocessor for Icon called IDOL. Compared with Icon, Unicon offers better access to the operating system as well as support for object-oriented programming. Unicon began life as a merger of three popular Icon extensions: an OO preprocessor named Idol, a POSIX filesystem and networking interface, and an ODBC facility. The name is shorthand for "Unified Extended Dialect of Icon." Compared with Icon, many of the new features of Unicon are extensions to the I/O and system interface, to complement Icon's core control and data structures. Rather than providing lower-level APIs as-is from C, Unicon implements higher level and easier to use facilities, enabling rapid development of graphic- and network-intensive applications in addition to Icon's core strengths in text and file processing. classes and packages exceptions as a contributed class library - see mailing list loadable child programs monitoring of child programs dynamic loading of C modules (some platforms) multiple inheritance, with novel semantics ODBC database access dbm files can be used as associative arrays posix system interface 3D graphics true concurrency (on platforms supporting Posix threads) When run as a graphical IDE, the Unicon program ui.exe continues to offer links to Icon help. The official Unicon programming book in PDF format is a popular way to learn Unicon. The book includes an introduction to object-oriented development as well as UML. It includes useful chapters on topics such as the use of Unicon for CGI. Recent additions to Unicon include true concurrency. Unicon is not yet Unicode-compliant. There are opportunities posted at a help-wanted page.


procedure main()
 w := open("test UNICON window", "g")
 write(w, "Hello, World!")
 read(w)
 close(w)
end
Uniface (pl, appeared 1994)
Website: http://uniface.com


Uniface is a development and deployment platform for enterprise applications that can run in a large range of runtime environments, including mobile, mainframe, web, Service-oriented architecture (SOA), Windows, Java EE and .NET.  Uniface is a model-driven, Rapid Application Development (RAD) environment used to create mission-critical applications. Uniface applications are database- and platform-independent. Uniface provides an integration framework that enables Uniface applications to integrate with all major DBMS products such as Oracle, Microsoft SQL Server, MySQL and IBM DB2. In addition, Uniface also supports file systems such as RMS (HP OpenVMS), Sequential files, operating system text files  and a wide range of other technologies, such as mainframe-based products (CICS, IMS), web services, SMTP and POP email, LDAP directories, .NET, ActiveX, Component Object Model (COM), C(++) programs, and Java. Uniface operates under Microsoft Windows, Windows Mobile, various flavors of Unix and Linux, VMS, IBM iSeries, and  z/OS. Uniface can be used in complex systems that maintain critical enterprise data supporting mission-critical business processes such as point-of sale and web-based online shopping, financial transactions, salary administration, and inventory control. It is currently used by thousands of companies in more than 30 countries, with an effective installed base of millions of end-users. Uniface applications range from client/server to web, and from data entry to workflow, as well as portals that are accessed locally, via intranets and the internet. Originally developed in the Netherlands by Inside Automation, later Uniface B.V., the product and company were acquired by Detroit-based Compuware Corp in 1994, and in 2014 was acquired by Marlin Equity Partners and is now an independent company. Uniface B.V. global headquarters are in Amsterdam.