pldb/PLDB huggingface dataset:
WHOIS (protocol, appeared 1970)


WHOIS (pronounced as the phrase "who is") is a query and response protocol that is widely used for querying databases that store the registered users or assignees of an Internet resource, such as a domain name, an IP address block or an autonomous system, but is also used for a wider range of other information. The protocol stores and delivers database content in a human-readable format. The WHOIS protocol is documented in RFC 3912.
Winbatch (pl, appeared 1989)
Website: http://www.winbatch.com


Winbatch is a Microsoft Windows scripting language originally developed by Wilson WindowWare and currently supported, maintained and enhanced by Island Lake Consulting LLC. Its environment includes an interpreter and a code editor along with a dialog designer and optional compiler to create self-contained executables. Its language structure and syntax is a cross between DOS batch command, Basic, Fortran, and C.   It has been developed over the years with functions added and support for things like .Net, ActiveX controls, COM (OLE), Unicode, UAC and code signing.
Wing (pl, appeared 2022)
Creators: Elad Ben-Israel
Website: https://winglang.io



GitHub description: The Wing Programming Language

bring cloud;

let queue = new cloud.Queue(timeout: 2m);
let bucket = new cloud.Bucket();
let counter = new cloud.Counter(initial: 100);

queue.on_message(inflight (body: str): str => {
  let next = counter.inc();
  let key = "myfile-${next}.txt";
  bucket.put(key, body);
});
WinWrap Basic (pl, appeared 1993)


WinWrap Basic (WWB) by Polar Engineering, Inc. is a third-party macro language based on Visual Basic used with programmes of various types  which its vendor touts as an alternative to ActiveX (e.g. VBScript, JScript, PerlScript, Rexx-based WSH engines and others), Visual Basic for Applications, and VSTA for this purpose. The WWB software package is used in conjunction with Microsoft development tools including Visual Studio, Visual Studio.NET, and the ActiveX scripting engines.  The default file extension for programmes written in this language is .wwb   WWB 10 has Windows Scripting Host functionality,  i.e. it contains a scripting engine similar to the default and third-party language implementations for WSH.  This engine is able to access both the .NET framework and the Component Object Model. The current version, 10.01, is available for different combinations of OS and platform. At this time there are four types of WWB, those being WWB.NET for the .NET object model (used with Visual Studio.NET 2005 and 2008 and Vista), .WWB-COM for the COM object model (Visual Studio and Visual Studio.NET earlier versions), both of which are used with all Windows 32 and 64-bit operating systems from Windows 95 to Windows Vista; the other two packages are for Windows CE and PocketPC & Windows Mobile. Earlier versions of WWB ran under Windows 3.1 and ostensibly OS/2 Warp 3 as well. WWB is integrated into many software packages including most categories of PC and server software (e.g. earlier versions of Host Explorer, which now uses two proprietary scripting languages, Hummingbird QuickScript and Hummingbird Basic)   as well as software used to run various types of equipment like mass spectrometers and other lab equipment.
winxed (pl, appeared 2009)
Website: http://winxed.net/
File extensions: winxed



GitHub description: The winxed programming language

#! winxed
# (C) 2010 Julián Albo
/*
= head1 NAME
setup.winxed - Python distutils style
=head1 DESCRIPTION
Just some testing, not intended for real usage yet.
=head1 USAGE
Handle with care. See DESCRIPTION.
=cut
*/
$load 'Getopt/Obj.pbc';
//**********************************************************************
// Json file read.
function loadData(string filename)
{
    var json = load_language('data_json');
    var file = open(filename);
    if (file == null || file.is_closed())
        throw Error("Can't open " + filename);
    file.encoding('utf8');
    string jsondata = file.readall();
    file.close();
    var code = json.compile(jsondata);
    return code();
}
//**********************************************************************
function main(argv)
{
    // Parse command line.
    var getopts = new ['Getopt','Obj'];
    getopts.notOptStop(1);
    getopts.push_string('file=s');
    getopts.push_string('v');
    string progname = argv.shift();
    var opts = getopts.get_options(argv);
    int verbose = opts['v'] != null;
    var file = opts['file'];
    // Get setup data from json file specified in command line
    // or default value.
    string filename = 'setup.json';
    if (file != null)
        filename = file;
    var data = loadData(filename);
    if (verbose) {
        string description = data['description'];
 say("\tFile: ", filename);
 say("\tName: ", data['name']);
        say("\tDescription: ", description);
 say("\t(C) ", data['copyright_holder']);
 say();
    }
    using extern distutils;
    setup(argv:[flat], data:[flat,named]);
}
// End
WML (xmlFormat, appeared 1998)


