pldb/PLDB huggingface dataset:
Visual Prolog (pl, appeared 1996)


Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog.  As Turbo Prolog, it was marketed by Borland but it is now developed and marketed by the Danish firm Prolog Development Center (PDC) that originally developed it. Visual Prolog can build Microsoft Windows GUI-applications, console applications, DLLs (dynamic link libraries), and CGI-programs. It can also link to COM components and to databases by means of ODBC. Logic languages are traditionally interpreted, but Visual Prolog is compiled. This provides the important improvement of converting traditional Prolog-typical run-time errors to compiler warnings, which ensures a better robustness of the finished applications. The core of Visual Prolog are Horn clauses, algebraic datatypes, pattern matching and controlled non-determinism like in traditional Prolog, but unlike traditional Prolog, Visual Prolog has always been strongly and statically typed.
Visual Smalltalk Enterprise (pl, appeared 1992)


Visual Smalltalk Enterprise (VSE) is a Smalltalk dialect that runs only on Microsoft Windows, and is the last in a long line of Smalltalk implementations first produced by Digitalk and now available through Cincom. Active development has stopped since late 1997 and VSE is now only available as a version called VSE 2000, and only to licensed users of previous VSE versions.
Visual Studio Code (editor, appeared 2015)
Also known as: vs code


Visual Studio Code is a source code editor developed by Microsoft for Windows, Linux and macOS. It includes support for debugging, embedded Git control, syntax highlighting, intelligent code completion, snippets, and code refactoring. It is also customizable, so users can change the editor's theme, keyboard shortcuts, and preferences. It is free and open-source, although the official download is under a proprietary license.Visual Studio Code is based on Electron, a framework which is used to deploy Node.js applications for the desktop running on the Blink layout engine. Although it uses the Electron framework, the software does not use Atom and instead employs the same editor component (codenamed "Monaco") used in Visual Studio Team Services (formerly called Visual Studio Online).In the Stack Overflow 2018 Developer Survey, Visual Studio Code was ranked the most popular developer environment tool, with 34.9% of 75,398 respondents claiming to use it.
Visual Studio (editor, appeared 1997)


Microsoft Visual Studio is an integrated development environment (IDE) from Microsoft. It is used to develop computer programs, as well as websites, web apps, web services and mobile apps. Visual Studio uses Microsoft software development platforms such as Windows API, Windows Forms, Windows Presentation Foundation, Windows Store and Microsoft Silverlight. It can produce both native code and managed code. Visual Studio includes a code editor supporting IntelliSense (the code completion component) as well as code refactoring. The integrated debugger works both as a source-level debugger and a machine-level debugger. Other built-in tools include a code profiler, forms designer for building GUI applications, web designer, class designer, and database schema designer. It accepts plug-ins that enhance the functionality at almost every level—including adding support for source control systems (like Subversion and Git) and adding new toolsets like editors and visual designers for domain-specific languages or toolsets for other aspects of the software development lifecycle (like the Team Foundation Server client: Team Explorer). Visual Studio supports 36 different programming languages and allows the code editor and debugger to support (to varying degrees) nearly any programming language, provided a language-specific service exists. Built-in languages include C, C++, C++/CLI, Visual Basic .NET, C#, F#, JavaScript, TypeScript, XML, XSLT, HTML, and CSS. Support for other languages such as Python, Ruby, Node.js, and M among others is available via plug-ins. Java (and J#) were supported in the past. The most basic edition of Visual Studio, the Community edition, is available free of charge. The currently supported Visual Studio version is 2017. Microsoft announced 2019 on June 6, 2018, with its release timing to be shared "in the coming months," promising "to deliver ... quickly and iteratively."
VisualWorks (pl, appeared 1985)


