pldb/PLDB huggingface dataset:
Genie (pl, appeared 2008)
Creators: Jamie McCracken
Origin: GNOME Foundation
Country: United States


Genie is a modern, general-purpose high-level programming language in active development since 2008. It was designed as an alternative, simpler and cleaner dialect for the Vala compiler, while preserving the same functionality of the Vala language. Genie uses the same compiler and libraries as Vala; the two can indeed be used alongside each other. The differences are only syntactic. Genie's syntax is derived from numerous modern languages like Python, Boo, D and Delphi. In the vein of Python, Genie uses indentation rather than curly brackets to delimit blocks. Like Vala, Genie uses the GObject type system to create classes and interfaces declared in Genie source code, without imposing additional runtime requirements (i.e., unlike Python, Java or C#, it does not require a virtual machine). Genie allows access to C libraries, especially those based in GObject (like GTK+), without using a different application binary interface (ABI). During compilation, the code is first translated to C source and header files, which are then compiled to platform-specific machine code using any available C compiler like GCC, thus allowing cross-platform software development. Although both Vala and Genie are being developed and promoted by GNOME, programs developed in Vala and Genie don't depend on the GNOME Desktop Environment, usually requiring only GLib.


init
 print( "Hello, World!" )
GEL Genius (pl, appeared 1997)
Also known as: GEL
Origin: GNOME Foundation
Country: United States
Website: http://www.jirka.org/genius.html


Genius  (also known as the Genius Math Tool) is a free open-source numerical computing environment and programming language, similar in some aspects to MATLAB, GNU Octave, Mathematica and Maple.  Genius is aimed at mathematical experimentation rather than computationally intensive tasks.  It is also very useful as just a calculator.  The programming language is called GEL and aims to have a mathematically friendly syntax.  The software comes with a command-line interface and a GUI, which uses the GTK+ libraries.  The graphical version supports both 2D and 3D plotting.  The graphical version includes a set of tutorials originally aimed at in class demonstrations.


function f(x) = (
 if x <= 1 then
   1
 else
   (f(x-1)*x)
)
Genshi (template, appeared 2006)
Origin: https://github.com/edgewall
Country: Sweden and Japan and United States and France and Germany and Switzerland


Genshi is a template engine for XML-based vocabularies written in  Python.  Genshi is used to easily insert generated output into XML-based languages, usually HTML, and reuse elements between documents.  Genshi's syntax is based on Kid, but its architecture is different. Genshi aims to implement some of its functionality while processing templates faster, by dynamically processing templates using a stream based API, instead of compiling templates to Python code.Genshi can be used with several Python web frameworks, such as CherryPy, TurboGears, Pylons and web2py. Genshi has replaced Kid in the TurboGears 2.x web framework.
gentee (pl, appeared 2018)
Creators: Alexey Krivonogov
Origin: https://github.com/gentee
Country: Russia
Website: http://gentee.org/

Script programming language for automation. It uses VM and compiler written in Go (Golang).


GitHub description: Gentee - script programming language for automation. It uses VM and compiler written in Go (Golang).

#!/usr/local/bin/gentee
# stdin = 1024\n384\n0

// Copyright 2019 Alexey Krivonogov. All rights reserved.
// Use of this source code is governed by a MIT license
// that can be found in the LICENSE file.

func gcd( int left right ) int
{
    if right == 0 : return left
    return gcd( right, left % right )
}

run  {
    str     input
    int     left right
    Println("This program finds the greatest common divisor by the Euclidean Algorithm.")
 
    while true
    {
       left = int( ReadString( "Enter the first number ( enter 0 to exit ): "))
       if left == 0 : break
       
       right = int( ReadString( "Enter the second number: "))
       Println("GCD = \{ gcd( left, right )}")
    }
}
Gentoo Ebuild (pl, appeared 1999)
Origin: Gentoo Foundation
Country: United States
Website: https://wiki.gentoo.org/wiki/Ebuild

An ebuild file is a text file, used by Gentoo package managers, which identifies a specific software package and how the Gentoo package manager should handle it. It uses a bash-like syntax style and is standardized through the EAPI version. Gentoo Linux uses ebuilds as the package management format for individual software titles.