Wireless Markup Language (WML),  based on XML, is a now-obsolete markup language intended for devices that implement the Wireless Application Protocol (WAP) specification, such as mobile phones. It provides navigational support, data input, hyperlinks, text and image presentation, and forms, much like HTML (HyperText Markup Language). It preceded the use of other markup languages now used with WAP, such as HTML itself, and XHTML (which are gaining in popularity as processing power in mobile devices increases).
Wirth syntax notation (grammarLanguage, appeared 1977)


Wirth syntax notation (WSN) is a metasyntax, that is, a formal way to describe formal languages. Originally proposed by Niklaus Wirth in 1977 as an alternative to Backus–Naur form (BNF). It has several advantages over BNF in that it contains an explicit iteration construct, and it avoids the use of an explicit symbol for the empty string (such as <empty> or ε).WSN has been used in several international standards, starting with ISO 10303-21. It was also used to define the syntax of EXPRESS, the data modelling language of STEP.


SYNTAX     = { PRODUCTION } .
PRODUCTION = IDENTIFIER "=" EXPRESSION "." .
EXPRESSION = TERM { "|" TERM } .
TERM       = FACTOR { FACTOR } .
FACTOR     = IDENTIFIER
           | LITERAL
           | "[" EXPRESSION "]"
           | "(" EXPRESSION ")"
           | "{" EXPRESSION "}" .
IDENTIFIER = letter { letter } .
LITERAL    = """" character { character } """" .
wisp (pl, appeared 2012)
Creators: Santosh Rajan
Irakli Gozalishvili
LeXofLeviafan
Chris McCormick
Country: Unknown
Website: https://web.archive.org/web/20201121215216/https://gozala.io/wisp/

A little Clojure-like LISP in JavaScript


GitHub description: A little Clojure-like LISP in JavaScript

(alert "Hello world!")
WML (template, appeared 2006)
Stands for: Website Meta Language
Website: http://thewml.org/


Website Meta Language (WML) and its associated command wmk are together a free and extensible web designer's off-line HTML generation toolkit for Unix, distributed under the GNU General Public License (GPL v2). It works as an off-line content management system. It is written in ANSI C and Perl 5, built via a GNU Autoconf based source tree and runs out-of-the-box on all major Unix derivates. WML consists of a control frontend driving up to nine backends in a sequential pass-oriented filtering scheme. Each backend provides one particular core language. WML additionally ships with a set of include files which provide higher-level features. WML's nine backends are: Pass 1: Source Reading and Include File Expansion (ipp) Pass 2: HTML Macro Construct Expansion (mp4h) Pass 3: Perl 5 Programming Construct Expansion (eperl) Pass 4: M4 Macro Construct Expansion (gm4) Pass 5: Diversion Filter (divert) Pass 6: Character and String Substitution (asubst) Pass 7: HTML Fixup (htmlfix) Pass 8: Line Stripping and Output Fixup (htmlstrip) Pass 9: Output Splitting and Final Writing (slice)
WMLScript (pl, appeared 1998)
Stands for: Wireless Markup Language Script


WMLScript is a procedural programming language and dialect of JavaScript used for WML pages and is part of the Wireless Application Protocol (WAP). WMLScript is a client-side scripting language and is similar to JavaScript. Just like JavaScript WMLScript is used for tasks such as user input validation, generation of error message and other Dialog boxes etc. WMLScript is based on ECMAScript (European Computer Manufacturers Association Script), which is JavaScript's standardized version. Thus the syntax of WMLScript is similar to JavaScript but not fully compatible.Despite the syntactical similarities, they are two different languages.  WMLScript does not have objects or array, which JavaScript has.  On the other hand, it allows you to declare and include external functions from other scripts.   WMLScript is optimised for low power devices, and is a compiled language.
WOL (pl, appeared 1997)


