pldb/PLDB huggingface dataset:
Guile (pl, appeared 1993)
Stands for: GNU Ubiquitous Intelligent Language for Extensions
Creators: Aubrey Jaffer
Tom Lord
Miles Bader
Origin: GNU Project
Country: United States
Website: https://www.gnu.org/software/guile/

Guile is designed to help programmers create flexible applications that can be extended by users or other programmers with plug-ins, modules, or scripts. Guile is an implementation of the Scheme programming language, supporting the Revised5 and most of the Revised6 language reports, as well as many SRFIs. It also comes with a library of modules that offer additional features, like an HTTP server and client, XML parsing, and object-oriented programming.

GNU Guile is the preferred extension system for the GNU Project, which features an implementation of the Scheme programming language. Its first version was released in 1993.  In addition to large parts of Scheme standards, Guile Scheme includes modularized extensions for many different programming tasks.For extending programs, Guile offers "libguile" which allows the language to be embedded in other programs, and integrated closely through the C API; similarly, new types and subroutines defined through the C API can be made available as extensions to Guile itself.Guile stands for the GNU Ubiquitous Intelligent Language for Extensions. It is used in programs like GnuCash, LilyPond, GNU Guix, GuixSD, and GNU Debugger.


;;; Hello world program
(define name "World")
(display (string-append "Hello " name "!"))
(newline)
GNU Guix (distribution, appeared 2013)
Origin: GNU Project
Country: United States


GNU Guix () is a cross-platform package manager and a tool to instantiate and manage Unix-like operating systems, based on the Nix package manager with Guile Scheme APIs and specializes in providing exclusively free software. Differing from traditional package managers, Guix (like Nix) utilizes a purely functional deployment model where software is installed into unique directories generated through cryptographic hashes. Dependencies from each software are included within each hash, solving the problem of dependency hell. This approach to package management promises to generate more reliable, reproducible, and portable packages.Guix packages are defined through functional Guile Scheme APIs specifically designed for package management. Dependencies are tracked directly in this language through special values called "derivations" which are evaluated by the Guix daemon lazily. Guix keeps track of these references automatically so that installed packages can be garbage collected when no other package depends on them. At the cost of greater storage requirements, all upgrades in Guix are guaranteed to be both atomic and efficiently rolled back. This also enables multiple users to safely install software on the same system without administrator privileges. The extra storage requirements translates to greater bandwidth usage when binary substitutes are downloaded compared to distributions such as Debian. If the user chooses to build everything from source even larger storage space and bandwidth is required.  The development of GNU Guix is intertwined with Guix System (until Guix 1.0: Guix System Distribution [GuixSD]), a complete installable GNU system using the Linux-libre kernel and GNU Shepherd init system.The roll-back feature of Guix is inherited from the design of Nix and is not found in any of the popular Linux distributions such as Debian and its derivatives, Arch Linux and its derivatives, or in other major distributions such as Fedora, CentOS or OpenSUSE. The project is coordinated over the Internet by a team of volunteers and is incorporated in the French non-profit Guix Europe with members of the community.
gura (pl, appeared 2012)
Creators: Yutaka Saito
Origin: https://github.com/gura-lang
Country: Japan
Website: http://www.gura-lang.org

Gura is an iterator-oriented programming language that focuses on iterators with improved functions for calculation and data processing. It makes you be able to write an artificial code for what used to need a lot of codes of repeat syntax.


GitHub description: Gura Programming Language