An ebuild is a specialized bash script which automates compilation and installation procedures for software packages. The format was created by the Gentoo Linux project for use in its Portage software management system. Each version of an application or package in the Portage repository has a specific ebuild script written for it. The script is used by the emerge tool, also created by the Gentoo Linux project, to calculate any dependencies of the desired software installation, download the required files (and patch them, if necessary), configure the package (based on "USE flag" settings), compile, and perform a sandboxed installation (in /var/tmp/portage/[ebuild name]/image/ by default). Upon successful completion of these steps, the installed files are merged into the live system, outside the sandbox. Although most ebuilds found in the Gentoo Portage repository are used to compile programs from source code, there are also ebuilds to install binary packages, ebuilds that install only documentation or data such as fonts, and basic ebuilds called "metabuilds" whose sole purpose is to trigger the installation of other ebuilds (such as the GNOME or KDE metabuilds).


 Copyright 1999-2018 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2

EAPI=6

DESCRIPTION="A classical example to use when starting on something new"
HOMEPAGE="https://wiki.gentoo.org/index.php?title=Basic_guide_to_write_Gentoo_Ebuilds"
SRC_URI="https://dev.gentoo.org/~tomwij/files/wiki/hello-world-1.0.tar.gz"

LICENSE="MIT"
SLOT="0"
KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86"
Geography Markup Language (xmlFormat, appeared 2000)
Origin: Open Geospatial Consortium
Country: United States


The Geography Markup Language (GML) is the XML grammar defined by the Open Geospatial Consortium (OGC) to express geographical features. GML serves as a modeling language for geographic systems as well as an open interchange format for geographic transactions on the Internet. Key to GML's utility is its ability to integrate all forms of geographic information, including not only conventional "vector" or discrete objects, but coverages (see also GMLJP2) and sensor data.
GeoJSON (jsonFormat, appeared 2008)
Origin: Planet Labs
Mapbox
Hobu Inc
Cadcorp
Country: United States and United Kingdom
Website: http://geojson.org/


GeoJSON is an open standard format designed for representing simple geographical features, along with their non-spatial attributes. It is based on JSON, the JavaScript Object Notation. The features include points (therefore addresses and locations), line strings (therefore streets, highways and boundaries), polygons (countries, provinces, tracts of land), and multi-part collections of these types. GeoJSON features need not represent entities of the physical world only; mobile routing and navigation apps, for example, might describe their service coverage using GeoJSON. The GeoJSON format differs from other GIS standards in that it was written and is maintained not by a formal standards organization, but by an Internet working group of developers. A notable offspring of GeoJSON is TopoJSON, an extension of GeoJSON that encodes geospatial topology and that typically provides smaller file sizes.
Gerber Image (application, appeared 1980)
Origin: Ucamco
Country: Belgium


The Gerber format is an open ASCII vector format for 2D binary images. It is the de facto standard used by printed circuit board (PCB) industry software to describe the printed circuit board images: copper layers, solder mask, legend, etc.Gerber is used in PCB fabrication data. PCBs are designed on a specialized electronic design automation (EDA) or a computer-aided design (CAD) system. The CAD systems output PCB fabrication data to allow fabrication of the board. This data typically contains a Gerber file for each image layer (copper layers, solder mask, legend or silk...). Gerber is also the standard image input format for all bare board fabrication equipment needing image data, such as photoplotters, legend printers, direct imagers or automated optical inspection (AOI) machines and for viewing reference images in different departments. For assembly the fabrication data contains the solder paste layers and the central locations of components to create the stencil and place and bond the components.There are two major generations of Gerber format:  Extended Gerber, or RS-274X. This is the current Gerber format. In 2014, the graphics format was extended with the option to add meta-information to the graphics objects. Files with attributes are called X2 files, without X1 files. Standard Gerber, or RS-274-D. This obsolete format was revoked.The standard file extension is .GBR or .gbr though other extensions are also used.
GFA BASIC (pl, appeared 1986)
Origin: GFA Systemtechnik GmbH
Country: Germany


GFA BASIC is a dialect of the BASIC programming language, by Frank Ostrowski.  The name is derived from the company ("GFA Systemtechnik GmbH"), which distributed the software. In the mid-1980s to the 1990s it enjoyed popularity as an advanced BASIC dialect, but has been mostly superseded by several other programming languages. Official support ended in the early 2000s.
General feature format (textDataFormat, appeared 2006)
Origin: Sanger Centre
Sequence Ontology
Country: United Kingdom and United States