Wol, WoL or WOL may refer to:  ComputingWake-on-LAN, (/wɒl/) an Ethernet standard that allows computers to be powered on by a network message An unofficial initialism for Web Ontology Language .wol, file extension for the WOLF eBook file format World Online, a defunct European internet service provider Write-only language, a programming which facilitates hard to read codeComputer gamesWar of Legends, (/wɒl/) a fantasy real-time strategy game published by Jagex Games Studio Warhammer Online, abbreviation used internally by Games Workshop staff StarCraft II: Wings of Liberty Westwood Online, multi-player game mode by Westwood Studios, superseded by XWISPublishingEditorial language, (/wɒl/) acronym for write on line, a dotted or solid line in an exercise book for students to write in an answer.OtherOwl (Winnie the Pooh), character in the Winnie the Pooh stories, who spells his name "Wol" Wide outside lane, in bicycle transportation engineering WOL (AM), a radio station in Washington, D.C. WOL World Loud TV Wol Books, the first independent academic bookshop (opened 1981) at Royal Holloway College, now Royal Holloway University of London, later taken over in 1987 by Pentos Illawarra Regional Airport
Wolfram Language (pl, appeared 1988)
Also known as: wolframlanguage
Creators: Stephen Wolfram
Origin: Wolfram Research
Website: https://www.wolfram.com/language/
File extensions: nb
m
wl


The Wolfram Language, a general multi-paradigm programming language developed by Wolfram Research, is the programming language of mathematical symbolic computation program Mathematica and the Wolfram Programming Cloud. It emphasizes symbolic computation, functional programming, and rule-based programming and can employ arbitrary structures and data. It includes built-in functions for generating and running Turing machines, creating graphics and audio, analyzing 3D models, matrix manipulations, and solving differential equations. It is extensively documented. The Wolfram language was released for the Raspberry Pi in 2013 with the goal of making it free for all Raspberry Pi users. It was controversially included in the recommended software bundle that the Raspberry Pi Foundation provides for beginners. Plans to port the Wolfram language to the Intel Edison were announced after the board's introduction at CES 2014. There was also a short lived proposal to make Wolfram libraries compatible with the Unity game engine, giving game developers access to the language's high level functions.
Wonkey (pl, appeared 2021)
Website: https://wonkey-coders.github.io/

Wonkey is an open-source cross-platform programming language.


GitHub description: Wonkey is a programming language for the creation of cross-platform video games, but not only :). Join us https://discord.gg/awfuRtZay7

Function Add( a:Int, b:Int )
    Return a + b
End

Function Add( a:Float, b:Float )
    Return a + b
End
WordPress (application, appeared 2003)
Website: https://wordpress.org


WordPress is a free and open-source content management system (CMS) based on PHP and MySQL. To function, WordPress has to be installed on a web server, which would either be part of an Internet hosting service or a network host in its own right. An example of the first scenario may be a service like WordPress.com, for example, and the second case could be a computer running the software package WordPress.org. A local computer may be used for single-user testing and learning purposes. Features include a plugin architecture and a template system. WordPress was used by more than 27.5% of the top 10 million websites as of February 2017. WordPress is reportedly the most popular website management or blogging system in use on the Web, supporting more than 60 million websites. WordPress has also been used for other application domains such as pervasive display systems (PDS). WordPress was released on May 27, 2003, by its founders, Matt Mullenweg and Mike Little, as a fork of b2/cafelog. WordPress is released under the GPLv2 (or later) license.
WFL (pl, appeared 1961)