VisualWorks is a cross-platform implementation of the Smalltalk language. It is implemented as a development system based on "images", which are dynamic collections of software objects, each contained in a system image. The lineage of VisualWorks goes back to the first Smalltalk-80 implementation by Xerox PARC. In the late 1980s, a group of Smalltalk-80 developers spun off ParcPlace Systems to further develop Smalltalk-80 as a commercial product. The commercial product was initially called ObjectWorks, and then VisualWorks. On August 31, 1999, the VisualWorks product was sold to Cincom. VisualWorks runs under many operating systems, including  Windows, Mac OS X, Linux, and several versions of Unix. VisualWorks has a very active third-party developers community, with a non-commercial version available free. The non-commercial version has all the power and functionality of the commercial version. In both versions, as in all Smalltalks, the user can see all the source code. This includes all the system classes, including the browser and GUI builder. VisualWorks supports cross-platform development projects, because of its built-in multi-platform features. For example, a GUI application needs to be developed only once, and can then be switched to different widget styles. A VisualWorks application can be run on all supported platforms without any modifications. Only the virtual machine is platform-dependent.
VlibTemplate (template, appeared 2003)


vlibTemplate is a template engine written in PHP. Programmers and web developers may use it for web development. vlibTemplate is a PHP class that is intended to make splitting PHP from HTML a simple and natural task, using markup tags. This class allows users to set values for variables, loops, if statements, etc. which are declared in the template. vlibTemplate is a part of vLIB. It has an interface to vlibDate and vlibMimeMail.
VML (xmlFormat, appeared 1998)
Stands for: Vector Markup Language


Vector Markup Language (VML) was an XML-based file format for two-dimensional vector graphics. VML was specified in Part 4 of the Office Open XML standards ISO/IEC 29500 and ECMA-376. According to the specification, VML is a deprecated format included in Office Open XML for legacy reasons only. VML was pervasively used in MS Office 2007 documents (i.e. Word, Excel and PowerPoint documents). As of 2012, with the release of Internet Explorer 10, VML became obsolete and is no longer supported by Internet Explorer standard mode. It is a legacy feature that is available in Internet Explorer 10 only when the browser is set to run in modes that emulate the functionality of previous versions of Internet Explorer 6, 7, 8, and 9.
VSXu (visual, appeared 2004)
Website: http://vsxu.com


VSXu (VSX Ultra) is an OpenGL-based (hardware-accelerated), modular programming environment with its main purpose to visualize music/audio data and create 3D effects in real-time. Available for Windows and GNU/Linux. It is currently released as free software under terms of the  GNU General Public License v2 and maintained by Vovoid Media Technologies AB. VSXu is built on a modular plug-in-based architecture so anyone can extend it and or make visualization presets ("visuals" or "states").

GitHub description: Visual programming language; Real-time OpenGL graphics; Embeddable; GPL/LGPL Licensed; Audio/Music Visualizer; Animation tool
Velocity Template Language (template, appeared 2000)
Stands for: Velocity Template Language

Velocity is a Java-based template engine. It permits web page designers to reference methods defined in Java code.



<html>
  <body>
    Hello $customer.Name!
    <table>
    #foreach( $mud in $mudsOnSpecial )
      #if ( $customer.hasPurchased($mud) )
        <tr>
          <td>
            $flogger.getPromo( $mud )
          </td>
        </tr>
      #end
    #end
    </table>
  </body>
</html>
Very Tiny Language (pl, appeared 1976)
Also known as: vtl-2
Creators: Garry Shannon
Frank McCoy

VTL-2 is the second Very Tiny Language developed for the Altair 680 Computer system. VTL-2 represents an enormous improvement over the earlier VTL-1 language, and incorporates some thirty additional features. In spite of these enhancements, it still requires only 768 bytes of Read-Only-Memory, and still fits into the three empty PROM sockets already on the 680 CPU board.
Visual Tool Markup Language (pl, appeared 1997)

VTML is a family of markup languages used to extend the IDE of HomeSite and ColdFusion Studio. Using VTML you can define your own Tag Insight and Tag Editors, which is very helpful when developing your own custom tags, since you can simply put the VTML files inside your distribution, enabling your custom tags to tightly integrate into the ColdFusion Studio IDE. As the name (Markup Language) might suggest, VTML is a tag-based language (CFML is also tag-based) and therefore easy to learn.

Visual Tool Markup Language, a user interface markup language used by Macromedia HomeSite, ColdFusion Studio and JRun Studio. VTML is used for tag editors and custom dialogs shipped with these applications and can be used to extend the user interface and to support additional tag-based languages. It is documented in help files included with these applications or available online, notably in the "VTML Reference" and "Customizing the Development Environment" sections. Wizard Markup Language (WIZML) is a sub-language of VTML that defines the logic used by user interface wizards and tag editors.