prime() = {
        p = []
        for (n in 2..):xiter {
                if (!(n % p.each() == 0).or()) {
                        p.add(n)
                        n
                }
        }
}
guru (pl, appeared 2009)
Origin: The University of Iowa
Washington University
Universitat Polit`ecnica de Catalunya
Country: United States and Spain

 OpTT has been implemented in the GURU verified programming language, which includes a type- and proof-checker, and a compiler to efficient C code. In addition to the core OpTT, GURU implements a number of extensions, including ones for verification of programs using mutable state and input/output. This paper gives an introduction to verified programming in GURU.



Inductive trie : Fun(A:type).type :=
trie_none : Fun(A:type).<trie A>
| trie_exact : Fun(A:type)(s:string)(a:A).<trie A>
| trie_next : Fun(A:type)(o:<option A>)
(unique l:<charvec <trie A>>).
<trie A>.
GW-BASIC (pl, appeared 1983)
Origin: Microsoft
Country: United States


GW-BASIC is a dialect of the BASIC programming language developed by Microsoft from BASICA, originally for Compaq. It is otherwise identical to Microsoft/IBM BASICA, but is a fully self-contained executable and does not need the ROM BASIC. It was bundled with MS-DOS operating systems on IBM PC compatibles by Microsoft. Microsoft also sold a BASIC compiler, BASCOM, compatible with GW-BASIC, for programs needing more speed. The language is suitable for simple games, business programs and the like. Since it was included with most versions of MS-DOS, it was also a low-cost way for many aspiring programmers to learn the fundamentals of computer programming. With the release of MS-DOS 5.0, GW-BASIC's place was eventually taken by QBasic, the interpreter part of the separately available QuickBASIC compiler.
Gwion (pl, appeared 2016)
Origin: https://github.com/Gwion
Country: The Netherlands and United States and Turkey and France
Website: https://Gwion.github.io/Gwion

<a href='https://github.com/fennecdjay/Gwion'>Gwion</a> is a strongly-timed musical programming language .


GitHub description: :musical_note: strongly-timed musical programming language
Guix Workflow Language (pl, appeared 2017)
Stands for: Guix Workflow Language
Origin: GNU Project
Country: United States
Website: https://www.guixwl.org/




 ;; https://www.guixwl.org/extended-start
 ;; We are going to extend the workflow defined in the file
 ;; "example-workflow.w".
 define dynamic-workflow
   load-workflow "/tmp/examples/example-workflow.w"
 
 process: (list-file-template filename)
   name
     string-append "list-file-"
                   basename filename
   packages "gzip"
   inputs filename
   outputs
     string-append filename ".list"
   run-time
     complexity
       space 20 mebibytes
       time  30 seconds
   # { gzip --list {{inputs}} > {{outputs}} }
 
 ;; Get all processes of the other workflow.
 define foreign-processes
   workflow-processes dynamic-workflow
 
 ;; Get the processes that we want to extend on.
 define compress-file-processes
   processes-filter-by-name foreign-processes "compress-file"
 
 ;; Create the new processes.
 define list-file-processes
   map list-file-template
       append-map process-outputs compress-file-processes
 
 workflow: extended-dynamic-workflow
   processes
     append
       ;; These are the process connections of the imported workflow
       workflow-restrictions dynamic-workflow
       ;; And these are the new process connections.  The "zip" procedure
       ;; pairs up each of the processes in "list-file-processes" with
       ;; one of the processes in "compress-file-processes".
       zip list-file-processes compress-file-processes
Gzip (binaryDataFormat, appeared 1992)
Origin: GNU Project
Website: http://www.gnu.org/software/gzip/


gzip is a file format and a software application used for file compression and decompression. The program was created by Jean-loup Gailly and Mark Adler as a free software replacement for the compress program used in early Unix systems, and intended for use by GNU (the "g" is from "GNU"). Version 0.1 was first publicly released on 31 October 1992, and version 1.0 followed in February 1993.
Hack (pl, appeared 2014)
Creators: Julien Verlaguet
Alok Menghrajani
Drew Paroski
Origin: Facebook
Website: http://hacklang.org/


Hack is a programming language for the HipHop Virtual Machine (HHVM), created by Facebook as a dialect of PHP. The language implementation is open-source, licensed under the BSD License. Hack allows programmers to use both dynamic typing and static typing. This kind of a type system is called gradual typing, which is also implemented in other programming languages such as ActionScript. Hack's type system allows types to be specified for function arguments, function return values, and class properties; however, types of local variables are always inferred and cannot be specified.
Hackett (pl, appeared 2017)
Creators: Alexis King
Origin: https://github.com/lexi-lambda/hackett/issues
Country: United States
Website: https://lexi-lambda.github.io/hackett/

Hackett is an attempt to implement a Haskell-like language with support for Racket’s macro system, built using the techniques described in the paper Type Systems as Macros.


GitHub description: WIP implementation of a Haskell-like Lisp in Racket

#lang hackett

(data (Maybe a)
  Nothing
  (Just a))

(def x : Integer
  (let ([y 3]
        [z 7])
    {y + z}))

(class (Show a)
  [show : {a -> String}])

(instance (forall [a] (Show a) => (Show (Maybe a)))
  [show (λ* [[(Just x)] {"(Just " ++ (show x) ++ ")"}]
            [[Nothing ] "Nothing"])])
hacspec (pl, appeared 2018)
Creators: Franziskus Kiefer
Origin: https://github.com/hacspec/hacspec/discussions
Country: Germany
Website: https://hacspec.org

A specification language for crypto primitives and more in Rust.


GitHub description: A specification language for cryptography primitives.

pub type Res = (usize, usize);
pub enum ResTyp {
    Ok(Res),
}

pub fn test_simpl_fails() -> Res {
    match ResTyp::Ok((42, 42)) {
        ResTyp::Ok(res) => res,
    }
}

#[derive(Clone)]
pub struct MyTupleType(u16, u8);

pub fn test_tuple_destructuring() {
    let tuple = MyTupleType(1u16, 2u8).clone();
    let MyTupleType(_a, _b) = tuple;
}
HAGGIS (pl, appeared 2010)
Origin: University of Glasgow
Heriot Watt University
University of Strathclyde
Country: Scotland


HAGGIS is a high-level reference programming language used primarily to examine Computing Science for Scottish pupils taking SQA courses on the subject. HAGGIS is used as a tool to bridge the gap between pseudocode and typical computer programming. HAGGIS is not based on any one language but a mixture that is intended to allow a pupil familiar with any of the many languages used in classrooms to easily understand the syntactic construct being used in an example. It has multiple programming paradigms of functional, imperative and object-oriented to suit this purpose. There are three separate language definitions, one for each level at which computing is assessed by the SQA; these are proper subsets of each other, so for example any program contained by the National 5 level language is also well-defined at Higher and Advanced Higher levels. Higher includes the definition of procedures and functions and the use of record types and files, while Advanced Higher includes object-orientation. Online HAGGIS interpreters have been developed to provide a way for examiners and teachers to check their programs are correctly defined and behave as expected.
hakaru (pl, appeared 2014)
Origin: Indiana University
McMaster University
Country: United States
Website: http://hakaru-dev.github.io/

Hakaru is a simply-typed probabilistic programming language, designed for easy specification of probabilistic models and inference algorithms. This type of language is useful for the development of machine learning algorithms and stochastic modeling.


GitHub description: A probabilistic programming language

def pulls(strength real):
    normal(strength, 1)

def winner(a real, b real):
    a_pull <~ pulls(a)
    b_pull <~ pulls(b)
    return (a_pull > b_pull)

alice <~ normal(0,1)
bob   <~ normal(0,1)
carol <~ normal(0,1)

match1 <~ winner(alice, bob)
match2 <~ winner(bob, carol)
match3 <~ winner(alice, carol)
HAL Format (binaryDataFormat, appeared 2012)
Origin: https://github.com/ComparativeGenomicsToolkit
Country: Unknown

HAL is a graph-based structure to efficiently store and index multiple genome alignments and ancestral reconstructions. HAL files are represented in HDF5 format, an open standard for storing and indexing large, compressed scientific data sets. Genomes within HAL are organized according to the phylogenetic tree that relate them: each genome is segmented into pairwise DNA alignment blocks with respect to its parent and children (if present) in the tree. Note that if the phylogeny is unknown, a star tree can be used. The modularity provided by this tree-based decomposition allows for efficient querying of sub-alignments, as well as the ability to add, remove and update genomes within the alignment with only local modifications to the structure. Another important feature of HAL is reference independence: alignments in this format can be queried with respect to the coordinates of any genome they contain.


GitHub description: Hierarchical Alignment Format
HAL/S (assembly, appeared 1972)
Origin: NASA
Country: United States


HAL/S (High-order Assembly Language/Shuttle)  is a real-time aerospace programming language compiler and cross-compiler for avionics applications used by NASA and associated agencies (JPL, etc.). It has been used in many U.S. space projects since 1973 and its most significant use was in the Space Shuttle program (approximately 85% of the Shuttle software is coded in HAL/S).  It was designed by Intermetrics in 1972 for NASA and delivered in 1973. HAL/S is written in XPL, a dialect of PL/I. Although HAL/S is designed primarily for programming on-board computers, it is general enough to meet nearly all the needs in the production, verification, and support of aerospace and other real-time applications. It is currently (2005) maintained by the HAL/S project of United Space Alliance.
Halide (pl, appeared 2010)
Origin: https://github.com/halide
Country: United States
Website: http://halide-lang.org/

a language for fast, portable computation on images and tensors


GitHub description: a language for fast, portable data-parallel computation

Func blur_3x3(Func input) {
 Func blur_x, blur_y;
 Var x, y, xi, yi;

 // The algorithm - no storage or order
 blur_x(x, y) = (input(x-1, y) + input(x, y) + input(x+1, y))/3;
 blur_y(x, y) = (blur_x(x, y-1) + blur_x(x, y) + blur_x(x, y+1))/3;

 // The schedule - defines order, locality; implies storage
 blur_y.tile(x, y, xi, yi, 256, 32)
       .vectorize(xi, 8).parallel(y);
 blur_x.compute_at(blur_y, x).vectorize(x, 8);

 return blur_y;
}
Ham (pl, appeared 2013)
Creators: James Keane
Origin: https://github.com/jameskeane/ham-script/issues
Country: Canada
Website: https://github.com/jameskeane/ham-script
File extensions: ham
Keywords: class
else
extends
false
from
if
import
is
isnt
new
null
number
string
operator
or
return
true
var



GitHub description: An altJS language for the web
HAML (template, appeared 2006)
Stands for: HTML Abstraction Markup Language
Creators: Hampton Lintorn-Catlin
Origin: Unspace Interactive
Country: Canada
Website: http://haml.info/


Haml (HTML Abstraction Markup Language) is a templating system that is designed to avoid writing inline code in a web document and make the HTML easy and clean. Haml gives the flexibility to have some dynamic content in HTML. Similar to other web languages like PHP, ASP, JSP and template systems like eRuby, Haml also embeds some code that gets executed during runtime and generates HTML code in order to provide some dynamic content. In order to run Haml code, files need to have .haml extension. These files are similar to .erb or eRuby files which also help to embed Ruby code while developing a web application. While parsing coding comments, Haml uses the same rules as Ruby 1.9 or later. Haml understands only ASCII compatible encodings like UTF-8 but not UTF-16 or UTF-32 because these are not compatible with ASCII. Haml can be used in command line, as a separate Ruby module, or in a Ruby on Rails application making Haml suitable for a wide range of applications.

GitHub description: HTML Abstraction Markup Language - A Markup Haiku

%section.container
 %h1= post.title
 %h2= post.subtitle
 .content
   = post.content
hamler (pl, appeared 2019)
Creators: Feng Lee
Origin: https://github.com/hamler-lang/
Country: China
Website: https://www.hamler-lang.org/

Hamler is a strongly-typed language with compile-time typechecking and built-in support for concurrency and distribution.


GitHub description: Haskell-style functional programming language running on Erlang VM.

module Main where

import System.IO

main = print "Hello, World!"
Handel-C (pl, appeared 1996)
Origin: Oxford University Computing Laboratory
Country: United Kingdom


Handel-C is a high-level programming language which targets low-level hardware, most commonly used in the programming of FPGAs. It is a rich subset of C, with non-standard extensions to control hardware instantiation with an emphasis on parallelism.  Handel-C is to hardware design what the first high-level programming languages were to programming CPUs.  Unlike many other design languages that target a specific architecture Handel-C can be compiled to a number of design languages and then synthesised to the corresponding hardware.  This frees developers to concentrate on the programming task at hand rather than the idiosyncrasies of a specific design language and architecture.
Harbour (pl, appeared 1999)
Creators: Antonio Linares
Origin: https://github.com/harbour
Country: Various
Website: https://harbour.github.io/


Harbour is a modern computer programming language, primarily used to create database/business programs. It is a modernized, open sourced and cross-platform version of the older Clipper system, which in turn developed from the dBase database market of the 1980s and 90s. Harbour code using the same databases can be compiled under a wide variety of platforms, including Microsoft Windows, Linux, Unix variants, several BSD descendants, Mac OS X, MINIX 3, Windows CE, Pocket PC, Symbian, iOS, Android, QNX, VxWorks, OS/2/eComStation, BeOS/Haiku,  AIX and MS-DOS.
Hare (pl, appeared 2020)
Origin: https://harelang.org/community/
Country: Various
Website: https://harelang.org/

Hare is a systems programming language designed to be simple, stable, and robust. Hare uses a static type system, manual memory management, and a minimal runtime. It is well-suited to writing operating systems, system tools, compilers, networking software, and other low-level, high performance tasks.



use fmt;

export fn main() void = {
	const greetings = [
		"Hello, world!",
		"¡Hola Mundo!",
		"Γειά σου Κόσμε!",
		"Привет, мир!",
		"こんにちは世界！",
	];
	for (let i = 0z; i < len(greetings); i += 1) {
		fmt::println(greetings[i])!;
	};
};
IBM HAScript (pl, appeared 1990)
Origin: IBM
Country: United States


HAScript, or Host Access Script, is an IBM-developed macro language with an XML syntax designed for programmatic interaction with terminal-based applications. HAScript is based on a state machine principle. The first commercial implementation appeared in IBM's Host On-Demand in the late 1990s. IBM software products that use HAScript include WebSphere Host On-Demand (HOD), Personal Communications, and WebSphere Host Access Transformation Services (HATS). When accessing the IBM Mainframe the HAScript API allows for Host emulation whereby information from the host screen can be retrieved and reformatted within a webpage, or other software application.  There has been limited adoption of HAScript as it requires an intense amount of system resources, general process overhead and Java virtual machine resources.  To date, the implementation of HAScript by other software companies has been mild as the language used for communication is not universally standardized.
Haskell (pl, appeared 1990)
Creators: Paul Hudak
John Hughes
Origin: Yale University
Chalmers University
Microsoft Research
University of Edinburgh
Country: United States and United Kingdom
Website: https://www.haskell.org
File extensions: hs
lhs
Keywords: !
'
''
-
-<
-<<
->
::
;
<-
,
=
=>
>
?
#
\*
@
[|,
|]
\
\_
`
{,
}
{-,
-}
|
~
as
case
of
class
data
family
instance
default
deriving
do
forall
foreign
hiding
if
then
else
import
infix
infixl
infixr
let
in
mdo
module
newtype
proc
qualified
rec
type
where


