pldb/PLDB huggingface dataset:
Golo (pl, appeared 2012)
Creators: Webmaster
Origin: https://dev.eclipse.org/mailman/listinfo/golo-dev
Country: Unknown
Website: http://golo-lang.org


Golo is computer software, a programming language for the Java virtual machine (JVM). It is simple, with dynamic, weak typing. It was created in 2012 as part of the research activities of the DynaMid group of the Centre of Innovation in Telecommunications and Integration of service (CITI) Laboratory at Institut national des sciences appliquées de Lyon (INSA). It is distributed as free and open-source software under the Eclipse Public License 1.0.

GitHub description: Golo - a lightweight dynamic language for the JVM.
Google Apps Script (pl, appeared 2009)
Origin: Google
Country: United States


Apps Script is a scripting language for light-weight application development in the G Suite platform. It is based on JavaScript 1.6 with some portions of 1.7 and 1.8 and provides subset of ECMAScript 5 API, however instead of running on the client, it gets executed in the Google Cloud. According to Google, Apps Script "provides easy ways to automate tasks across Google products and third party services." Apps Script is also the tool that powers the add-ons for Google Docs, Sheets and Slides.
Google Cloud Platform (cloud, appeared 2011)
Origin: Google
Country: United States
Website: https://cloud.google.com/


Google Cloud Platform, offered by Google, is a suite of cloud computing services that runs on the same infrastructure that Google uses internally for its end-user products, such as Google Search and YouTube. Alongside a set of management tools, it provides a series of modular cloud services including computing, data storage, data analytics and machine learning.. Registration requires a credit card or bank account details.
Gopher (protocol, appeared 1991)
Creators: Mark P. McCahill
Farhad Anklesaria
Paul Lindner
Daniel Torrey
Bob Alberti
Origin: University of Minnesota
Country: United States


The Gopher protocol  is a TCP/IP application layer protocol designed for distributing, searching, and retrieving documents over the Internet. The Gopher protocol was strongly oriented towards a menu-document design and presented an alternative to the World Wide Web in its early stages, but ultimately Hypertext Transfer Protocol (HTTP) became the dominant protocol. The Gopher ecosystem is often regarded as the effective predecessor of the World Wide Web.The protocol was invented by a team led by Mark P. McCahill at the University of Minnesota.  It offers some features not natively supported by the Web and imposes a much stronger hierarchy on information stored on it. Its text menu interface is well-suited to computing environments that rely heavily on remote text-oriented computer terminals, which were still common at the time of its creation in 1991, and the simplicity of its protocol facilitated a wide variety of client implementations. More recent Gopher revisions and graphical clients added support for multimedia. Gopher was preferred by many network administrators for using fewer network resources than Web services.Gopher's hierarchical structure provided a platform for the first large-scale electronic library connections. Gopher has been described by some enthusiasts as "faster and more efficient and so much more organized" than today's Web services. The Gopher protocol is still in use by enthusiasts, and although it has been almost entirely supplanted by the Web, a small population of actively-maintained servers remains.
GorillaScript (pl, appeared 2013)
Creators: Cameron Knight
Origin: https://github.com/ckknight/gorillascript/issues
Country: United States
Website: https://ckknight.github.io/gorillascript
File extensions: gs
Keywords: assert
and
bitand
bitlshift
bitnot
bitor
bitrshift
biturshift
bitxor
by
const
delete
else
false
haskey
if
in
instanceof
instanceofsome
is
isnt
is-array!
is-object!
max
min
new
not
null
or
ownskey
ownsor
post-dec!
post-inc!
return
then
til
to
true
typeof!
throw?
throw
var
xor



GitHub description: GorillaScript is a compile-to-JavaScript language designed to empower the user while attempting to prevent some common errors.
Gosu (pl, appeared 2002)
Origin: Guidewire Software, Inc
Country: United States
Website: http://gosu-lang.org/
File extensions: gs
gsp
gst
gsx