<TAG> <ATTRIBUTES>
... Defines tag attribute properties and behavior
</ATTRIBUTES>
<ATTRIBCATEGORIES>
... Defines logical grouping for tag attributes
</ATTRIBCATEGORIES>

<EDITORLAYOUT>
... Defines the layout of a tag editor
</EDITORLAYOUT>

<TAGLAYOUT>
... Defines the tag generation template
</TAGLAYOUT>
<TAGDESCRIPTION>
... HTML-based documentation for the tag
</TAGDESCRIPTION>
</TAG>
Vue (framework, appeared 2014)
Website: https://vuejs.org


Vue.js (commonly referred to as Vue; pronounced , like view) is an open-source JavaScript framework for building user interfaces. Integration into projects that use other JavaScript libraries is simplified with Vue because it is designed to be incrementally adoptable. Vue can also function as a web application framework capable of powering advanced single-page applications.

GitHub description: 🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Vvvv (application, appeared 1998)
Website: https://vvvv.org/


vvvv (German pronunciation: [faʊfiːɐ̯ ] = "v4") is a general purpose toolkit with a special focus on real-time video synthesis and programming large media environments with physical interfaces, real-time motion graphics, audio and video. vvvv uses a dataflow approach and a visual programming interface for rapid prototyping and developing. Applications written in vvvv are commonly called patches. Patches consist of a network of nodes. Patches can be created, edited and tested while they are running. Patches are stored on the disk in standard XML format. vvvv is written in Borland Delphi, plugins can be developed in the .NET Framework in C#. Most nodes handle data in a one-dimensional array of values, called Spreads. In addition to traditional vector algebra this allows programming of particle systems, as also rendering nodes and deal with arrays of values accordingly. If an operation has to deal with arrays of different lengths, the shorter array gets repeated to fill up the larger. vvvv includes a feature it calls boygrouping, where one computer controls a number of slave computers to operate in parallel, with all programming and editing done on the master computer. The toolkit has the ability to work with HLSL Shaders which are written in their common textual form but are embedded in the data flow language and are instantly compiled and uploaded as soon any part of their source code is changed. With a focus on video synthesis and processing, vvvv uses the toolkit DirectX and, as such, is available for Microsoft Windows systems only, although it is known to run stably under Parallels and VMWare Fusion. vvvv currently supports DirectX 9 (including PS 3 and VS 3 shader techniques) and DirectX 11. vvvv was initially developed by the Frankfurt-based media collective MESO as an in-house tool for their own projects, but was then released. vvvv is now maintained by the VVVV group. vvvv is free for non-commercial use and available for download at its website. Any commercial uses require a license.
walt (pl, appeared 2017)
Website: https://ballercat.github.io/walt/

Walt is a JavaScript-like syntax for WebAssembly text format


GitHub description: :zap: Walt is a JavaScript-like syntax for WebAssembly text format :zap:

export function fibonacci(n: i32): i32 {
 if (n <= 0) return 0;

 if (n == 1) return 1;

 return fibonacci(n - 1) + fibonacci(n - 2);
}
Wart (pl, appeared 2010)
Creators: Kartik K. Agaram
Website: http://akkartik.name/post/wart



GitHub description: An experimental, small, readable Lisp with thorough unit tests and extensible functions/macros.

def (foo (a | (b c)))     # 'b' and 'c' name parts of list 'a'
  (list a b c)