Work Flow Language, or WFL ("wiffle") is the process control language for the Burroughs large systems, including the Unisys ClearPath/MCP series, and their operating system Master Control Program. Developed soon after the B5000 in 1961, WFL is the ClearPath equivalent of the Job Control Language (JCL) on IBM mainframes and the shell scripts of Unix-like operating systems. Unlike JCL, WFL is a high-level structured language complete with subroutines (procedures and functions) with arguments and high-level program control flow instructions. WFL programs are compiled to binary executables like any other MCP subject. WFL  is used for high-level system operations, such as running tasks, moving and copying files, providing high-level recoverability. Thus it is not a general purpose language in that you would not use it to do general computations. You can open and close files to check their attributes for example; however, you cannot read or change their contents in WFL – that you do in a general purpose language, and invoke it as a task from WFL. WFL has a high-level ALGOL-like readable syntax. It has none of the low-level assembler-like commands of JCL like //SYSIN DD, etc. in order to connect hardware devices and open files for programs. All WFL constructs deal with the high-level abstractions of tasks and files. Parameters are also real HLL parameters, not the $1, $2... style position parameters of shell scripts. WFL also has an instruction block command which is used to give operators instructions needed to run the current job. These instructions are displayed using the 'IB' operator command. WFL was a compiled language on the medium systems.  Because some OS interfaces may change from release to release, Medium Systems WFL code included a copy of the source in the object file. Upon executing a WFL job it would check to determine if the object was compatible with the OS version.  If not it would trigger a recompile of the object using the source embedded in the object code.
world (pl, appeared 2011)
Website: http://www.world-lang.org




timeval: struct [
    slong sec
    sint32 usec
] none

timezone: struct [
    sint minuteswest
    sint dsttime
] none

gettimeofday: routine [
    [typecheck]
    libc "gettimeofday" [
        tp [struct!] pointer
        tzp [struct!] pointer
    ]
    sint
]
Worst (pl, appeared 2001)
Website: http://worst.mitten.party/

Worst is a simple, malleable programming language built for extensibility and creativity. Its syntax system allows you to redefine the entire language as you wish.



import syntax/attributes
import doc
define cool [
    @[documentation [
        title "Be cool"
        description "Use this function to be really cool."
        usage "how cool"
        example "600 cool"
        tags [very cool]
    ]]
    1337 add
]
Wren (pl, appeared 2013)
Creators: Bob Nystrom
Country: United States
Website: https://wren.io/

Wren is a small, fast, class-based concurrent scripting language.


GitHub description: The Wren Programming Language. Wren is a small, fast, class-based concurrent scripting language.

System.print("Hello, world!")

class Wren {
  flyTo(city) {
    System.print("Flying to %(city)")
  }
}

var adjectives = Fiber.new {
  ["small", "clean", "fast"].each {|word| Fiber.yield(word) }
}

while (!adjectives.isDone) System.print(adjectives.call())
WSDL (xmlFormat, appeared 2000)
Stands for: Web Services Description Language


The Web Services Description Language (WSDL ) is an XML-based interface definition language that is used for describing the functionality offered by a web service. The acronym is also used for any specific WSDL description of a web service (also referred to as a WSDL file), which provides a machine-readable description of how the service can be called, what parameters it expects, and what data structures it returns. Therefore, its purpose is roughly similar to that of a method signature in a programming language. The current version of WSDL is WSDL 2.0. The meaning of the acronym has changed from version 1.1 where the "D" stood for "Definition".
WSFN (pl, appeared 1983)


WSFN (Which Stands for Nothing) is an interpreted programming language for controlling robots created by Li-Chen Wang. It was designed to be as small as possible, a "tiny" language, similar to Wang's earlier effort, Palo Alto Tiny BASIC. WSFN was first published in Dr. Dobb's Journal in September 1977. The language consists primarily of single-letter commands to tell a robot to move in certain directions, while other commands perform tests or basic mathematical operations. These can be grouped into named macros to produce more complex programs. The original version also included code that simulated the robot as a cursor on the VDM-1 display, or graphically on a Cromemco Dazzler display. Today, this is known as turtle graphics. Extended WSFN is an implementation created for the Atari 8-bit family of home computers written by Harry Stewart and published by the Atari Program Exchange in 1981. In addition to supporting turtle graphics, it adds a number of commands to control the graphics and sound capabilities of that platform. It was offered as a "beginner's language with emphasis on graphics".
WxBasic (pl, appeared 2002)