Gosu is a statically-typed programming language that runs on the Java Virtual Machine released under the Apache 2. This general-purpose programming language is used in several open-source software projects including SparkGS and Ragnar DB among several others, and is widely used in the insurance industry via Guidewire Software's commercial products. The language borrows from several existing languages including Java, C#, and ECMAScript. A notable and unique feature is its Open Type System, which allows the language to be easily extended to provide compile-time checking and IDE awareness of information that is typically checked only at runtime in most other languages. Also of note is the language's ability to serve as both a full-featured general purpose language and as a concise scripting language. For instance, Gosu has free-form Program types (.gsp files) for scripting as well as statically verified Template files (.gst files). Gosu can optionally execute these and all other types directly from source without precompilation, which also distinguishes it from other static languages.
General Purpose Simulation System (pl, appeared 1960)
Stands for: General Purpose Simulation System
Origin: IBM
Country: United States


General Purpose Simulation System (GPSS) is a discrete time simulation general-purpose programming language, where a simulation clock advances in discrete steps. A system is modelled as transactions enter the system and are passed from one service (represented by blocks) to another. It is used primarily as a process flow oriented simulation language; this is particularly well-suited for problems such as a factory.
GRAAL (pl, appeared 1986)
Origin: Université Pierre-et-Marie-Curie
IBM
Country: France


Graal may refer to:  A style of glassblowing Holy Grail, or "Graal" in older forms Graal-Müritz, a health resort by the Baltic Sea in Germany Graal Radio - internet streaming radio GraalVM, a Java virtual machine extension aiming to support more languages and execution modes Graal (album), an album by Polish rapper Tau (AKA Medium) Graal Online, an MMORPG for Windows, Linux, OS X, and iOS. The German Wikipedia has an article here.
Grace (pl, appeared 2010)
Origin: Portland State University
Country: United States
Website: https://web.cecs.pdx.edu/~grace/

The purpose of Grace is to allow novices to discover programming in the simplest possible way. Other famous languages such as Java or Python are widely used by professionals, but may be hard to assimilate for a beginner in programming. That is what the object-oriented Grace language is made for.



class cat {
    def name = "Felix"
    method getName {
        return name
    }
}
Grammar (grammarLanguage, appeared 2017)
Creators: Breck Yunits
Origin: https://github.com/breck7/jtree/issues
Country: United States and Ireland and Norway and India
Website: https://jtree.treenotation.org/langs/grammar/

Grammar is a Tree Language for creating new Tree Languages. By creating a grammar file you get a parser, a type checker, syntax highlighting, autocomplete, a compiler, and interpreter for executing your new language. Grammar uses both postfix and prefix language features.


GitHub description: Build your own language using Tree Notation.

latinNode
 root
 catchAllParser anyNode
anyNode
 baseParser blobNode
Grammatical Framework (grammarLanguage, appeared 1998)
Origin: Xerox Research Centre Europe
Country: France


Grammatical Framework (GF) is a programming language for writing grammars of natural languages. GF is capable of parsing and generating texts in several languages simultaneously while working from a language-independent representation of meaning. Grammars written in GF can be compiled into different formats including JavaScript and Java and can be reused as software components. A companion to GF is the GF Resource Grammar Library, a reusable library for dealing with the morphology and syntax of a growing number of natural languages. Both GF itself and the GF Resource Grammar Library are open-source. Typologically, GF is a functional programming language. Mathematically, it is a type-theoretic formal system (a logical framework to be precise) based on Martin-Löf's intuitionistic type theory, with additional judgments tailored specifically to the domain of linguistics.
GraphIt (pl, appeared 2017)
Origin: https://github.com/GraphIt-DSL
Country: United States
Website: http://graphit-lang.org/
File extensions: gt

GraphIt is a new DSL for graph computations that generates fast implementations for algorithms with different performance characteristics running on graphs with different sizes and structures. GraphIt separates what is computed (algorithm) from how it is computed (schedule). Programmers specify the algorithm using an algorithm language, and performance optimizations are specified using a separate scheduling language. The scheduling language enables programmers to easily search through this complicated tradeoff space by composing together a large set of edge traversal and vertex data layout optimizations.


GitHub description: GraphIt - A High-Performance Domain Specific Language for Graph Analytics