(foo '(1 2))
WebAssembly (bytecode, appeared 2015)
Creators: Alon Zakai
Origin: W3C
Website: http://webassembly.org/
File extensions: wasm


WebAssembly (Wasm, WA) is a web standard that defines a binary format and a corresponding assembly-like text format for executable code in Web pages. It is meant to enable executing code nearly as fast as running native machine code. It was envisioned to complement JavaScript to speed up performance-critical parts of web applications and later on to enable web development in languages other than JavaScript. WebAssembly does not attempt to replace JavaScript, but to complement it. It is developed at the World Wide Web Consortium (W3C) with engineers from Mozilla, Microsoft, Google and Apple.It is executed in a sandbox in the web browser after a verification step. Programs can be compiled from high-level languages into Wasm modules and loaded as libraries from within JavaScript applets.

GitHub description: The WebAssembly Binary Toolkit

20 00
50
04 7E
42 01
05
20 00
20 00
42 01
7D
10 00
7E
0B
WebAssembly Text Format (pl, appeared 2015)
File extensions: wast

WebAssembly has an S-expression-based textual representation, an intermediate form designed to be exposed in text editors, browser developer tools, etc.



 (module
  (import "math" "exp" (func $exp (param f64) (result f64)))
  (func (export "doubleExp") (param $0 f64) (result f64)
    (f64.mul
      (call $exp
        (get_local $0))
      (f64.const 2))))
WATFIV (pl, appeared 1968)


WATFIV, or WATerloo FORTRAN IV,  developed at the University of Waterloo, Canada is an implementation of the Fortran computer programming language. It is the successor of WATFOR. WATFIV was used from the late 1960s into the mid-1980s. WATFIV was in turn succeeded by later versions of WATFOR. Because it could complete the three usual steps ("compile-link-go") in just one pass, the system became popular for teaching students computer programming.
Wavefront Object (application, appeared 1988)


OBJ (or .OBJ) is a geometry definition file format first developed by Wavefront Technologies for its Advanced Visualizer animation package. The file format is open and has been adopted by other 3D graphics application vendors. The OBJ file format is a simple data-format that represents 3D geometry alone — namely, the position of each vertex, the UV position of each texture coordinate vertex, vertex normals, and the faces that make each polygon defined as a list of vertices, and texture vertices.  Vertices are stored in a counter-clockwise order by default, making explicit declaration of face normals unnecessary. OBJ coordinates have no units, but OBJ files can contain scale information in a human readable comment line.
WCPS (pl, appeared 2008)
Stands for: Web Coverage Processing Service


The Web Coverage Processing Service (WCPS) defines a language for filtering and processing of multi-dimensional raster coverages, such as sensor, simulation, image, and statistics data. The Web Coverage Processing Service is maintained by the Open Geospatial Consortium (OGC). This raster query language allows clients to obtain original coverage data, or derived information, in a platform-neutral manner over the Web.


for $c in ( M1, M2, M3 ),
    $r in ( R )
where
    some( $c.nir > 127 and $r )
return
    encode( abs( $c.red - $c.nir ), "hdf5" )
WDL (pl, appeared 2012)
Stands for: Workflow Description Language
Website: http://www.openwdl.org/

The Workflow Description Language (WDL) is a way to specify data processing workflows with a human-readable and -writeable syntax. WDL makes it straightforward to define analysis tasks, chain them together in workflows, and parallelize their execution. The language makes common patterns simple to express, while also admitting uncommon or complicated behavior; and strives to achieve portability not only across execution platforms, but also different types of users. Whether one is an analyst, a programmer, an operator of a production system, or any other sort of user, WDL should be accessible and understandable.


GitHub description: Workflow Description Language - Specification and Implementations
WebGL (library, appeared 2011)
Origin: Khronos Group
Website: https://www.khronos.org/webgl/


WebGL (Web Graphics Library) is a JavaScript API for rendering interactive 2D and 3D graphics within any compatible web browser without the use of plug-ins. WebGL is integrated completely into all the web standards of the browser allowing GPU accelerated usage of physics and image processing and effects as part of the web page canvas. WebGL elements can be mixed with other HTML elements and composited with other parts of the page or page background. WebGL programs consist of control code written in JavaScript and shader code that is written in OpenGL Shading Language (GLSL), a language similar to C or C++, and is executed on a computer's graphics processing unit (GPU). WebGL is designed and maintained by the non-profit Khronos Group.
WebP (binaryDataFormat, appeared 2010)


WebP is an image format employing both lossy and lossless compression. It is currently developed by Google, based on technology acquired with the purchase of On2 Technologies.As a derivative of the VP8 video format, it is a sister project to the WebM multimedia container format. WebP-related software is released under a BSD license.The format was first announced on 30 September 2010 as a new open standard for lossy compressed true-color graphics on the web, producing smaller files of comparable image quality to the older JPEG scheme. On October 3, 2011 Google announced WebP support for animation, ICC profile, XMP metadata, and tiling (compositing very large images from maximum 16384×16384 tiles).On 18 November 2011 Google began to experiment with lossless compression and support for transparency (alpha channel) in both lossless and lossy modes; support has been enabled by default in libwebp 0.2.0 (16 August 2012). According to Google's measurements, a conversion from PNG to WebP results in a 45% reduction in file size when starting with PNGs found on the web, and a 28% reduction compared to PNGs that are recompressed with pngcrush and PNGOUT.
webql (queryLanguage, appeared 2001)
Origin: QL2 Software

WebQL was developed by QL2 Softaware in 2006. It is used for data integration and collection of unstructured and structured sources including the Web, PDF and Word documents, spreadsheets, email repositories, corporate data stores and more. It is also capable of Optical Character Recognition that enables it to retrive text within images. WebQL also support XML data of arbitrary size, and APIs for embedding WebQL in C, Java or .NET programs.



select
  URL,
  clean(CONTENT) as TITLE
from
  links
within
  http://blogsearch.google.com
  submitting values 'wikipedia' for 'q'
where
  url_host(URL) not matching 'google'
whalecalf (grammarLanguage, appeared 2000)
Creators: Alexander Okhotin
Website: http://users.utu.fi/aleokh/whalecalf/

Whale Calf is a research-level parser generator for Boolean grammars, which are context-free grammars augmented with Boolean operations. It is written by Alexander Okhotin in C++, and is mainly aimed at demonstrating different parsing algorithms, of which the most practically useful is the Generalized LR (GLR). The main development took place in 2000-2004, though (as of April 2017) some occasional corrections are still being made.



algorithm=trellis;
terminal a, b, c;
S -> C & D;
C -> a C a | a C b | b C a | b C b | c;
D -> a A & a D | b B & b D | c E;
A -> a A a | a A b | b A a | b A b | c E a;
B -> a B a | a B b | b B a | b B b | c E b;
E -> a E | b E | e;
Whiley (pl, appeared 2009)
Creators: David J. Pearce
Website: http://whiley.org/

A Programming Language with Extended Static Checking

Whiley is an experimental programming language that combines features from the functional and imperative paradigms, and supports formal specification through function preconditions, postconditions and loop invariants. The language uses flow-sensitive typing also known as "flow typing." The Whiley project began in 2009 in response to the "Verifying Compiler Grand Challenge" put forward by Tony Hoare in 2003. The first public release of Whiley was in June, 2010.Primarily developed by David Pearce, Whiley is an open source project with contributions from a small community. The system has been used for student research projects and in teaching undergraduate classes.  It was supported between 2012 and 2014 by the Royal Society of New Zealand's Marsden Fund.The Whiley compiler generates code for the Java virtual machine and can inter-operate with Java and other JVM based languages.

GitHub description: The Whiley Compiler (WyC)

// Define the type of natural numbers
type nat is (int x) where x >= 0
public function indexOf(int[] items, int item) -> (int|null index)
// If int returned, element at this position matches item
ensures index is int ==> items[index] == item
// If int returned, element at this position is first match
ensures index is int ==> no { i in 0 .. index | items[i] == item }
// If null returned, no element in items matches item
ensures index is null ==> no { i in 0 .. |items| | items[i] == item }:
    //
    nat i = 0
    //
    while i < |items|
    // No element seen so far matches item
    where no { j in 0 .. i | items[j] == item }:
        //
        if items[i] == item:
            return i
        i = i + 1
    //
    return null
Whitespace (esolang, appeared 2003)


Whitespace is an esoteric programming language developed by Edwin Brady and Chris Morris at the University of Durham (also developers of the Kaya and Idris programming languages). It was released on 1 April 2003 (April Fool's Day). Its name is a reference to whitespace characters. Unlike most programming languages, which ignore or assign little meaning to most whitespace characters, the Whitespace interpreter ignores any non-whitespace characters. Only spaces, tabs and linefeeds have meaning. An interesting consequence of this property is that a Whitespace program can easily be contained within the whitespace characters of a program written in another language, except possibly in languages which depend on spaces for syntax validity such as Python, making the text a polyglot. The language itself is an imperative stack-based language. The virtual machine on which the programs run has a stack and a heap. The programmer is free to push arbitrary-width integers onto the stack (currently there is no implementation of floating point numbers) and can also access the heap as a permanent store for variables and data structures.