pldb/PLDB huggingface dataset:
YARA (pl, appeared 2008)
Stands for: Yet Another Recursive Acronym
Creators: Victor M. Alvarez
Website: http://virustotal.github.io/yara/

YARA is a tool aimed at (but not limited to) helping malware researchers to identify and classify malware samples. With YARA you can create descriptions of malware families (or whatever you want to describe) based on textual or binary patterns. Each description, a.k.a rule, consists of a set of strings and a boolean expression which determine its logic.

YARA is the name of a tool primarily used in malware research and detection. It provides a rule-based approach to create descriptions of malware families based on textual or binary patterns. A description is essentially a Yara rule name, where these rules consist of sets of strings and a boolean expression. The language used has traits of Perl compatible regular expressions.

GitHub description: The pattern matching swiss knife

rule silent_banker : banker
{
    meta:
        description = "This is just an example"
        threat_level = 3
        in_the_wild = true

    strings:
        $a = {6A 40 68 00 30 00 00 6A 14 8D 91}
        $b = {8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9}
        $c = "UVODFRYSIHLNWPEJXQZAKCBGMT"

    condition:
        $a or $b or $c
}
YARV (vm, appeared 2007)


YARV (Yet another Ruby VM) is a bytecode interpreter that was developed for the Ruby programming language by Koichi Sasada. The goal of the project was to greatly reduce the execution time of Ruby programs. Since YARV has become the official Ruby interpreter for Ruby 1.9, it is also named KRI (Koichi's Ruby Interpreter), in the same vein as the original Ruby MRI, named for Ruby's creator Yukihiro Matsumoto.
Yet Another Scripting Language (pl, appeared 2017)
Stands for: Yet Another Scripting Language



GitHub description: Bytecode Interpreter for Yet Another Scripting Language (YASL).

# simple program that iteratively calculates factorials

fn range(a, b) {
  tmp := []
  for i := a; i < b; i += 1 {
    tmp->push(i)
  }

  return tmp
}

fn fact(n) {
  tmp := 1
  while n > 0 {
    tmp *= n
    n -= 1
  }

  return tmp
}


for i <- range(0, 7) {
  echo "fact(#{i}): #{fact(i)}"
}
YASnippet (textMarkup, appeared 2008)
Creators: Zhang Chiyuan
Website: http://joaotavora.github.com/yasnippet/



GitHub description: A template system for Emacs

# -*- mode: snippet -*-
# name: fun
# key: fun
# expand-env: ((yas-indent-line 'fixed))
# --
${1:function-name} :: ${2:type}
$1 ${3:arguments} $0
YAWL (pl, appeared 2006)
Stands for: Yet Another Workflow Language
Creators: Dean Mao
Website: http://www.yawlfoundation.org


YAWL (Yet Another Workflow Language) is a workflow language based on workflow patterns. The language is supported by a software system that includes an execution engine, a graphical editor and a worklist handler. The system is available as Open source software under the LGPL license. Production-level uses of the YAWL system include a deployment by first:utility and first:telecom in the UK to automate front-end service processes, and by the Australian film television and radio school to coordinate film shooting processes. The YAWL system has also been used for teaching in more than 20 universities.

GitHub description: Yet Another Workflow Language
Yedalog (queryLanguage, appeared 2015)
Creators: Brian Chin
Daniel von Dincklage
Vuk Ercegovac
Peter Hawkins
Mark S. Miller
Franz Och
Chris Olston
Fernando Pereira
Origin: Google

 We introduce Yedalog, a declarative programming language that allows programmers to mix data-parallel pipelines and computation seamlessly in a single language. By contrast, most existing tools for data-parallel computation embed a sublanguage of data-parallel pipelines in a general-purpose language, or vice versa. Yedalog extends Datalog, incorporating not only computational features from logic programming, but also features for working with data structured as nested records. Yedalog programs can run both on a single machine, and distributed across a cluster in batch and interactive modes, allowing programmers to mix different modes of execution easily.



Documents = Load{path: "document-parse-trees"};

# Code to execute for each document:
module PerDocument{tokens: T} = {
# Computes parent-child relationships
Child{p} = c :- T[c] == {parent: p, .._};

# Computes nodes that transitively descend from "influenced"
Descendants{t: c} :- T[p] == {text: "influenced", .._}, c == Child{p};
Descendants{t: c} :- Descendants{t: p}, c == Child{p};

# Counts nodes in which each entity appears under the verb "influenced".
Influence{mid} += 1 :- Descendants{t}, T[t] == {entity: mid, .._};
};

# Each entity’s influence from each hostname
Influential{mid, hostname} += count :-
Documents{tokens, hostname, .._},
PerDocument{tokens}.Influence{mid} == count;

# Persists Influential as protocol buffer data
? Store{data: Influential, path: "influential-entities"};
YESS (protocol, appeared 2022)
Stands for: You Easily Syndicate Scenes
Creators: Paul Gordon

YESS: A Reboot Of RSS. The protocol is a subset of HTML and CSS. It's central design idea is to split static HTML files up into small single-screen components, called Scenes.


GitHub description: Official specification document for the YESS protocol.

<section>
	HTML for section 1
</section>
<embed src="section-2-and-3.html">
<section>
	HTML for section 4
</section>
<section>
	HTML for section 5
</section>
<embed src="section-6.html">
yeti (pl, appeared 2007)
Website: http://mth.github.io/yeti/



GitHub description: Functional programming language for JVM.

ack m n =
    if m == 0 then
        n + 1
    elif n == 0 then
        ack (m - 1) 1
    else
        ack (m - 1) (ack m (n - 1))
    fi;

println "ack 3 8 = \(ack 3 8)"
Yes It Is (framework, appeared 2006)
Stands for: Yes It Is
Website: http://www.yiiframework.com/


Yii is an open source, object-oriented, component-based MVC PHP web application framework. Yii is pronounced as "Yee" or [ji:] and in Chinese it means "simple and evolutionary" and it can be an acronym for "Yes It Is!".

GitHub description: Yii 2: The Fast, Secure and Professional PHP Framework
Yoix (pl, appeared 2000)
Creators: Rich Drechsler
John Mocenigo


In computer programming, Yoix is a high-level, general-purpose, interpreted, dynamic programming language. The Yoix interpreter is implemented using standard Java technology without any add-on packages and requires only a Sun-compliant JVM to operate. Initially developed by AT&T Labs researchers for internal use, it has been available as free and open source software since late 2000.
Yorick (pl, appeared 1996)
Creators: David H. Munro
Website: http://yorick.github.com
File extensions: i


Yorick is an interpreted programming language designed for numerics, graph plotting, and steering large scientific simulation codes. It is quite fast due to array syntax, and extensible via C or Fortran routines. It was created in 1996 by David H. Munro of Lawrence Livermore National Laboratory.
Yum (packageManager, appeared 1999)
Creators: Seth Vidal
Michael Stenner
Origin: Duke


The Yellowdog Updater, Modified (YUM) is a libre and open-source command-line package-management utility for computers running the Linux operating system using the RPM Package Manager. Though YUM has a command-line interface, several other tools provide graphical user interfaces to YUM functionality. YUM allows for automatic updates and package and dependency management on RPM-based distributions. Like the Advanced Package Tool (APT) from Debian, YUM works with software repositories (collections of packages), which can be accessed locally or over a network connection. Under the hood, YUM depends on RPM, which is a packaging standard for digital distribution of software, which automatically uses hashes and digisigs to verify the authorship and integrity of said software; unlike some app stores, which serve a similar function, neither YUM nor RPM provide built-in support for proprietary restrictions on copying of packages by end-users. YUM is implemented as libraries in the Python programming language, with a small set of programs that provide a command-line interface. GUI-based wrappers such as YUM Extender (yumex) also exist.A rewrite of YUM named DNF replaced YUM as the default package manager in Fedora 22. DNF was created to improve on YUM in several ways - improved performance, better resolution of dependency conflicts, and easier integration with other software applications.
Z-flat (pl, appeared 2021)
Creators: Adam Hutchings
File extensions: zf

Z-flat is a compiled, statically-typed programming language. Its design goals are intuitive syntax, type-safety, and easy library management.


GitHub description: The home of the Z♭ programming language, including the compiler and docs (in progress) and the standard library (not yet started)

~/ factorial /~

~ recursive implementation ~
factorial_r(x: int): int {
    if (x < 2) {
        return 1;
    } else {
        return x * factorial_r(x - 1);
    }
}

~ iterative implementation ~
factorial_i(x: int): int {
    ret: int = 1;
    loop(x): i: int {
        ret *= (i + 1);
    }
    return ret;
}
Z-machine (pl, appeared 1980)
Origin: Infocom


The Z-machine is a virtual machine that was developed by Joel Berez and Marc Blank in 1979 and used by Infocom for its text adventure games. Infocom compiled game code to files containing Z-machine instructions (called story files or Z-code files) and could therefore port its text adventures to a new platform simply by writing a Z-machine implementation for that platform. With the large number of incompatible home computer systems in use at the time, this was an important advantage over using native code or developing a compiler for each system.
Z notation (notation, appeared 1974)

Z is not an executable notation. In general, Z specifications cannot be interpreted or compiled into a running program (or prototype or simulation). Z is not a programming language. Z texts are not just programs written in very high-level language. What would be the point of writing the program twice? Z was designed for people, not machines. For years Z was exclusively a pencil-and-paper notation.

The Z notation  is a formal specification language used for describing and modelling computing systems. It is targeted at the clear specification of computer programs and computer-based systems in general.
Z shell (pl, appeared 1990)
Also known as: zsh
Creators: Paul Falstad
Origin: Princeton University
Country: United States
Website: http://www.zsh.org/
File extensions: .ZSH


The Z shell (Zsh) is a Unix shell that can be used as an interactive login shell and as a powerful command interpreter for shell scripting. Zsh is an extended Bourne shell with a large number of improvements, including some features of Bash, ksh, and tcsh.
z80 (assembly, appeared 1976)




 ; memcpy --
 ; Copy a block of memory from one location to another.
 ;
 ; Entry registers
 ;      BC - Number of bytes to copy
 ;      DE - Address of source data block
 ;      HL - Address of target data block
 ;
 ; Return registers
 ;      BC - Zero

             org     1000h       ;Origin at 1000h
 memcpy      public
 loop        ld      a,b         ;Test BC,
             or      c           ;If BC = 0,
             ret     z           ;Return
             ld      a,(de)      ;Load A from (DE)
             ld      (hl),a      ;Store A into (HL)
             inc     de          ;Increment DE
             inc     hl          ;Increment HL
             dec     bc          ;Decrement BC
             jp      loop        ;Repeat the loop
             end
ZBasic (pl, appeared 1980)


ZBasic is a compiler which was first released by Simutek (Tucson, Arizona) in 1980.  The combined efforts of Andrew Gariepy, Scott Terry, David Overton, Greg Branche, and Halbert Laing led to versions for MS-DOS,  Apple II, Macintosh, CP/M, and TRS-80 computers. ZBasic is a very fast, efficient and quite advanced BASIC compiler with an integrated development environment. It aims to be used as a cross-platform development system, where the same source code can be compiled to different platforms without any modifications. ZBasic features device independent graphics: the same compiled code can work on different display resolutions and colors, and even in text mode. Original PC versions include graphical support up to EGA for MS-DOS. A special feature of ZBasic is BCD (binary coded decimal) math with accuracy up to 54 digits. Another special feature is INDEX$ array, an array of variable length strings that could be easily sorted, searched etc. In 1991, Harry Gish and 32 Bit Software Inc. of Dallas, Texas purchased the MS-DOS version. Nando Favaro expanded it to include 16- and 32-bit-specific machine code as well as VGA and VESA video. Zedcor concentrated on the Apple Macintosh market and renamed it FutureBASIC.
ZENO (pl, appeared 1995)
Country: United States


Zeno (after pre-Socratic Greek philosopher Zeno of Elea) is an imperative procedural programming language designed to be easy to learn and user friendly. Zeno is generic in the sense that it contains most of the essential elements used in other languages to develop real applications. The Zeno Interpreter was designed for use in Windows 95 and later Microsoft operating systems. The interpreter comes with built-in debugging tools, a source code text editor, and an on-line language reference.  Zeno was created by Stephen R. Schmitt and is maintained by Abecedarical Systems.
Zeta (pl, appeared 2008)
Creators: Russ Cox
Tom Bergan†
Austin T. Clements
Frans Kaashoek
Eddie Kohler
Origin: MIT CSAIL
UCLA

A prototype implementation of xoc in zeta, a C-like interpreted procedural language with first-class functions. Zeta makes writing extensions easier than standard C, although extension writers must adjust to a slightly different language. Our implementation runs zeta using a bytecode interpreter and is therefore limited in its performance; we plan to replace the bytecode interpreter with compilation to machine code, which should reduce the compilation time for a large program from tens of seconds to a fraction of a second.
ZigZag (knowledgeBase, appeared 1965)


ZigZag is Ted Nelson's trademark on a data model he has designed for computer interaction, both for users and between programs. Nelson's stated goal is on one hand a platform for the Project Xanadu hypertext and on the other a complete computing system built on new conventions. The design is centered on an information structure called a zzstructure and its interactive visualizations. Instead of conventional linear text or tree structures, zzstructure is a multidimensional extension of a spreadsheet whose cells can contain various kinds of data. At any moment, the display shows any two dimensions in table form much like a modern spreadsheet. Users can pivot the display about any cell to efficiently "rotate" any unseen dimension in place of either visible one, allowing them to browse high dimensional grids in a zigzag manner.
Zork Implementation Language (pl, appeared 1988)
Stands for: Zork Implementation Language




<ROUTINE VILLAIN-STRENGTH (OO
                       "AUX" (VILLAIN <GET .OO ,V-VILLAIN>)
                       OD TMP)
     <SET OD <GETP .VILLAIN ,P?STRENGTH>>
     <COND (<NOT <L? .OD 0>>
            <COND (<AND <EQUAL? .VILLAIN ,THIEF> ,THIEF-ENGROSSED>
                   <COND (<G? .OD 2> <SET OD 2>)>
                   <SETG THIEF-ENGROSSED <>>)>
            <COND (<AND ,PRSI
                        <FSET? ,PRSI ,WEAPONBIT>
                        <EQUAL? <GET .OO ,V-BEST> ,PRSI>>
                   <SET TMP <- .OD <GET .OO ,V-BEST-ADV>>>
                   <COND (<L? .TMP 1> <SET TMP 1>)>
                   <SET OD .TMP>)>)>
     .OD>
Zimbu (pl, appeared 2009)
Creators: Bram Moolenaar
Website: http://www.zimbu.org/


Bram Moolenaar (born 1961, in Lisse) is a Dutch computer programmer and an active member of the open-source software community. He is the original author, maintainer, release manager, and benevolent dictator for life of Vim, a text editor that is very popular among programmers and power users. Since July 2006, Moolenaar has been employed by Google, working in the Zürich office. He is able to spend part of his time maintaining Vim.


FUNC Main() int
  IO.write("Hello, World!\n")
  RETURN 0
}
Zimpl (pl, appeared 2004)
Website: https://zimpl.zib.de/

