pldb/PLDB huggingface dataset:
EverParse3D (idl, appeared 2022)
Creators: Nikhil Swamy
Tahina Ramananandro
Aseem Rastogi
Irina Spiridonova
Haobin Ni
Dmitry Malloy
Juan Vazquez
Michael Tang
Omar Cardona
Arti Gupta
Origin: Microsoft

Addressing this need, we present EverParse3D, a parser generator for binary message formats that yields performant C code backed by fully automated formal proofs of memory safety, arithmetic safety, functional correctness, and even double-fetch freedom to prevent certain kinds of time-of check/time-of-use errors. This allows systems developers to specify their message formats declaratively and to integrate correct-by-construction C code into their applications, eliminating several classes of bugs. EverParse3D has been in use in the Windows kernel for the past year. Applied primarily to the Hyper-V network virtualization stack, the formats of nearly 100 different messages spanning four protocols have been specified in EverParse3D and the resulting formally proven parsers have replaced prior handwritten code.



typedef struct _OrderedPair {
 UINT32 fst;
 UINT32 snd { fst <= snd };
 } OrderedPair;
EXEC 2 (pl, appeared 1970)
Origin: IBM
Country: United States


EXEC 2 is an interpreted, command procedure control, computer scripting language used by the EXEC 2 Processor supplied with the IBM Virtual Machine/System Product (VM/SP) operating system.EXEC 2 is similar to EXEC with the following enhancements: There is no 8-byte restriction on token length. Statements can be up to 255 characters long. EXEC 2 can issue commands to subcommand environments as well as CMS and CP. EXEC 2 has additional built-in functions. EXEC 2 commands may include subroutines and functions. EXEC 2 has extra debugging facilities. CMS programs can manipulate EXEC 2 variables.
Executable JSON (pl, appeared 2013)
Creators: Todd Davies
Origin: http://todddavies.co.uk
Country: United Kingdom
Website: https://gist.github.com/Todd-Davies/7666505#file-executable-json




[
    {"x":9},
    {"y":3},
    ["print The value of x is: $x"],
    ["print The value of x is: $y"],
    ["print Now lets add x and y"],
    ["add $z $x $y"],
    ["print The answer is: $z"],
    ["print Now lets subtract y from x"],
    ["sub $z $x $y"],
    ["print The answer is: $z"],
    ["print Now lets divide x by y"],
    ["div $z $x $y"],
    ["print The answer is: $z"],
    ["print Now lets multiply x by y"],
    ["mul $z $x $y"],
    ["print The answer is: $z"],
    {"myMethod":
      {
        "params": [
          "p1",
          "p2"
        ],
        "body": [
          {"nestedMethod":
            {
              "params": [
                "p1"
              ],
              "body": [
                ["print Methods can be nested, and arguments can be trickled down."],
                ["print The result was: $p1"]
              ]
            }
        },
          ["print You passed me: $p1 and $p2"],
          ["print Lets add them and pass the result into another method!"],
          ["add $p2 $p1 $p2"],
          ["!nestedMethod $p2"]
        ]
      }
  },
  ["!myMethod $x $y"]
]
ExFAT (filesystem, appeared 2006)
Origin: Microsoft
Country: United States


exFAT (Extended File Allocation Table) is a Microsoft file system introduced in 2006 and optimized for flash memory such as USB flash drives and SD cards. It is proprietary and Microsoft owns patents on several elements of its design.exFAT can be used where NTFS is not a feasible solution (due to data-structure overhead), but a greater file-size limit than the standard FAT32 file system (i.e. 4 GiB) is required. exFAT has been adopted by the SD Card Association as the default file system for SDXC cards larger than 32 GiB.
exkited (template, appeared 2018)
Creators: Brandon Barber
Origin: https://exkited.com
Country: United States
Website: https://exkited.com



GitHub description: A minimalistic templating language that lets you generate markup with JavaScript.

<html>
    <div class="title">
        <@ return data.title @> // A 'data' object may be passed rendering.
    </div>
    <@
        let result = '';
        for(let x=0;x<10;x++) {
            for(let i=0;i<4;i++) {
                for(let j=0;j<4;j++){
                    result += `<div>@{i+j}</div>`;
                }
            }
        }
        return result;
    @>
    <div class="average-price">
        <@ return data.prices.reduce((accum, val) => accum += val) / data.prices.length; @>
    </div>
    <div class="day-of-week">
        <@
            switch(data.dayIdx) {
                case 0:
                return 'Sunday';
                case 1:
                return 'Monday';
                case 2:
                return 'Tuesday';
                case 3:
                return 'Wednesday';
                case 4:
                return 'Thursday';
                case 5:
                return 'Friday';
                case 6:
                return 'Saturday';
            }
        @>
    </div>