The general feature format (gene-finding format, generic feature format, GFF) is a file format used for describing genes and other features of DNA, RNA and protein sequences. The filename extension associated with such files is .GFF and the content type associated with them is text/x-gff3. There are two versions of the GFF file format in general use:  General Feature Format Version 2.2 especially in its GTF variant Generic Feature Format Version 3 (Sequence Ontology Project)Servers that generate this format:  Clients that use this format:
Gforth (pl, appeared 1992)
Origin: https://www.gnu.org/software/gforth/gforth.html#MAILLIST
Country: Various
Website: https://www.gnu.org/software/gforth/


Gforth is a free and portable implementation of the Forth programming language for Unix-like systems, Microsoft Windows, and other operating systems. A primary goal of Gforth is to adhere to the ANS Forth standard. Gforth is free software as part of the GNU Project.
Gherkin (pl, appeared 2008)
Also known as: Cucumber
Origin: SmartBear Software
Country: United States
Website: https://docs.cucumber.io/gherkin/

Executable specifications



Feature: Guess the word

 # The first example has two steps
 Scenario: Maker starts a game
   When the Maker starts a game
   Then the Maker waits for a Breaker to join

 # The second example has three steps
 Scenario: Breaker joins a game
   Given the Maker has started a game with the word "silky"
   When the Breaker joins the Maker's game
   Then the Breaker must guess a word with 5 characters
GIF (binaryDataFormat, appeared 1987)
Origin: CompuServe
Country: United States


The Graphics Interchange Format (GIF  JIF or  GHIF), is a bitmap image format that was developed by a team at the online services provider CompuServe led by American computer scientist Steve Wilhite on June 15, 1987. It has since come into widespread usage on the World Wide Web due to its wide support and portability between many applications and operating systems. The format supports up to 8 bits per pixel for each image, allowing a single image to reference its own palette of up to 256 different colors chosen from the 24-bit RGB color space. It also supports animations and allows a separate palette of up to 256 colors for each frame. These palette limitations make GIF less suitable for reproducing color photographs and other images with color gradients, but it is well-suited for simpler images such as graphics or logos with solid areas of color. GIF images are compressed using the Lempel–Ziv–Welch (LZW) lossless data compression technique to reduce the file size without degrading the visual quality. This compression technique was patented in 1985. Controversy over the licensing agreement between the software patent holder, Unisys, and CompuServe in 1994 spurred the development of the Portable Network Graphics (PNG) standard. By 2004 all the relevant patents had expired.
GCC GIMPLE (ir, appeared 2003)
Origin: GNU Project
Country: United States

GCC is a widely used compiler infrastructure that supports a variety of input languages, e.g., C, C++, Fortran, Java, and Ada, and over 30 different target machine architectures. GCC translates each of its front-end languages into a language-independent intermediate representation, called GIMPLE, which then gets translated to machine code for one of GCC’s many target architectures. A subset of GENERIC.
Gist (pl, appeared 1977)
Origin: Information Sciences Institute
Country: United States


In computing, GiST or Generalized Search Tree, is a data structure and API that can be used to build a variety of disk-based search trees.  GiST is a generalization of the B+ tree, providing a concurrent and recoverable height-balanced search tree infrastructure without making any assumptions about the type of data being stored, or the queries being serviced.  GiST can be used to easily implement a range of well-known indexes, including B+ trees, R-trees, hB-trees, RD-trees, and many others; it also allows for easy development of specialized indexes for new data types. It cannot be used directly to implement non-height-balanced trees such as quad trees or prefix trees (tries), though like prefix trees it does support compression, including lossy compression. GiST can be used for any data type that can be naturally ordered into a hierarchy of supersets. Not only is it extensible in terms of data type support and tree layout, it allows the extension writer to support any query predicates that they choose.  The most widely used GiST implementation is in the PostgreSQL relational database; it was also implemented in the Informix Universal Server, and as a standalone library, libgist. GiST is an example of software extensibility in the context of database systems: it allows the easy evolution of a database system to support new tree-based indexes.  It achieves this by factoring out its core system infrastructure from a narrow API that is sufficient to capture the application-specific aspects of a wide variety of index designs. The GiST infrastructure code manages the layout of the index pages on disk, the algorithms for searching indexes and deleting from indexes, and complex transactional details such as page-level locking for high concurrency and write-ahead logging for crash recovery. This allows authors of new tree-based indexes to focus on implementing the novel features of the new index type — for example, the way in which subsets of the data should be described for search — without becoming experts in database system internals. Although originally designed for answering Boolean selection queries, GiST can also support nearest-neighbor search, and various forms of statistical approximation over large data sets. The PostgreSQL GiST implementation includes support for variable length keys, composite keys, concurrency control and recovery; these features are inherited by all GiST extensions. There are several contributed modules developed using GiST and distributed with PostgreSQL. For example:  rtree_gist, btree_gist - GiST implementation of R-tree and B-tree intarray - index support for one-dimensional array of int4's tsearch2 - a searchable (full text) data type with indexed access ltree - data types, indexed access methods and queries for data organized as a tree-like structures hstore - a storage for (key,value) data cube - data type, representing multidimensional cubesThe PostgreSQL GiST implementation provides the indexing support for the PostGIS (geographic information system) and the BioPostgres bioinformatics system.
Git (application, appeared 2005)
Stands for: global information tracker
Creators: Linus Torvalds
Origin: https://github.com/git/
Country: Various
Website: https://git-scm.com