Zimpl is a little language to translate the mathematical model of a problem into a linear or nonlinear (mixed-) integer mathematical program expressed in .lp or .mps file format which can be read and (hopefully) solved by a LP or MIP solver.



# $Id: queens3.zpl,v 1.3 2009/09/13 16:15:53 bzfkocht Exp $
#
# This is a formulation of the n queens problem using binary variables.
# variables. Since the number of queens is maximized, the size of the
# board can be set arbitrarily.
#
param columns := 8;

set I   := { 1 .. columns };
set IxI := I * I;

set TABU[<i,j> in IxI] := { <m,n> in IxI with 
   (m != i or n != j) and (m == i or n == j or abs(m - i) == abs(n - j)) };

var x[IxI] binary;

maximize queens: sum <i,j> in IxI : x[i,j];

subto c1: forall <i,j> in IxI do
   card(TABU[i,j]) - card(TABU[i,j]) * x[i,j] >= sum <m,n> in TABU[i,j] : x[m,n];
Zip file format (binaryDataFormat, appeared 1989)
File extensions: zip


ZIP is an archive file format that supports lossless data compression. A ZIP file may contain one or more files or directories that may have been compressed. The ZIP file format permits a number of compression algorithms, though DEFLATE is the most common. This format was originally created in 1989 and was first implemented in PKWARE, Inc.'s PKZIP utility, as a replacement for the previous ARC compression format by Thom Henderson. The ZIP format was then quickly supported by many software utilities other than PKZIP. Microsoft has included built-in ZIP support (under the name "compressed folders") in versions of Microsoft Windows since 1998. Apple has included built-in ZIP support in Mac OS X 10.3 (via BOMArchiveHelper, now Archive Utility) and later. Most free operating systems have built in support for ZIP in similar manners to Windows and Mac OS X. ZIP files generally use the file extensions .zip or .ZIP and the MIME media type application/zip. ZIP is used as a base file format by many programs, usually under a different name. When navigating a file system via a user interface, graphical icons representing ZIP files often appear as a document or other object prominently featuring a zipper.
zolang (pl, appeared 2018)
Creators: Þorvaldur Rúnarsson

