pldb/PLDB huggingface dataset:
Unified Diff (diffFormat, appeared 1990)
Also known as: unidiff
Creators: Wayne Davison
Origin: comp.sources.misc




--- /path/to/original	timestamp
+++ /path/to/new	timestamp
@@ -1,3 +1,9 @@
+This is an important
+notice! It should
+therefore be located at
+the beginning of this
+document!
+
 This part of the
 document has stayed the
 same from version to
@@ -8,13 +14,8 @@
 compress the size of the
 changes.

-This paragraph contains
-text that is outdated.
-It will be deleted in the
-near future.
-
 It is important to spell
-check this dokument. On
+check this document. On
 the other hand, a
 misspelled word isn't
 the end of the world.
@@ -22,3 +23,7 @@
 this paragraph needs to
 be changed. Things can
 be added after it.
+
+This paragraph contains
+important new additions
+to this document.
UPC (pl, appeared 2003)
Origin: UPC Consortium
Website: http://upc.lbl.gov/


Unified Parallel C (UPC) is an extension of the C programming language designed for high-performance computing on large-scale parallel machines, including those with a common global address space (SMP and NUMA) and those with distributed memory (e.g. clusters). The programmer is presented with a single shared, partitioned address space, where variables may be directly read and written by any processor, but each variable is physically associated with a single processor. UPC uses a single program, multiple data (SPMD) model of computation in which the amount of parallelism is fixed at program startup time, typically with a single thread of execution per processor. In order to express parallelism, UPC extends ISO C 99 with the following constructs:  An explicitly parallel execution model A shared address space Synchronization primitives and a memory consistency model Explicit communication primitives, e.g. upc_memput Memory management primitivesThe UPC language evolved from experiences with three other earlier languages that proposed parallel extensions to ISO C 99: AC, Split-C, and Parallel C preprocessor (PCP). UPC is not a superset of these three languages, but rather an attempt to distill the best characteristics of each. UPC combines the programmability advantages of the shared memory programming paradigm and the control over data layout and performance of the message passing programming paradigm.
Unity (library, appeared 2005)
Website: https://unity3d.com


Unity is a cross-platform game engine developed by Unity Technologies, first announced and released in June 2005 at Apple Inc.'s Worldwide Developers Conference as an OS X-exclusive game engine. As of 2018, the engine has been extended to support 27 platforms. The engine can be used to create both three-dimensional and two-dimensional games as well as simulations for its many platforms. Several major versions of Unity have been released since its launch, with the latest stable version being Unity 2018.2.13, released on October 18, 2018.
UNITY (pl, appeared 1988)


UNITY is a programming language constructed by K. Mani Chandy and Jayadev Misra for their book Parallel Program Design: A Foundation. It is a theoretical language which focuses on what, instead of where, when or how. The language contains no method of flow control, and program statements run in a nondeterministic way until statements cease to cause changes during execution. This allows for programs to run indefinitely, such as auto-pilot or power plant safety systems, as well as programs that would normally terminate (which here converge to a fixed point).


Program bubblesort
declare
    n: integer,
    A: array [0..n-1] of integer
initially
    n = 20 #
    <|| i : 0 <= i and i < n :: A[i] = rand() % 100 >
assign
    <# k : 0 <= k < 2 ::
        <|| i : i % 2 = k and 0 <= i < n - 1 ::
            A[i], A[i+1] := A[i+1], A[i] 
                if A[i] > A[i+1] > >
end
UniVerse (pl, appeared 1997)


Rocket U2 is a suite of database management (DBMS) and supporting software now owned by Rocket Software.  It includes two MultiValue database platforms: UniData and UniVerse.  Both of these products are operating environments which run on current Unix, Linux and Windows operating systems.  They are both derivatives of the Pick operating system. The family also includes developer and web-enabling technologies including SystemBuilder/SB+, SB/XA, U2 Web Development Environment (WebDE), UniObjects and wIntegrate.
UNLAMBDA (esolang, appeared 1999)
Creators: David Madore
Country: United States
Website: http://www.madore.org/~david/programs/unlambda/