element Vertex end
element Edge end
const edges : edgeset{Edge}(Vertex,Vertex) = load (argv[1]);
const vertices : vertexset{Vertex} = edges.getVertices();
const old_rank : vector{Vertex}(double) = 1.0/vertices.size();
const new_rank : vector{Vertex}(double) = 0.0;
const out_degree : vector {Vertex}(int) = edges.getOutDegrees();
const contrib : vector{Vertex}(double) = 0.0;
const error : vector{Vertex}(double) = 0.0;
const damp : double = 0.85;
const beta_score : double = (1.0 - damp) / vertices.size();

func computeContrib(v : Vertex)
    contrib[v] = old_rank[v] / out_degree[v];
end

func updateEdge(src : Vertex, dst : Vertex)
    new_rank[dst] += contrib[src];
end

func updateVertex(v : Vertex)
    var old_score : double = old_rank[v];
    new_rank[v] = beta_score + damp*(new_rank[v]);
    error[v] = fabs(new_rank[v] - old_rank[v]);
    old_rank[v] = new_rank[v];
    new_rank[v] = 0.0;
end

func printRank(v : Vertex)
    print old_rank[v];
end

func reset(v: Vertex)
    old_rank[v] = 1.0/vertices.size();
    new_rank[v] = 0.0;
end

func main()
    for trail in 0:10
      startTimer();
        vertices.apply(reset);
      for i in 0:20
          vertices.apply(computeContrib);
            #s1# edges.apply(updateEdge);
            vertices.apply(updateVertex);
      end

      var elapsed_time : double = stopTimer();
      print "elapsed time: ";
      print elapsed_time;
    end
end

% specify schedules here or use a separate schedule file
Graph Modeling Language (application, appeared 1997)
Origin: University of Passau
Country: Germany


Graph Modeling Language (GML) is a hierarchical ASCII-based file format for describing graphs. It has been also named Graph Meta Language.


graph
[
  directed 0
  node
  [
    id 0
    label "Node 1"
    value 100
  ]
  node
  [
    id 1
    label "Node 2"
    value 200
  ]
  edge
  [
    source 1
    target 0
  ]
]
Graphics BASIC (pl, appeared 1983)
Origin: Epyx, Inc
Country: United States


Graphics BASIC is a third-party extension to the Commodore BASIC V2.0 programming language of the Commodore 64 computer. It was originally written in 1983 by Ron Gilbert and Tom McFarlane. The program was licensed to Hesware, who briefly sold the program in 1984 as part of their product line before going out of business. The program was later extended by Ken Rose and Jack Thornton, and repackaged and sold in 1985 by Epyx under the title Programmers BASIC Toolkit.  Graphics BASIC adds over 100 new commands to the BASIC language, providing an easy-to-use API to the relatively advanced (at the time) graphics and sound hardware capabilities of the Commodore 64. The only access to these features with Commodore BASIC alone is through the cumbersome use of PEEK and POKE commands. Graphics BASIC was delivered on a single 5.25" floppy disk, containing the language itself and numerous, very simple demo programs showing off the new features of the language. A cartridge version was also available.
GraphML (xmlFormat, appeared 2001)
Origin: https://list.dia.uniroma3.it/mailman/listinfo/gdnet
Country: Various


GraphML is an XML-based file format for graphs. The GraphML file format results from the joint effort of the graph drawing community to define a common format for exchanging graph structure data. It uses an XML-based syntax and supports the entire range of possible graph structure constellations including directed, undirected, mixed graphs, hypergraphs, and application-specific attributes.
GraphQL+- (queryLanguage, appeared 2017)
Origin: https://github.com/dgraph-io
Country: United States
Website: https://docs.dgraph.io/query-language/

Dgraph’s GraphQL+- is based on Facebook’s GraphQL. GraphQL wasn’t developed for Graph databases, but its graph-like query syntax, schema validation and subgraph shaped response make it a great language choice. We’ve modified the language to better support graph operations, adding and removing features to get the best fit for graph databases. We’re calling this simplified, feature rich language, “GraphQL+-”.
GraphQL Schema Definition Language (idl, appeared 2018)
Origin: https://github.com/graphql/
Country: Various

A type definition syntax to the GraphQL specification.