A programming language to generate code for multiple platforms


GitHub description: A programming language for generating code for multiple platforms

describe Person {
 name as text
 street as text
 number as number
 friendNames as list of text
}
let john as Person be Person("John", "Wall Street", 15, [ "Alice", "Bob" ])
DNS Zone (application, appeared 2001)


A Domain Name System (DNS) zone file is a text file that describes a DNS zone. A DNS zone is a subset, often a single domain, of the hierarchical domain name structure of the DNS. The zone file contains mappings between domain names and IP addresses and other resources, organized in the form of text representations of resource records (RR). A zone file may be either a DNS master file, authoritatively describing a zone, or it may be used to list the contents of a DNS cache.
Zonnon (pl, appeared 2003)
Creators: Jürg Gutknecht


Zonnon is a programming language along the Oberon, Modula, and Pascal language line. Jürg Gutknecht is the author of the programming language.Zonnon is a general purpose programming language in the Pascal, Modula-2 and Oberon family. Its conceptual model is based on objects, definitions, implementations and modules. Its computing model is concurrent, based on active objects which interact via syntax controlled dialogs. The language is being developed at ETH Zürich Institute for Computer Systems by Prof. Jürg Gutknecht. Zonnon introduces the concept of 'active objects' which are used to represent real world concurrent objects within computer programs. The Zonnon Language Report was written by Brian Kirk (director at Robinsons Associates), and David Lightfoot (Oxford Brookes University) working with Prof. Jürg Gutknecht (ETH, Zürich) and Dr. Eugene Zueff (Евгений Зуев) (Moscow State University). The first book about Zonnon was published by the N. I. Lobachevsky State University of Nizhny Novgorod (a.k.a. the Nizhni Novgorod State University).
Zope (application, appeared 1999)