</html>
Expect (pl, appeared 1990)
Origin: www.tcl.tk/community/coreteam
Country: Various
Website: http://core.tcl.tk/expect/index


Expect, an extension to the Tcl scripting language written by Don Libes, is a program to automate interactions with programs that expose a text terminal interface.  Expect was originally written in 1990 for Unix systems, but has since become available for Microsoft Windows and other systems.


# Assume $remote_server, $my_user_id, $my_password, and $my_command were read in earlier
# in the script.
# Open a telnet session to a remote server, and wait for a username prompt.
spawn telnet $remote_server
expect "username:"
# Send the username, and then wait for a password prompt.
send "$my_user_id\r"
expect "password:"
# Send the password, and then wait for a shell prompt.
send "$my_password\r"
expect "%"
# Send the prebuilt command, and then wait for another shell prompt.
send "$my_command\r"
expect "%"
# Capture the results of the command into a variable. This can be displayed, or written to disk.
set results $expect_out(buffer)
# Exit the telnet session, and wait for a special end-of-file character.
send "exit\r"
expect eof
Explorer (visual, appeared 2020)
Also known as: Hannah
Creators: Hannah Ritchie
Breck Yunits
Shahid Ahmad
Origin: Our World In Data

Programs are encoded as TSVs so are easy to read+write from a spreadsheet IDE, code, or plain text editor.



selection	Canada~India			
title	Population of different countries			
subtitle	How many people live in each country?			
type	DiscreteBar			
hasMapTab	true			
hideControls	true			
ySlugs	Population			
table				
	Country	Population	Year	MapleleafsInFlag
	Canada	32000000	2020	1
	India	1000000000	2020	0
	France	50000000	2020	0
columns				
	slug	type	name	notes
	Country	EntityName	Country	Unreviewed
	Population	Numeric	Population	Unreviewed
	Year	Year	Year	Unreviewed
	MapleleafsInFlag	Numeric	MapleleafsInFlag	Unreviewed
EXPRESS (dataNotation, appeared 2004)
Origin: International Organization for Standardization
Country: Switzerland


EXPRESS is a standard data modeling language for product data. EXPRESS is formalized in the ISO Standard for the Exchange of Product model STEP (ISO 10303), and standardized as ISO 10303-11.


SCHEMA Family;

ENTITY Person
   ABSTRACT SUPERTYPE OF (ONEOF (Male, Female));
     name: STRING;
     mother: OPTIONAL Female;
     father: OPTIONAL Male;
END_ENTITY;

ENTITY Female
   SUBTYPE OF (Person);
END_ENTITY;

ENTITY Male
   SUBTYPE of (Person);
END_ENTITY;

END_SCHEMA;
Extended file system (filesystem, appeared 1992)
Origin: The Linux Foundation
Country: United States


The extended file system, or ext, was implemented in April 1992 as the first file system created specifically for the Linux kernel. It has metadata structure inspired by the traditional Unix File System (UFS) and was designed by Rémy Card to overcome certain limitations of the MINIX file system. It was the first implementation that used the virtual file system (VFS), for which support was added in the Linux kernel in version 0.96c, and it could handle file systems up to 2 gigabytes (GB) in size.ext was the first in the series of extended file systems.  In 1993 it was superseded by both ext2 and xiafs, which competed for a time, but ext2 won because of its long-term viability: ext2 remedied issues with ext, such as the immutability of inodes and fragmentation.
Ext2 (filesystem, appeared 1993)
Origin: The Linux Foundation
Country: United States