wxBasic is a free software / open-source software, cross-platform BASIC interpreter. As it is based on syntax of the BASIC language, it is designed to be simple to learn and understand, and allow novice programmers to write applications for graphical environments like Windows and Linux with minimal effort.  wxBasic is a bytecode based language, like Perl or Java. It is licensed under the LGPL, so proprietary software's source code can be linked against it. It can create stand-alone executables by binding together source code with the interpreter. In contrast with executables created by similar commercial programs like Visual Basic, executables produced by wxBasic do not require any external DLL file, resource file, or installer to run.  The executable is distributed alone and can be run immediately by end-users.  As with programs written in any interpreted language, wxBasic programs may also be run straight from the source code on any platform, if wxBasic is present.    wxBasic is written primarily in C, with some C++ linking it to the wxWidgets library. wxWidgets supplies the cross-platform features. It runs on Microsoft Windows using native controls, and on Linux and macOS using the GTK+ library.
Wyvern (pl, appeared 2012)
Website: http://wyvernlang.github.io/


Wyvern is a computer programming language created by Jonathan Aldrich and Alex Potanin for the development of web and mobile applications with security and assurance being number one priority. Wyvern supports object capabilities, it is structurally typed, and aims to make secure way of programming easier than insecure - as described in the Wyvern Manifesto. One of the early available features that make Wyvern special is a way to safely use multiple programming languages within the same program so programmers can use the language most appropriate for each function while at the same time increasing the program's security. It is currently in a prototype stage and distributed under a GPLv2 license.

GitHub description: The Wyvern programming language.
X-BASIC (pl, appeared 1987)


The X68000 (Japanese: エックス ろくまんはっせん, Hepburn: Ekkusu Rokuman Hassen) is a home computer created by Sharp Corporation, first released in 1987, sold only in Japan. The first model features a 10 MHz Motorola 68000 CPU (hence the name), 1 MB of RAM, and no hard drive; the last model was released in 1993 with a 25 MHz Motorola 68030 CPU, 4 MB of RAM, and optional 80 MB SCSI hard drive. RAM in these systems is expandable to 12 MB, though most games and applications do not require more than 2 MB.
X BitMap (textDataFormat, appeared 1989)

XBM files differ markedly from most image files in that they take the form of C source files.

In computer graphics, the X Window System used X BitMap (XBM), a plain text binary image format, for storing cursor and icon bitmaps used in the X GUI. The XBM format is superseded by XPM, which first appeared for X11 in 1989.


#define test_width 16
#define test_height 7
static char test_bits[] = {
0x13, 0x00, 0x15, 0x00, 0x93, 0xcd, 0x55, 0xa5, 0x93, 0xc5, 0x00, 0x80,
0x00, 0x60 };
X PixMap (application, appeared 1989)


X PixMap (XPM) is an image file format used by the X Window System, created in 1989 by Daniel Dardailler and Colas Nahaboo working at Bull Research Center at Sophia Antipolis, France, and later enhanced by Arnaud Le Hors.It is intended primarily for creating icon pixmaps, and supports transparent pixels. Derived from the earlier XBM syntax, it is a plain text file in the XPM2 format or of a C programming language syntax, which can be included in a C program file.
X10 (pl, appeared 2004)
Creators: Kemal Ebcioğlu
Saravanan Arumugam
Vijay Saraswat
Vivek Sarkar
Origin: IBM
Country: United States
Website: http://x10-lang.org
File extensions: x10
Keywords: as
assert
async
at
athome
ateach
atomic
break
case
catch
class
clocked
continue
def
default
do
else
final
finally
finish
for
goto
haszero
here
if
import
in
instanceof
interface
isref
new
offer
operator
package
return
struct
switch
throw
try
type
val
var
when
while


X10 is a programming language being developed by IBM at the Thomas J. Watson Research Center as part of the Productive, Easy-to-use, Reliable Computing System (PERCS) project funded by DARPA's High Productivity Computing Systems (HPCS) program. Its primary authors are Kemal Ebcioğlu, Vijay Saraswat, Saravanan Arumugam, and Vivek Sarkar. X10 is designed specifically for parallel computing using the partitioned global address space (PGAS) model. A computation is divided among a set of places, each of which holds some data and hosts one or more activities that operate on those data. It has a constrained type system for object-oriented programming, a form of dependent types. Other features include user-defined primitive struct types; globally distributed arrays, and structured and unstructured parallelism. X10 uses the concept of parent and child relationships for activities to prevent the lock stalemate that can occur when two or more processes wait for each other to finish before they can complete. An activity may spawn one or more child activities, which may themselves have children. Children cannot wait for a parent to finish, but a parent can wait for a child using the finish command.