Zope is a family of free and open-source web application servers written in Python, and their associated online community. Zope stands for "Z Object Publishing Environment", and was the first system using the now common object publishing methodology for the Web. Zope has been recognized as a Python killer app, an application that helped put Python in the spotlight.Over the last few years, the Zope community has spawned several additional web frameworks with disparate aims and principles, but sharing philosophy, people, and source code. Zope 2 is still the most widespread of these frameworks, largely thanks to the Plone content management system, which runs on Zope 2. BlueBream (earlier called Zope 3) is less widespread but underlies several large sites, including Launchpad. Grok was started as a more programmer-friendly framework, "Zope 3 for cavemen", and in 2009 Pyramid (ex BFG) gained popularity in the Zope community as a minimalistic framework based on Zope principles.
ZOPL (pl, appeared 1979)
Stands for: Version Z, Our Programming Language
Country: United States


ZOPL is a programming language created by Geac Computer Corporation in the early 1970s for use on their mainframe computer systems used in libraries and banking institutions.  It had similarities to C and Pascal. ZOPL stood for "Version Z, Our Programming Language". ZOPL is still in use at CGI Group (formerly known as RealTime Datapro), who ported it to VAX/VMS and Unix in the 1980s, and to Windows in 1998.  It currently (2010) runs on Windows XP/2000/2003 and Red Hat Linux.  The RTM (formerly ZUG) language compiler and runtime framework are written in ZOPL. Outside of CGI, ZOPL has not been in general use since the late 1980s, although there is still one known working system where it is found embedded in programs written in the KARL programming language.
Z++ (pl, appeared 1991)