The ext2 or second extended file system is a file system for the Linux kernel.  It was initially designed by Rémy Card as a replacement for the extended file system (ext).  Having been designed according to the same principles as the Berkeley Fast File System from BSD, it was the first commercial-grade filesystem for Linux.The canonical implementation of ext2 is the "ext2fs" filesystem driver in the Linux kernel. Other implementations (of varying quality and completeness) exist in GNU Hurd, MINIX 3, some BSD kernels, in MiNT, and as third-party Microsoft Windows and macOS drivers. ext2 was the default filesystem in several Linux distributions, including Debian and Red Hat Linux, until supplanted more recently by ext3, which is almost completely compatible with ext2 and is a journaling file system. ext2 is still the filesystem of choice for flash-based storage media (such as SD cards and USB flash drives) because its lack of a journal increases performance and minimizes the number of writes, and flash devices have a limited number of write cycles. However, recent Linux kernels support a journal-less mode of ext4 which provides benefits not found with ext2.
Ext3 (filesystem, appeared 2001)
Origin: The Linux Foundation
Country: United States


ext3, or third extended filesystem, is a journaled file system that is commonly used by the Linux kernel. It used to be the default file system for many popular Linux distributions. Stephen Tweedie first revealed that he was working on extending ext2 in Journaling the Linux ext2fs Filesystem in a 1998 paper, and later in a February 1999 kernel mailing list posting. The filesystem was merged with the mainline Linux kernel in November 2001 from 2.4.15 onward. Its main advantage over ext2 is journaling, which improves reliability and eliminates the need to check the file system after an unclean shutdown. Its successor is ext4.
Extended ML (pl, appeared 1985)
Origin: University of Edinburgh
Country: United Kingdom


Extended ML is a wide-spectrum language covering both specification and implementation and based on the ML programming language. It extends the syntax of ML to include axioms, which need not be executable but can rigorously specify the behavior of the program. With this addition the language can be used for stepwise refinement, proceeding gradually from an initial formal specification to eventually yield an executable Standard ML program. Correctness of the final executable SML program with respect to the original specification can then be established by proving the correctness of each of the refinement steps. Extended ML is used for research into and teaching of formal program development and specification, and research into automatic program verification. Extended ML is neither related to the programming language Extensible ML (other than being similarly derived from ML), nor to the specification language eXtensible Markup Language.
Extensible Embeddable Language (pl, appeared 2005)
Creators: David Olofson
Origin: https://github.com/olofson
Country: Sweden


The Extensible Embeddable Language (EEL) is a scripting and programming language in development by David Olofson. EEL is intended for scripting in realtime systems with cycle rates in the kHz range, such as musical synthesizers and industrial control systems, but also aspires to be usable as a platform independent general purpose programming language.
Ezhil (pl, appeared 2007)
Creators: Muthu Annamalai
Origin: Google scholar
Country: United States
Website: http://ezhillang.org


Ezhil, in Tamil language script (எழில்), is a compact, open source, interpreted, programming language, originally designed to enable native-Tamil speaking students, K-12 age-group to learn computer programming, and enable learning numeracy and computing, outside of linguistic expertise in predominately English language-based computer systems. In the Ezhil programming language, Tamil keywords and language-grammar are chosen to easily enable the native Tamil speaker write programs in the Ezhil system. Ezhil allows easy representation of computer program closer to the Tamil language logical constructs equivalent to the conditional, branch and loop statements in modern English based programming languages. Ezhil is the first freely available programming language in the Tamil language and one of many known non-English-based programming languages. The language was officially announced in July 2009, while it has been developed since late 2007.
F-Script (pl, appeared 2009)
Creators: Philippe Mougin
Origin: https://github.com/pmougin
Country: United States
Website: https://github.com/pmougin/F-Script


F-Script is an object-oriented scripting programming language for Apple's macOS operating system developed by Philippe Mougin.  F-Script is an interactive language based on Smalltalk, using macOS's native Cocoa API.
F# (pl, appeared 2005)
Also known as: f#
fsharp
Creators: Don Syme
Origin: Microsoft Research
Country: United Kingdom
Website: http://fsharp.org
File extensions: fs
fsi
fsx
fsscript
Keywords: abstract
and
atomic
as
assert
asr
base
begin
break
checked
component
const
constraint
constructor
continue
class
default
delegate
do
done
downcast
downto
elif
else
end
exception
eager
event
external
extern
false
finally
for
fun
function
fixed
functor
global
if
in
include
inherit
inline
interface
internal
land
lor
lsl
lsr
lxor
lazy
let
match
member
mod
module
mutable
namespace
method
mixin
new
not
null
of
open
or
object
override
private
parallel
process
protected
pure
public
rec
return
static
sealed
struct
sig
then
to
true
tailcall
trait
try
type
upcast
use
val
void
virtual
volatile
when
while
with
yield