Haskell  is a standardized, general-purpose purely functional programming language, with non-strict semantics and strong static typing. It is named after logician Haskell Curry. The latest standard of Haskell is Haskell 2010. As of May 2016, a group is working on the next version, Haskell 2020. Haskell features a type system with type inference and lazy evaluation. Type classes first appeared in the Haskell programming language. Its main implementation is the Glasgow Haskell Compiler. Haskell is based on the semantics, but not the syntax, of the language Miranda, which served to focus the efforts of the initial Haskell working group. Haskell is used widely in academia and industry.
Haxe (pl, appeared 2005)
Creators: Nicolas Cannasse
Origin: Haxe Foundation
Country: Unknown
Website: http://haxe.org
File extensions: hx
hxml


Haxe is computer software, a high-level, cross-platform, multi-paradigm programming language and compiler that can produce applications and source code, for many different computing platforms, from one code-base. It is free and open-source software, distributed under the GNU General Public License (GPL) 2.0, and the standard library under an MIT License. Haxe includes a set of common functions that are supported across all platforms, such as numeric data types, text, arrays, binary and some common file formats. Haxe also includes platform-specific application programming interface (API) for Adobe Flash, C++, PHP and other languages. Code written in the Haxe language can be source-to-source compiled into ActionScript 3, JavaScript, Java, C++, C#, PHP, Python, Lua and Node.js. Haxe can also emit small web format SWF and Neko bytecode. Major users of Haxe include BBC, Coca-Cola, Disney, Hasbro, Mattel, Nickelodeon, Prezi, TiVo, Toyota, and Zynga. OpenFL, Kha and Flambe are popular Haxe frameworks that enable creating multi-platform content from one codebase.