# Enumeration type for a level of priority
enum Priority {
  LOW
  MEDIUM
  HIGH
}
# Our main todo type
type Todo {
  id: ID!
  name: String!
  description: String
  priority: Priority!
}
type Query {
  # Get one todo item
  todo(id: ID!): Todo
  # Get all todo items
  allTodos: [Todo!]!
}
type Mutation {
  addTodo(name: String!, priority: Priority = LOW): Todo!
  removeTodo(id: ID!): Todo!
}
schema {
  query: Query
  mutation: Mutation
}
GraphQL (queryLanguage, appeared 2012)
Creators: Lee Byron
Origin: Facebook
Website: http://graphql.org/
Keywords: null
true
false
query
mutation
subscription
extend
schema
directive
scalar
type
interface
union
enum
input
implements
fragment
on


GraphQL is a data query language developed internally by Facebook in 2012 before being publicly released in 2015. It provides an alternative to REST and ad-hoc webservice architectures.. It allows clients to define the structure of the data required, and exactly the same structure of the data is returned from the server. It is a strongly typed runtime which allows clients to dictate what data is needed. This avoids both the problems of over-fetching as well as under-fetching of data. Major GraphQL clients include Apollo Client and Relay. GraphQL servers are available for multiple languages, including JavaScript, Python, Ruby, Java, C#, Scala, Go, Elixir, Erlang, PHP, and Clojure.
GRASS (pl, appeared 1977)
Origin: Ohio State University
Country: United States


GRASS (GRAphics Symbiosis System) is a programming language created to script 2D vector graphics animations. GRASS was similar to BASIC in syntax, but added numerous instructions for specifying 2D object animation, including scaling, translation, rotation and color changes over time. It quickly became a hit with the artistic community who were experimenting with the new medium of computer graphics, and is most famous for its use by Larry Cuba to create the original "attacking the Death Star will not be easy" animation in Star Wars (1977). A later version that was adapted to support raster graphics was known as ZGrass.
Gremlin (queryLanguage, appeared 2009)
Creators: Marko A. Rodriguez
Origin: https://issues.apache.org/jira/projects/TINKERPOP/issues/TINKERPOP-2814?filter=allopenissues
Country: Various


Gremlin is a graph traversal language and virtual machine developed by Apache TinkerPop of the Apache Software Foundation. Gremlin works for both OLTP-based graph databases as well as OLAP-based graph processors. Gremlin's automata and functional language foundation enable Gremlin to naturally support imperative and declarative querying, host language agnosticism, user-defined domain specific languages, an extensible compiler/optimizer, single- and multi-machine execution models, hybrid depth- and breadth-first evaluation, as well as Turing Completeness. As an explanatory analogy, Apache TinkerPop and Gremlin are to graph databases what the JDBC and SQL are to relational databases. Likewise, the Gremlin traversal machine is to graph computing as what the Java virtual machine is to general purpose computing.


g.V().hasLabel('movie').values('year').min()
grep (pl, appeared 1974)
Origin: AT&T Bell Laboratories
Country: United States


grep is a command-line utility for searching plain-text data sets for lines that match a regular expression. Its name comes from the ed command g/re/p (globally search a regular expression and print), which has the same effect: doing a global search with the regular expression and printing all matching lines. Grep was originally developed for the Unix operating system, but later available for all Unix-like systems.
GRML (pl, appeared 2003)


GRML – an acronym for General Reuse Markup Language – is a markup language similar to HTML and XML, using tags to organize data in files and web pages. Data is organized in columns and rows. Tags are used to define forms, images, and hyper-linking. Its syntax, like HTML, is based on a simplified subset of SGML. GRML is not in very wide use as of May 2005.  GRML is a data-oriented format which defines data content rather than data presentation; the file or web browser determines how data is displayed. This is the same goal as HTML's separating CSS from HTML, moving away from <font> tags, but GRML takes it even further. One of the key aims in creating the format was to separate "views" of the data from "forms" used to manipulate it. It is also a common result of a typographical error when attempting to type HTML, because HT and GR are adjacent on a Qwerty keyboard.
groff (textMarkup, appeared 1990)
Origin: GNU Project
Country: United States
Website: https://www.gnu.org/software/groff/groff.html