F# (pronounced F sharp) is a strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. F# is most often used as a cross-platform Common Language Infrastructure (CLI) language, but it can also generate JavaScript and graphics processing unit (GPU) code. F# is developed by the F# Software Foundation, Microsoft and open contributors. An open source, cross-platform compiler for F# is available from the F# Software Foundation. F# is also a fully supported language in Visual Studio and Xamarin Studio. Other tools supporting F# development include Mono, MonoDevelop, SharpDevelop, MBrace and WebSharper. Plug-ins supporting F# exist for many widely used editors, most notably the Ionide extension for Atom and Visual Studio Code, and integrations for other editors such as Vim, Emacs, and Sublime Text. F# is member of the ML language family and originated as a .NET Framework implementation of a core of the programming language OCaml, It has also been influenced by C#, Python, Haskell, Scala, and Erlang.
F (pl, appeared 1996)
Origin: The Fortran Company
Country: United States


F is a modular, compiled, numeric programming language, designed for scientific programming and scientific computation. F was developed as a modern Fortran, thus making it a subset of Fortran 95. It combines both numerical and data abstraction features from these languages. F is also backwards compatible with Fortran 77, allowing calls to Fortran 77 programs. F was first included in the g95 compiler.
Fable (pl, appeared 2012)
Origin: https://github.com/fable-compiler
Country: Various
Website: https://fable.io/

Fable is a compiler that brings F# into the JavaScript ecosystem



type Face =
    | Ace | King | Queen | Jack
    | Number of int
type Color =
    | Spades | Hearts | Diamonds | Clubs
type Card =
    | Face * Color
let aceOfHearts = Ace, Hearts
let tenOfSpades = (Number 10), Spades
match card with
| Ace, Hearts -> printfn "Ace Of Hearts!"
| _, Hearts -> printfn "A lovely heart"
| (Number 10), Spades -> printfn "10 of Spades"
| _, (Diamonds|Clubs) -> printfn "Diamonds or clubs"
// Warning:
// Incomplete pattern matches on this expression.
// For example, the value '(_,Spades)' may indicate
// a case not covered by the pattern(s).
Facelets (template, appeared 2005)
Origin: https://javaee.github.io
Country: United States


In computing, Facelets is an open-source Web template system under the Apache license and the default view handler technology (aka view declaration language) for JavaServer Faces (JSF). The language requires valid input XML documents to work. Facelets supports all of the JSF UI components and focuses completely on building the JSF component tree, reflecting the view for a JSF application. Although both JSP and JSF technologies have been improved to work better together, Facelets eliminates the issues noted in Hans Bergsten's article "Improving JSF by Dumping JSP"Facelets draws on some of the ideas from Apache Tapestry, and is similar enough to draw comparison. The project is conceptually similar to Tapestry's, which treats blocks of HTML elements as framework components backed by Java classes. Facelets also has some similarities to the Apache Tiles framework with respect to support templating as well as composition. Facelets was originally created by Jacob Hookom in 2005 as a separate, alternative view declaration language for JSF 1.1 and JSF 1.2 that both used JSP as the default view declaration language. Starting from JSF 2.0, Facelets has been promoted by the JSF expert group to be the default view declaration language. JSP has been deprecated as a legacy fall back.
FaCT (pl, appeared 2017)
Also known as: FACT
Creators: Deian Stefan
Origin: University of California San Diego
Stanford University
PI for Security and Privacy
Inria Sophia Antipolis
IMDEA Software Institute
Country: United States and Germany and France and Spain

FaCT is a domain-specific language that aids you in writing constant-time code for cryptographic routines that need to be free from timing side channels. This is the compiler for the Flexible and Constant Time cryptographic programming language. Real-world cryptographic code is often written in a subset of C intended to execute in constant-time, thereby avoiding timing side channel vulnerabilities. This C subset eschews structured programming as we know it: if-statements, looping constructs, and procedural abstractions can leak timing information when handling sensitive data. The resulting obfuscation has led to subtle bugs, even in widely-used high-profile libraries like OpenSSL. To address the challenge of writing constant-time cryptographic code, we present FaCT, a crypto DSL that provides high-level but safe language constructs. The FaCT compiler uses a secrecy type system to automatically transform potentially timing-sensitive high-level code into low-level, constant-time LLVM bitcode. We develop the language and type system, formalize the constant-time transformation, and present an empirical evaluation that uses FaCT to implement core crypto routines from several open-source projects including OpenSSL, libsodium, and curve25519-donna. Our evaluation shows that FaCT's design makes it possible to write \emph{readable}, high-level cryptographic code, with \emph{efficient}, \emph{constant-time} behavior.