Unlambda is a minimal, "nearly pure" functional programming language invented by David Madore. It is based on combinatory logic, a version of the lambda calculus that omits the lambda operator. It relies mainly on two built-in functions (s and k) and an apply operator (written `, the backquote character). These alone make it Turing-complete, but there are also some input/output (I/O) functions to enable interacting with the user, some shortcut functions, and a lazy evaluation function. Variables are unsupported. Unlambda is free and open-source software distributed under a GNU General Public License (GPL) 2.0 or later.
Uno (pl, appeared 2002)
Website: https://fuseopen.com

The Uno langauge is a dialect of C#, designed for cross-compilation to C++ and other languages. Uno does not require the .NET Framework, but has instead a more lightweight library called UnoCore. The syntax of Uno is more or less identical to C#, with deviations documented here.


GitHub description: Extremely fast, native C#-dialect and powerful tooling for mobile and desktop developers
UnQL (queryLanguage, appeared 2011)
Stands for: Unstructured Query Language
Creators: Richard Hipp
Damien Katz

UnQL is a database query language, akin to SQL, but designed for modern document-oriented databases. SQL assumes a rigidly defined data schema. Each table has a fixed number of columns and each column has a defined datatype. UnQL assumes a more flexible approach to storing data. Instead of "tables", UnQL uses "collections". (The concept is the same, but the name is changed since "tables" are square whereas "collections" can be of varying shape.) Each collection consists of zero or more documents represented as JSON strings. A document in UnQL corresponds to a row in SQL



SELECT {articleout:cool_nosql_collection.docNumber} FROM cool_nosql_collection
UnrealScript (pl, appeared 1998)


The Unreal Engine is a game engine developed by Epic Games, first showcased in the 1998 first-person shooter game Unreal. Although primarily developed for first-person shooters, it has been successfully used in a variety of other genres, including stealth, fighting games, MMORPGs, and other RPGs. With its code written in C++, the Unreal Engine features a high degree of portability and is a tool used by many game developers today, with it being source-available. The most recent version is Unreal Engine 4, which was released to the public in 2014.
UPIC (pl, appeared 2018)


UPIC (Unité Polyagogique Informatique CEMAMu) is a computerised musical composition tool, devised by the composer Iannis Xenakis. It was developed at the Centre d'Etudes de Mathématique et Automatique Musicales (CEMAMu) in Paris, and was completed in 1977. Xenakis used it on his subsequent piece Mycènes Alpha (1978), and it has been used by composers such as Jean-Claude Risset (on Saxatile (1992)), François-Bernard Mâche (Hypérion (1981), Nocturne (1981), Tithon (1989), Moires (1994), Canopée (2003)), Takehito Shimazu (Illusions in Desolate Fields (1994)),  Mari King, and Curtis Roads. Aphex Twin talked about it in an interview Physically, the UPIC is a digitising tablet linked to a computer, which has a vector display. Its functionality is similar to that of the later Fairlight CMI, in that the user draws waveforms and volume envelopes on the tablet, which are rendered by the computer. Once the waveforms have been stored, the user can compose with them by drawing "compositions" on the tablet, with the X-axis representing time, and the Y-axis representing pitch. The compositions can be stretched in duration from a few seconds to an hour. They can also be transposed, reversed, inverted, and subject to a number of algorithmic transformations. The system allows for real time performance by moving the stylus across the tablet. The UPIC system has subsequently been expanded to allow for digitally sampled waveforms as source material, rather than purely synthesised tones. In 2005, Mode Records of New York released a 2-CD compilation of works composed with the UPIC, entitled Xenakis, UPIC, Continuum, which provides an overview of the machine's sonic possibilities. There were a couple of attempts to reproduce the UPIC system using commodity hardware, for instance Iannix, HighC, UPISketch. IanniX, which has been sponsored by the French Ministry of Culture, is a graphical open-source sequencer which syncs via Open Sound Control events and curves to a real-time environment (like Pure Data, SuperCollider, Csound, MaxMSP and openFrameworks among others). For its part, HighC is currently used as a pedagogical tool in classes ranging from early teens to Master classes in composition, while some contemporary composers, such as George Hatzimichelakis have made it part of their toolset. UPISketch is a pedagogical tool inspired by the UPIC. The first version, released in 2018, runs on OSX and iOS.
Urbiscript (pl, appeared 2003)
Creators: Jean-Christophe Baillie


urbiscript is a programming language for robotics.  It features syntactic support for concurrency and event-based programming.  It is a prototype-based object-oriented scripting language.  It is dynamic: name resolution is performed during the program execution (late binding); slots (member variables) can be added/removed at runtime, and even prototypes (superclasses) of an object can be changed at runtime. Memory management is performed by reference counting. Tightly bound to the Urbi platform it supports seamless integration of C++/Java components.
URL (schema, appeared 1994)
Stands for: Uniform Resource Locator
Creators: Tim Berners-Lee


A Uniform Resource Locator (URL), colloquially termed a web address, is a reference to a web resource that specifies its location on a computer network and a mechanism for retrieving it. A URL is a specific type of Uniform Resource Identifier (URI), although many people use the two terms interchangeably. URLs occur most commonly to reference web pages (http), but are also used for file transfer (ftp), email (mailto), database access (JDBC), and many other applications. Most web browsers display the URL of a web page above the page in an address bar. A typical URL could have the form http://www.example.com/index.html, which indicates a protocol (http), a hostname (www.example.com), and a file name (index.html).
UTC (timeFormat, appeared 1960)


Coordinated Universal Time (abbreviated to UTC) is the primary time standard by which the world regulates clocks and time. It is within about 1 second of mean solar time at 0° longitude, and is not adjusted for daylight saving time. In some countries where English is spoken, the term Greenwich Mean Time (GMT) is often used as a synonym for UTC and predates UTC by nearly 300 years.The first Coordinated Universal Time was informally adopted on 1 January 1960 and was first officially adopted as CCIR Recommendation 374, Standard-Frequency and Time-Signal Emissions, in 1963, but the official abbreviation of UTC and the official English name of Coordinated Universal Time (along with the French equivalent) were not adopted until 1967.The system has been adjusted several times, including a brief period where time coordination radio signals broadcast both UTC and "Stepped Atomic Time (SAT)" before a new UTC was adopted in 1970 and implemented in 1972. This change also adopted leap seconds to simplify future adjustments. This CCIR Recommendation 460 "stated that (a) carrier frequencies and time intervals should be maintained constant and should correspond to the definition of the SI second; (b) step adjustments, when necessary, should be exactly 1 s to maintain approximate agreement with Universal Time (UT); and (c) standard signals should contain information on the difference between UTC and UT."A number of proposals have been made to replace UTC with a new system that would eliminate leap seconds. A decision whether to remove them altogether has been deferred until 2023.The current version of UTC is defined by International Telecommunications Union Recommendation (ITU-R TF.460-6), Standard-frequency and time-signal emissions, and is based on International Atomic Time (TAI) with leap seconds added at irregular intervals to compensate for the slowing of the Earth's rotation. Leap seconds are inserted as necessary to keep UTC within 0.9 seconds of the UT1 variant of universal time. See the "Current number of leap seconds" section for the number of leap seconds inserted to date.
UTF-8 (characterEncoding, appeared 1993)
Creators: Rob Pike
Ken Thompson


UTF-8 is a variable width character encoding capable of encoding all 1,112,064 valid code points in Unicode using one to four 8-bit bytes. The encoding is defined by the Unicode standard, and was originally designed by Ken Thompson and Rob Pike. The name is derived from Unicode (or Universal Coded Character Set) Transformation Format –  8-bit. It was designed for backward compatibility with ASCII. Code points with lower numerical values, which tend to occur more frequently, are encoded using fewer bytes. The first 128 characters of Unicode, which correspond one-to-one with ASCII, are encoded using a single octet with the same binary value as ASCII, so that valid ASCII text is valid UTF-8-encoded Unicode as well. Since ASCII bytes do not occur when encoding non-ASCII code points into UTF-8, UTF-8 is safe to use within most programming and document languages that interpret certain ASCII characters in a special way, such as "/" in filenames, "\" in escape sequences, and "%" in printf.  UTF-8 has been the dominant character encoding for the World Wide Web since 2009, and as of November 2017 accounts for 90.1% of all Web pages. (The next-most popular multibyte encodings, Shift JIS and GB 2312, have 0.8% and 0.6% respectively). The Internet Mail Consortium (IMC) recommended that all e-mail programs be able to display and create mail using UTF-8, and the W3C recommends UTF-8 as the default encoding in XML and HTML.
Uniform eXchange Format (dataNotation, appeared 2022)
Creators: Mark Summerfield
Origin: Qtrac Ltd
Country: United Kingdom
Website: https://www.qtrac.eu
File extensions: uxf,
ux*

Uniform eXchange Format (uxf) is a plain text human readable optionally typed storage format that supports custom types. It may serve as a convenient alternative to csv, ini, json, sqlite, toml, xml, or yaml


GitHub description: Uniform eXchange Format (uxf) is a plain text human readable optionally typed storage format that supports custom types. It may serve as a convenient alternative to csv, ini, json, sqlite, toml, xml, or yaml.

uxf 1
[
  {<Point> [1.4 9.8 -0.7 3.0 2.1 -6.3]}
  <TrafficLightGreen> <TrafficLightAmber> <TrafficLightRed>
]
V (pl, appeared 2019)
Creators: Alexander Medvednikov
Website: https://vlang.io/



GitHub description: Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies. Supports automatic C => V translation. https://vlang.io

import json

struct User {
    name string
    age  int
mut:
    is_registered bool
}

fn main() {
    s := '[{"name":"Frodo", "age":25}, {"name":"Bobby", "age":10}]'
    mut users := json.decode([]User, s) or {
        eprintln('Failed to parse json')
        return
    }
    for user in users {
        println('$user.name: $user.age')
    }
    println('')
    for i, mut user in users {
        println('$i) $user.name')
        if !user.can_register() {
            println('Cannot register $user.name, they are too young')
            continue
        }
        // `user` is declared as `mut` in the for loop,
        // modifying it will modify the array
        user.register()
    }
    // Let's encode users again just for fun
    println('')
    println(json.encode(users))
}

fn (u User) can_register() bool {
    return u.age >= 16
}

fn (mut u User) register() {
    u.is_registered = true
}
v8torque (pl, appeared 2018)




 macro LoadDataViewUint32(buffer: JSArrayBuffer, offset: intptr,
                   requested_little_endian: bool,
                   signed: constexpr bool): Number {
  let data_pointer: RawPtr = buffer.backing_store;

  let b0: uint32 = LoadUint8(data_pointer, offset);
  let b1: uint32 = LoadUint8(data_pointer, offset + 1);
  let b2: uint32 = LoadUint8(data_pointer, offset + 2);
  let b3: uint32 = LoadUint8(data_pointer, offset + 3);
  let result: uint32;

  if (requested_little_endian) {
    result = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
  } else {
    result = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
  }

  return convert<Number>(result);
}
Vala (pl, appeared 2006)
Website: https://wiki.gnome.org/Projects/Vala


Vala is an object-oriented programming language with a self-hosting compiler that generates C code and uses the GObject system. Vala is syntactically similar to C# and includes several features such as: anonymous functions, signals, properties, generics, assisted memory management, exception handling, type inference, and foreach statements. Its developers Jürg Billeter and Raffaele Sandrini aim to bring these features to the plain C runtime with little overhead and no special runtime support by targeting the GObject object system. Rather than compiling directly to machine code or assembly language, it compiles to a lower level intermediate language. It source-to-source compiles to C, which is then compiled with a C compiler for a given platform, such as GCC. For memory management, the GObject system provides reference counting. In C, a programmer must manually manage adding and removing references, but in Vala, managing such reference counts is automated if a programmer uses the language's built-in reference types rather than plain pointers. Using functionality from native code libraries requires writing vapi files, defining the library interfacing. Writing these interface definitions is well-documented for C libraries, especially when based on GObject. However, C++ libraries are not supported. Vapi files are provided for a large portion of the GNOME platform, including GTK+. Vala was conceived by Jürg Billeter and was implemented by him and Raffaele Sandrini, finishing a self-hosting compiler in May 2006.


int main (string[] args) {
   var app = new Gtk.Application(
     "com.example.App",
     ApplicationFlags.FLAGS_NONE
   );
   
   app.activate.connect(() => {
     var win = new Gtk.ApplicationWindow(app);
 
     var btn = new Gtk.Button.with_label("Hello World");
     btn.click.connect(win.close);
 
     win.child = btn;
     win.present();
   })
   return app.run(args);
 }
Vale (assembly, appeared 2017)
Stands for: Verified Assembly Language for Everest
Creators: Chris Hawblitzel

Vale is a tool for constructing formally verified high-performance assembly language code, with an emphasis on cryptographic code. It uses existing verification frameworks, such as Dafny and F*, for formal verification. It supports multiple architectures, such as x86, x64, and ARM, and multiple platforms, such as Windows, Mac, and Linux. Additional architectures and platforms can be supported with no changes to the Vale tool.


GitHub description: Verified Assembly Language for Everest

procedure ReadA(ghost a:seq(uint32),inline b:bool)
 reads r0; mem;
 modifies r1;
 requires
  length(a) >= 3;
  a[0] <= 100;
  a[1] <= 100;
  forall i :: 0 <= i < length(a) ==>
   InMem(r0 + 4 * i, mem)
   && mem[r0 + 4 * i] == a[i];
 ensures
  b ==> r1 == a[0] + 1;
  !b ==> r1 == a[1] + 1;
{
 inline if (b) {
  LDR(r1, r0, 0); //load memory [r0+0] into r1
  AddOne(r1);
 } else {
  LDR(r1, r0, 4); //load memory [r0+4] into r1
  AddOne(r1);
 }
}
procedure{:recursive} AddNToR7(inline n:nat)
 modifies r7;
 requires r7 + n <= 0xffffffff;
 ensures r7 == old(r7) + n;
{
 inline if (n > 0) {
  AddOne(r7);
  AddNToR7(n - 1);
}
VBA (pl, appeared 1993)
Stands for: Visual Basic for Applications
Origin: Microsoft


Visual Basic for Applications (VBA) is an implementation of Microsoft's event-driven programming language Visual Basic 6, which was discontinued in 2008, and its associated integrated development environment (IDE). Although Visual Basic is no longer supported or updated by Microsoft, VBA itself got upgraded in 2010 with the introduction of Visual Basic for Applications 7 in Microsoft Office applications. Visual Basic for Applications enables building user-defined functions (UDFs), automating processes and accessing Windows API and other low-level functionality through dynamic-link libraries (DLLs). It supersedes and expands on the abilities of earlier application-specific macro programming languages such as Word's WordBasic. It can be used to control many aspects of the host application, including manipulating user interface features, such as menus and toolbars, and working with custom user forms or dialog boxes. As its name suggests, VBA is closely related to Visual Basic and uses the Visual Basic Runtime Library. However, VBA code normally can only run within a host application, rather than as a standalone program. VBA can, however, control one application from another using OLE Automation. For example, VBA can automatically create a Microsoft Word report from Microsoft Excel data that Excel collects automatically from polled sensors. VBA can use, but not create, ActiveX/COM DLLs, and later versions add support for class modules. VBA is built into most Microsoft Office applications, including Office for Mac OS X (except version 2008), and other Microsoft applications, including Microsoft MapPoint and Microsoft Visio. VBA is also implemented, at least partially, in applications published by companies other than Microsoft, including ArcGIS, AutoCAD, CorelDraw, LibreOffice, Reflection, SolidWorks, and WordPerfect.
VBScript (pl, appeared 1996)
Origin: Microsoft
Country: United States
Website: https://msdn.microsoft.com/en-us/library/t0aew7h6.aspx
File extensions: vbs
vbe
wsf
wsc


VBScript ("Microsoft Visual Basic Scripting Edition") is an Active Scripting language developed by Microsoft that is modeled on Visual Basic. It allows Microsoft Windows system administrators to generate powerful tools for managing computers with error handling, subroutines, and other advanced programming constructs. It can give the user complete control over many aspects of their computing environment. VBScript uses the Component Object Model to access elements of the environment within which it is running; for example, the FileSystemObject (FSO) is used to create, read, update and delete files. VBScript has been installed by default in every desktop release of Microsoft Windows since Windows 98; in Windows Server since Windows NT 4.0 Option Pack; and optionally with Windows CE (depending on the device it is installed on). A VBScript script must be executed within a host environment, of which there are several provided with Microsoft Windows, including: Windows Script Host (WSH), Internet Explorer (IE), and Internet Information Services (IIS). Additionally, the VBScript hosting environment is embeddable in other programs, through technologies such as the Microsoft Script Control (msscript.ocx).
vCard (textDataFormat, appeared 1998)




BEGIN:VCARD
VERSION:4.0
N:Gump;Forrest;;Mr.;
FN:Forrest Gump
ORG:Bubba Gump Shrimp Co.
TITLE:Shrimp Man
PHOTO;MEDIATYPE=image/gif:http://www.example.com/dir_photos/my_photo.gif
TEL;TYPE=work,voice;VALUE=uri:tel:+1-111-555-1212
TEL;TYPE=home,voice;VALUE=uri:tel:+1-404-555-1212
ADR;TYPE=WORK;PREF=1;LABEL="100 Waters Edge\nBaytown\, LA 30314\nUnited States of America":;;100 Waters Edge;Baytown;LA;30314;United States of America
ADR;TYPE=HOME;LABEL="42 Plantation St.\nBaytown\, LA 30314\nUnited States of America":;;42 Plantation St.;Baytown;LA;30314;United States of America
EMAIL:forrestgump@example.com
REV:20080424T195243Z
x-qq:21588891
END:VCARD