Z++ is also a version of the C++ programming language (not to be confused with Z++ that this article is about).Z++  (pronounced zee plus plus) was an object-oriented extension to the Z specification language. Z++ is an object-oriented extension to the Z specification language, allowing for the definition of classes, and the relation of classes through inheritance, association or aggregation. The primary construct of Z++ is a class.  A Z++ class consists of a number of clauses which are optional. Z++ Class Structure:  CLASS ClassName   [OWNS List_of_attributes]   [FUNCTIONS constant_definitions]   [TYPE type_declaration]   [ENTENDS list_of_super_classes]   [OPERATIONS list_of_state_change_operations_definitions]   [RETURNS list_of_query_operations_definitions]   [ACTIONS all_operations_declarations]   [INVARIANT predicates]   [HISTORY RTL_predicates] END CLASS
zz (pl, appeared 2019)
Also known as: drunk octopus
Creators: Arvid E. Picciani



GitHub description: 🍺🐙  ZetZ a zymbolic verifier and tranzpiler to bare metal C

using <stdio.h>::{printf}

export fn main() -> int {
    let r = Random{
        num: 42,
    };
    printf("your lucky number: %u\n", r.gen());
    return 0;
}

struct Random {
    u32 num;
}

fn gen(Random *self) -> u32 {
    return self->num;
}