Groff (GNU troff) is a typesetting system that reads plain text mixed with formatting commands and produces formatted output. Output may be PostScript or PDF, html, or ASCII/UTF8 for display at the terminal. Formatting commands may be either low-level typesetting requests (“primitives”) or macros from a supplied set. Users may also write their own macros. All three may be combined.



.sp 1.5i
My thoughts on the subject
.sp
Groovy (pl, appeared 2003)
Creators: James Strachan
Origin: https://github.com/grails
Country: United States and Spain and France
Website: http://groovy-lang.org/
File extensions: groovy
Keywords: as
assert
break
case
catch
class
const
continue
def
default
do
else
enum
extends
false
finally
for
goto
if
implements
import
in
instanceof
interface
new
null
package
return
super
switch
this
throw
throws
trait
true
try
while


Apache Groovy is an object-oriented programming language for the Java platform. It is a dynamic language with features similar to those of Python, Ruby, Perl, and Smalltalk. It can be used as a scripting language for the Java Platform, is dynamically compiled to Java virtual machine (JVM) bytecode, and interoperates with other Java code and libraries. Groovy uses a Java-like curly-bracket syntax. Most Java code is also syntactically valid Groovy, although semantics may be different. Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Since version 2, Groovy can also be compiled statically, offering type inference, and performance near that of Java. Groovy 2.4 was the last major release under Pivotal Software's sponsorship which ended in March 2015. Groovy has since changed its governance structure to a Project Management Committee (PMC) in the Apache Software Foundation.
Gene transfer format (textDataFormat, appeared 2006)
Origin: European Bioinformatics Institute
Country: United Kingdom


The Gene transfer format (GTF) is a file format used to hold information about gene structure.  It is a tab-delimited text format based on the general feature format (GFF), but contains some additional conventions specific to gene information.  A significant feature of the GTF that can be validated: given a sequence and a GTF file, one can check that the format is correct.  This significantly reduces problems with the interchange of data between groups.
GUIDO music notation (textDataFormat, appeared 1998)
Creators: Holger H. Hoos
Keith Hamel
Origin: Technische Universität Darmstadt
University of British Columbia
Country: Germany and Canada


GUIDO Music Notation is a computer music notation format designed to logically represent all aspects of music in a manner that is both computer-readable and easily readable by human beings. It was named after Guido of Arezzo, who pioneered today's conventional musical notation 1,000 years ago. GUIDO was first designed by Holger H. Hoos (then at Technische Universität Darmstadt, Germany, now at University of British Columbia, Canada) and Keith Hamel (University of British Columbia, Canada).  Later developments have been done by the SALIERI Project by Holger H. Hoos, Kai Renz and Jürgen F. Kilian.  GUIDO Music Notation has been designed to represent music in a logical format (with the ability to render to sheet music), whereas LilyPond is more narrowly focused on typesetting sheet music.  The basic idea behind the GUIDO design is representational adequacy which means that simple musical concepts are represented in a simple way and only complex notions require more complex representations. [1]GUIDO is not primarily focused on conventional music notation, but has been invented as an open format, capable of storing musical, structural, and notational information. GUIDO Music Notation is designed as a flexible and easily extensible open standard. In particular, its syntax does not restrict the features it can represent. Thus, GUIDO can be easily adapted and customized to cover specialized musical concepts as might be required in the context of research projects in computational musicology. More importantly, GUIDO is designed in a way that when using such custom extensions, the resulting GUIDO data can still be processed by other applications that support GUIDO but are not aware of the custom extensions, which are gracefully ignored. This design also greatly facilitates the incremental implementation of GUIDO support in music software, which can speed up the software development process significantly, especially for research software and prototypes. GUIDO has been split into three consecutive layers: Basic GUIDO introduces the main concepts of the GUIDO design and allows to represent much of the conventional music of today. Advanced GUIDO extends Basic GUIDO by adding exact score-formatting and some more advanced musical concepts. Finally, Extended GUIDO can represent user-defined extensions, like microtonal information or user defined pitch classes.


[ \clef<"treble"> \key<"D"> \meter<"4/4">
 a1*1/2 b a/4. g/8 f#/4 g a/2 b a/4. g/8 f#/4 g
 a/2 a b c#2/4 d c#/2 b1 a/1 ]