GitHub description: Flexible and Constant Time Programming Language

void
swap_conditional(secret mut uint64[5] a, secret mut uint64[5] b, secret uint64 swapi) {
  if (swapi == 1) {
    for (uint32 i from 0 to 5) {
      secret uint64 x = a[i];
      a[i] = b[i];
      b[i] = x;
    }
  }
}
Fully Automated Compiling Technique (pl, appeared 1959)
Stands for: Fully Automated Compiling Technique
Origin: Computer Sciences Corporation
Honeywell
Country: United States

FACT is an early discontinued computer programming language, created by the Datamatic Division of Minneapolis Honeywell for its model 800 series business computers in 1959. FACT was an acronym for "Fully Automated Compiling Technique". It was an influence on the design of the COBOL programming language.

FACT is an early discontinued computer programming language, created by the Datamatic Division of Minneapolis Honeywell for its model 800 series business computers in 1959.  FACT was an acronym for "Fully Automated Compiling Technique".  It was an influence on the design of the COBOL programming language. Some of the design of FACT was based on the linguistic project Basic English, developed about 1925 by C.K. Ogden. The software was actually designed by Computer Sciences Corporation (Fletcher Jones, Roy Nutt, and Robert L. Patrick) under contract to Richard Clippinger of Honeywell.
Factor (pl, appeared 2003)
Creators: Slava Pestov
Origin: https://github.com/factor
Country: Unknown
Website: https://factorcode.org/


Factor is a stack-oriented programming language created by Slava Pestov. Factor is dynamically typed and has automatic memory management, as well as powerful metaprogramming features. The language has a single implementation featuring a self-hosted optimizing compiler and an interactive development environment. The Factor distribution includes a large standard library.

GitHub description: Factor programming language
Falcon (pl, appeared 2003)
Creators: Giancarlo Niccolai
Origin: https://github.com/falconpl
Country: Italy
Website: http://falconpl.org
File extensions: ftd
fal
fam


Falcon is an open source, multi-paradigm programming language. Design and implementation is led by Giancarlo Niccolai, a native of Bologna, Italy and Information Technology graduate from Pistoia. Falcon translates computer source code to virtual machine instructions for evaluation. The virtual machine is intended to be both a stand-alone interpreter as well as for integration in third-party embedding applications. A core design consideration for the Falcon programming language is to provide acceptably high performing scripting plug-ins to multi threaded data acquisition, reporting and dispersion applications. As programming languages go, Falcon design leans more towards conciseness of code and expressiveness than general readability. The Falcon implementation does provide facilities for source level documentation and this documentation may become important as the mixed paradigm potential of Falcon scripting attempts to meet the problems faced with programming in the large.
False (pl, appeared 1993)
Creators: Wouter Van Oortmerssen
Origin: http://strlen.com
Country: United States
Website: http://www.strlen.com/false-language/




{ writes all prime numbers between 0 and 100 }
99 9[1-$][$@$@$@$@/*=[1-$$[%1-$@]?0[$.' ,]?]?]#
Family BASIC (pl, appeared 1984)
Origin: Nintendo Co., Ltd
Sharp Corporation
Hudson Soft Co., Ltd
Country: Japan


Family BASIC or Famicom BASIC is the consumer product for programming Nintendo's Family Computer video game console of Japan. Family BASIC  was launched on June 21, 1984 to consumers in Japan by Nintendo, in cooperation with Hudson Soft and Sharp Corporation. A second version titled Family BASIC V3 was released on February 21, 1985, with greater memory and new features.
Fantom (pl, appeared 2005)
Origin: https://github.com/fantom-lang
Country: United States
Website: http://www.fantom.org


Fantom is a general purpose object-oriented programming language created by Brian and Andy Frank that runs on the Java Runtime Environment (JRE), JavaScript, and the .NET Common Language Runtime (CLR) (.NET support is considered "prototype" status). Its primary design goal is to provide a standard library API that abstracts away the question of whether the code will ultimately run on the JRE or CLR. Like C# and Java, Fantom uses a curly brace syntax. The language supports functional programming through closures and concurrency through the Actor model. Fantom takes a "middle of the road" approach to its type system, blending together aspects of both static and dynamic typing.