GitHub description: Haxe - The Cross-Platform Toolkit
Hbasic (pl, appeared 2007)
Origin: https://hbasic.sourceforge.net/join.html
Country: Germany


HBasic is an integrated development environment used to create, execute and debug programs with a Basic language. HBasic has object oriented features either in combination with precompiled C++ components (shared libraries) or class definitions (HBasic sourcecode). This also includes a version of inheritance. Hbasic is a mature Basic implementation for the Linux operating system. HBasic is released under the GNU General Public Licence. HBASIC is also the name for a BASIC interpreter created specifically for use with the Hercules Graphics Card.
HCard (xmlFormat, appeared 2009)
Origin: CommerceNet
Country: United States




<div class="vcard">
    <div class="fn org">Wikimedia Foundation Inc.</div>
    <div class="adr">
        <div class="street-address">149 New Montgomery Street, 3rd Floor</div>
        <div> <span class="locality">San Francisco</span>, <abbr class="region" title="California">CA</abbr> <span class="postal-code">94105</span></div>
        <div class="country-name">USA</div>
    </div>
    <div>Phone: <span class="tel">+1-415-839-6885</span></div>
    <div>Email: <span class="email">info@wikimedia.org</span></div>
    <div class="tel">
        <span class="type">Fax</span>:
        <span class="value">+1-415-882-0495</span>
    </div>
</div>