Git () is a version control system for tracking changes in computer files and coordinating work on those files among multiple people. It is primarily used for source code management in software development, but it can be used to keep track of changes in any set of files. As a distributed revision control system it is aimed at speed, data integrity, and support for distributed, non-linear workflows. Git was created by Linus Torvalds in 2005 for development of the Linux kernel, with other kernel developers contributing to its initial development. Its current maintainer since 2005 is Junio Hamano. As with most other distributed version control systems, and unlike most client–server systems, every Git directory on every computer is a full-fledged repository with complete history and full version tracking abilities, independent of network access or a central server. Git is free software distributed under the terms of the GNU General Public License version 2.

GitHub description: Git Source Code Mirror - This is a publish-only repository but pull requests can be turned into patches to the mailing list via GitGitGadget (https://gitgitgadget.github.io/). Please follow Documentation/SubmittingPatches procedure for any of your improvements.
gleam (pl, appeared 2016)
Creators: Louis Pilfold
Origin: https://github.com/gleam-lang
Country: United States and United Kingdom
Website: https://gleam.run/

Gleam is a statically typed functional programming language for building scalable concurrent systems. It compiles to Erlang and has straightforward interop with other BEAM languages such as Erlang, Elixir and LFE.


GitHub description: ⭐️ A friendly language for building type-safe, scalable systems!
Glicol (musicalNotation, appeared 2020)
Creators: Qichao Lan
Origin: University of Oslo
Country: Norway
Website: https://glicol.org



GitHub description: (Audio) graph-oriented live coding language and music DSP library written in Rust

~gate: speed 2.0
>> seq 60 _60 _~a 48;
~a: choose 48 48 48 72 0 0 0
~amp: ~gate >> envperc 0.001 0.1;
~pit: ~gate
>> mul ##Math.pow(2, (60-69)/12) * 440#
// mix js to get 261.63
~lead: saw ~pit >> mul ~amp >> lpf ~mod 5.0
>> meta `
    output = input.map(|x|x*0.1);
    output
` // rhai script, same as "mul 0.1"
~mod: sin 0.2 >> mul 1300 >> add 1500;
out: ~lead >> add ~drum >> plate 0.1 // optinal semicolon
~drum: speed 4.0 >> seq 60 >> sp \808bd;
// live drag and drop your sample  ^^^
GLMS (pl, appeared 2022)
Stands for: Generalized Linear Model Script
Creators: Sebastian Karlsson
Origin: https://github.com/sebbekarlsson/glms/issues
Country: Sweden



GitHub description: Generalized Linear Model Script

number w = 640;
number h = 480;

image img = image.make(w, h);

img.shade((vec3 uv, vec3 fragCoord, vec3 resolution) => {
  vec3 center = resolution * 0.5;
  number d = abs(distance(fragCoord, center));
  number g = 255 * (d < TAU * 6.0 * (1.0 + random()));
  vec3 color = mix(vec3(0.1, 0.3, 0.9), vec3(1), g);
  return vec4(color.xyz, 1.0);
});

img.save("test.png");
Glyph Bitmap Distribution Format (application, appeared 1988)
Origin: Adobe Inc
Country: United States


The Glyph Bitmap Distribution Format (BDF) by Adobe is a file format for storing bitmap fonts. The content takes the form of a text file intended to be human- and computer-readable. BDF is typically used in Unix X Window environments. It has largely been replaced by the PCF font format which is somewhat more efficient, and by scalable fonts such as OpenType and TrueType fonts.
Glyph (pl, appeared 2007)
Origin: Cadence Design Systems, Inc
Country: United States
Website: http://www.pointwise.com/glyph2/files/Glyph/cxx/GgGlyph-cxx.html

Glyph2 is the scripting language for Pointwise.  It is an extension to the tcl programming language that allows access to the commands and entities of the Pointwise application.
Gnuplot (pl, appeared 1986)
Origin: https://sourceforge.net/p/gnuplot/mailman/
Country: Various
Website: http://gnuplot.info/


gnuplot is a command-line program that can generate two- and three-dimensional plots of functions, data, and data fits. It is frequently used for publication-quality graphics as well as in education. The program runs on all major computers and operating systems (Linux, Unix, Microsoft Windows, macOS, and others). It is a program with a fairly long history, dating back to 1986. Despite its name, this software is not part of the GNU project.
Go! (pl, appeared 2003)
Creators: Francis McCabe
Keith Clark
Origin: Imperial College
Fujitsu Labs of America
Country: United Kingdom and United States


Go! is an agent-based programming language in the tradition of logic-based programming languages like Prolog.  It was introduced in a 2003 paper by Francis McCabe and Keith Clark.


Sex ::= male | female.
person <~ {dayOfBirth:[] => day.
           age:[] => integer.
           sex:[] => Sex.
           name:[] => string.
           home:[] => string.
           lives:[string]{}}.
person:[string, day, Sex, string] $= person.
person(Nm, Born, Sx, Hm)..{
  dayOfBirth() => Born.
  age() => yearsBetween(now(), Born).
  sex() => Sx.
  name() => Nm.
  home() => Hm.
  lives(Pl) :- Pl = home().
  yearsBetween:[integer, day] => integer.
  yearsBetween(...) => ..
}.
newPerson:[string, day, Sex, string] => person.
newPerson(Nm, Born, Sx, Hm) => $person(Nm, Born, Sx, Hm).
Go (pl, appeared 2009)
Also known as: golang
Creators: Rob Pike
Ken Thompson
Robert Griesemer
Origin: Google
Website: https://go.dev/
File extensions: go
Keywords: break
case
chan
const
continue
default
defer
else
fallthrough
for
func
go
goto
if
import
interface
map
package
range
return
select
struct
switch
type
var


Go (often referred to as golang) is a programming language created at Google in 2009 by Robert Griesemer, Rob Pike, and Ken Thompson. It is a compiled, statically typed language in the tradition of Algol and C, with garbage collection, limited structural typing, memory safety features and CSP-style concurrent programming features added. The compiler and other language tools originally developed by Google are all free and open source.

GitHub description: The Go programming language
Goal (pl, appeared 2022)
Origin: https://bardinflor.perso.aquilenet.fr/index-en
Country: France




csvs:"\n"_`
1,2,3
4,5,6
7,8,9
`
tsvs:"\n"_`
1	2	3
4	5	6
7	8	9
`
(
  (csv$''-1+"n"$csv csvs) ~ "\n"_`
0,1,2
3,4,5
6,7,8
`
  ("\t"csv$''-1+"n"$"\t"csv tsvs) ~ "\n"_`
0	1	2
3	4	5
6	7	8
`
  (csv "1,2,3") ~ (,"1" "2" "3")
)
/RESULT:
Gödel (Goedel) (pl, appeared 1992)
Also known as: Goedel
Creators: John Lloyd
Patricia Hill
Origin: University of Bristol
Country: United Kingdom


Gödel is a declarative, general-purpose programming language that adheres to the logic programming paradigm. It is a strongly typed language, the type system being based on many-sorted logic with parametric polymorphism. It is named after logician Kurt Gödel.
Godot (library, appeared 2014)
Origin: https://github.com/godotengine
Country: Various
Website: https://godotengine.org/


Godot is a 2D and 3D cross-platform compatible game engine released as open source software under the MIT license. It was initially developed for several companies in Latin America before its public release. The development environment runs on Windows, macOS, Linux, BSD and Haiku (both 32 and 64-bit) and can create games targeting PC, console, mobile and web platforms.