pldb/PLDB huggingface dataset:
OpenEdge ABL (pl, appeared 2006)
Also known as: abl
Origin: Progress Software Corporation
Country: United States


OpenEdge Advanced Business Language, or OpenEdge ABL for short, is a business application development language created and maintained by Progress Software Corporation (PSC). The language, typically classified as a fourth-generation programming language, uses an English-like syntax to simplify software development. The language was called PROGRESS or Progress 4GL up until version 9, but in 2006 PSC changed the name to OpenEdge Advanced Business Language (OpenEdge ABL) in order to overcome a presumed industry perception that 4GLs were less capable than other languages. A subset of the language, called SpeedScript, is used in the development of web applications.OpenEdge ABL helps developers to develop applications optionally using its own integrated relational database and programming tool. These applications are portable across computing systems and allow access to various popular data sources without having to learn the underlying data access methods. This means that the end-user of these products can be unaware of the underlying architecture. By combining a fourth generation language and relational database, OpenEdge ABL allows the use of the Rapid Application Development (RAD) model for developing software. A programmer and even end users can do rapid prototyping using the integrated and GUI tools of the development environment.
OpenEXR (binaryDataFormat, appeared 1999)
Origin: Industrial Light & Magic
Country: United States


OpenEXR is a high dynamic range raster file format, released as an open standard along with a set of software tools created by Industrial Light & Magic (ILM), under a free software license similar to the BSD license.It is notable for supporting multiple channels of potentially different pixel sizes, including 64-, 32- and 16-bit floating point values, as well as various compression techniques which include lossless and lossy compression algorithms.  It also has arbitrary channels and encodes multiple points of view such as left- and right-camera images.
OpenGL (library, appeared 1992)
Origin: Khronos Group
Website: https://www.opengl.org/


Open Graphics Library (OpenGL) is a cross-language, cross-platform application programming interface (API) for rendering 2D and 3D vector graphics. The API is typically used to interact with a graphics processing unit (GPU), to achieve hardware-accelerated rendering. Silicon Graphics Inc., (SGI) started developing OpenGL in 1991 and released it in January 1992; applications use it extensively in the fields of computer-aided design (CAD), virtual reality, scientific visualization, information visualization, flight simulation, and video games. Since 2006 OpenGL has been managed by the non-profit technology consortium Khronos Group.
opengraph (xmlFormat, appeared 2010)
Origin: Facebook
Country: United States
Website: https://ogp.me/

The Open Graph protocol enables any web page to become a rich object in a social graph. For instance, this is used on Facebook to allow any web page to have the same functionality as any other object on Facebook.



<html prefix="og: http://ogp.me/ns#">
<head>
<title>The Rock (1996)</title>
<meta property="og:title" content="The Rock" />
<meta property="og:type" content="video.movie" />
<meta property="og:url" content="http://www.imdb.com/title/tt0117500/" />
<meta property="og:image" content="http://ia.media-imdb.com/images/rock.jpg" />
...
</head>
...
</html>
OpenLisp (pl, appeared 1988)
Creators: Christian Jullien
Origin: Eligis (one person company)
Country: Brazil


OpenLisp is a programming language in the Lisp family developed by Christian Jullien. It conforms to the international standard for ISLISP published jointly by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), ISO/IEC 13816:1997(E), revised to ISO/IEC 13816:2007(E).Written in the programming languages C and Lisp, it runs on most common operating systems. OpenLisp is designated an ISLISP implementation, but also contains many Common Lisp-compatible extensions (hashtable, readtable, package, defstruct, sequences, rational numbers) and other libraries (network socket, regular expression, XML, Portable Operating System Interface (POSIX), SQL, Lightweight Directory Access Protocol (LDAP)).OpenLisp includes an interpreter associated to a read–eval–print loop (REPL), a Lisp Assembly Program (LAP) and a backend compiler for the language C.
OpenROAD (pl, appeared 1990)
Origin: Actian Corporation
Country: United States


OpenROAD stands for "Open Rapid Object Application Development". It is a software product of Actian Corporation. OpenROAD is a fourth-generation programming language (4GL) which include a suite of development tools, with built-in Integrated development environment (IDE) (Written in OpenROAD), Code Repository, allowing applications to be developed and deployed on Microsoft and UNIX/LINUX platforms.
OpenSCAD (pl, appeared 2010)
Origin: https://opencollective.com/openscad
Country: Norway

OpenSCAD is a 2D/3D and solid modeling program which is based on a Functional programming language used to create models that are previewed on the screen, and rendered into 3D mesh which allows the model to be exported in a variety of 2D/3D file formats. A script in the OpenSCAD language is used to create 2D or 3D models. This script is a free format list of action statements.

OpenSCAD is a free software application for creating solid 3D CAD (computer-aided design) objects. It is a script-only based modeller that uses its own description language; parts can be previewed, but it cannot be interactively selected or modified by mouse in the 3D view. An OpenSCAD script specifies geometric primitives (such as spheres, boxes, cylinders, etc.) and defines how they are modified and combined (for instance by intersection, difference, envelope combination and Minkowski sums) to render a 3D model. As such, the program does constructive solid geometry (CSG). OpenSCAD is available for Windows, Linux and OS X.


 cube(5);
 x = 4+y;
 rotate(40) square(5,10);
 translate([10,5]) { circle(5); square(4); }
 rotate(60) color("red") { circle(5); square(4); }
 color("blue") { translate([5,3,0]) sphere(5); rotate([45,0,45]) { cylinder(10); cube([5,6,7]); } }
OpenSpice (pl, appeared 2005)
Creators: Stephen Leach
Origin: The OpenSpice Group
Country: United Kingdom
Website: https://web.archive.org/web/20050204011930/https://www.openspice.org

OpenSpice is an openly available specification of the Spice language - a modern programming language with some nice XML processing features. It is designed with the needs of part-time or occasional programmers in mind. The language features are properly separated and their corner cases have been eliminated. This design means that if you only use Spice occasionally, you're likely to find it easy to come back to despite the breaks. The most similar well-known language is probably Common LISP together with CLOS. But Spice has a rich Algol-like external syntax, an XML transport form, and makes multiple values a key feature. The way Spice deals with multiple values is, we think, the feature that will strike most programmers as special.
OpenType Feature File (application, appeared 1996)
Origin: Microsoft
Adobe Systems
Country: United States

An OpenType feature file is a text file that contains the typographic layout feature specifications for an OpenType font in an easy-to-read format. It may also contain override values for certain fields in the font tables. It is read in during the creation or editing of an OpenType font.



# Script and language coverage
languagesystem DFLT dflt;
languagesystem latn dflt;

# Ligature formation
feature liga {
     substitute f i by f_i;
     substitute f l by f_l;
} liga;

# Kerning
feature kern {
     position A Y -100;
     position a y -80;
     position s f' <0 0 10 0> t;
} kern;
OpenVera (pl, appeared 2001)
Origin: Systems Science Inc
Country: United States
File extensions: vr


OpenVera is a hardware verification language developed and managed by Synopsys. OpenVera is an interoperable, open hardware verification language for testbench creation. The OpenVera language was used as the basis for the advanced verification features in the IEEE Std. 1800 SystemVerilog standard, for the benefit of the entire verification community including companies in the semiconductor, systems, IP and EDA industries along with verification services. The OpenVera language reference manual (LRM) can be obtained at no cost, but modifications to the language must go through Synopsys.


// This Examples shows how random 
// Test vectors is generated

// This is base object
class m_base_o {
  rand bit [7:0] addr ;
  rand bit [7:0] data ;
  rand bit       rd_wr;

  constraint c1 {
    addr > 0;
    data > 0;
  }

  task print() {
    printf ("-------------------------\n");
    printf ("Address : %x\n",addr);
    printf ("Data    : %x\n",data);
    printf ("Write   : %x\n",rd_wr);
 }
}

// This is transcation generator
class txgen {
  m_base_o base_ob;
  integer num_cmds;
  integer i,s;

  // Method to generate commands
  task gen_tx () {
     base_ob = new();
    // Generate num_cmds commands
    for ( i = 0; i < num_cmds; i ++) {
      s = base_ob.randomize();
      base_ob.print();
    }
  }
}

// Top level for any vera testbench
program memory {
   txgen tx;
   tx = new();
   tx.num_cmds = 5;
   tx.gen_tx();
}
operon (queryLanguage, appeared 2018)
Origin: Operon Consulting
Country: Finland
Website: https://www.operon.io/

Operon.io is a powerful language to query, transform and integrate JSON-data. You can use it for example to build a small microservice for your backend services. All code is run on the powerful and battle tested Java Virtual Machine (JVM).



From json:true
Function mySum($a, $b):
    $a + $b
End
Select [1 ... 5] => array:Reduce(mySum($a, $b))
OPS5 (pl, appeared 1977)
Stands for: Official Production System version 5
Origin: Carnegie Mellon University
Country: United States


OPS5 is a rule-based or production system computer language, notable as the first such language to be used in a successful expert system, the R1/XCON system used to configure VAX computers. The OPS (said to be short for "Official Production System") family was developed in the late 1970s by Charles Forgy while at Carnegie Mellon University. Allen Newell's research group in artificial intelligence had been working on production systems for some time, but Forgy's implementation, based on his Rete algorithm, was especially efficient, sufficiently so that it was possible to scale up to larger problems involving hundreds or thousands of rules. OPS5 uses a forward chaining inference engine; programs execute by scanning "working memory elements" (which are vaguely object-like, with classes and attributes) looking for matches with the rules in "production memory". Rules have actions that may modify or remove the matched element, create new ones, perform side effects such as output, and so forth. Execution continues until no more matches can be found. In this sense, OPS5 is an execution engine for a Petri net extended with inhibitor arcs. The OPS5 forward chaining process makes it extremely parallelizeable during the matching phase, and several automatic parallelizing compilers were created. OPS4 was an early version, while OPS83 came later. The first implementation of OPS5 was written in Lisp, and later rewritten in BLISS for speed. DEC OPS5 is an extended implementation of the OPS5 language definition, developed for use with the VMS, RISC ULTRIX, and DEC OSF/1 operating systems.


(compute 2 + (3 * 4) + 5)
Optimized Systems Software (pl, appeared 1981)
Origin: Shepardson Microsystems, Inc
Country: United States


Optimized Systems Software (OSS) was a company that produced disk operating systems, programming languages, and applications primarily for the Atari 8-bit family of home computers, but some products were also sold for the Apple II. OSS was best known for their enhanced versions of Atari BASIC and the MAC/65 assembler (both of which are much faster than Atari's products) and the Action! programming language. OSS transitioned to other platforms with Personal Pascal for the Atari ST and Personal Prolog for Macintosh (which was also advertised for the Atari ST, but may not have been released). OSS was not as significant in those markets.
OptimJ (pl, appeared 2006)
Origin: Ateji


OptimJ is an extension of the Java with language support for writing optimization models and abstractions for bulk data processing. The extensions and the proprietary product implementing the extensions were developed by Ateji which went out of business in September 2011. OptimJ aims at providing a clear and concise algebraic notation for optimization modeling, removing compatibility barriers between optimization modeling and application programming tools, and bringing software engineering techniques such as object-orientation and modern IDE support to optimization experts. OptimJ models are directly compatible with Java source code, existing Java libraries such as database access, Excel connection or graphical interfaces. OptimJ is compatible with development tools such as Eclipse, CVS, JUnit or JavaDoc. OptimJ is available free with the following solvers: lp_solve, glpk, LP or MPS file formats and also supports the following commercial solvers: Gurobi, MOSEK, IBM ILOG CPLEX Optimization Studio.
orange (pl, appeared 2014)
Creators: Robert Fratto
Origin: https://github.com/orange-lang
Country: United States
Website: https://web.archive.org/web/20191002000130/http://orange-lang.org/
Keywords: alias
bool
break
catch
char
class
const
continue
data
def
delete
do
double
elif
else
enum
extend
extern
false
final
finally
float
fro
get
if
import
int
int16
int32
int64
int8
interface
new
of
package
private
property
protected
public
return
set
static
string
super
this
throw
true
try
uint
uint16
uint362
uint64
uint8
var
virtual
void
where
while

Orange is a systems programming language made to be as powerful as C++ with none of the headache. It aims to be very productive by baking the most important low- and high-level features directly into the language, instead of dealing with them through obtuse function calls.



extern printf(char* s, ...) -> int32 

class Person
  public char* name

  public Person(char* name)
    @name = name 
  end
end

Person john = Person("Johnny")
printf("Hello, %s!\n", john.name)
Orc (pl, appeared 2004)
Creators: Jayadev Misra
Origin: The University of Texas at Austin
Country: United States
Website: http://orc.csres.utexas.edu/


Orc is a concurrent, nondeterministic computer programming language created by Jayadev Misra at the University of Texas at Austin. Orc  provides uniform access to computational services, including distributed communication and data manipulation, through sites. Using four simple concurrency primitives, the programmer orchestrates the invocation of sites to achieve a goal, while managing timeouts, priorities, and failures.
orca-lang (pl, appeared 2014)
Creators: Karl Robillard
Origin: https://sourceforge.net/p/urlan/mailman/urlan-orca
Country: Unknown
Website: https://sourceforge.net/p/urlan/wiki/OrcaProject/

Orca is a REBOL-like interpreter which can be used under the terms of either the GPL or LGPL. The interpreter is a C library so that C/C++ applications can use Orca as an embedded scripting system.
orca-pl (esolang, appeared 2018)
Origin: https://github.com/hundredrabbits/Orca-c/issues
Country: Unknown
Website: http://wiki.xxiivv.com/orca

Each letter of the alphabet is an operation, lowercase letters typically operate on bang(*), uppercase letters operate on each frame. Bangs can be generated by various operations, such as E colliding with a 0, see the bang.orca example. Watch a music video of ORCΛ in action. C Port for the ORCΛ programming environment, with a commandline interpreter.


GitHub description: Live Programming Environment(C Port)
order (pl, appeared 2003)
Creators: Vesa Karvonen
Origin: https://www.devever.net/~hl
Country: United Kingdom

Metalanguage for C Preprocessor Metaprogramming



#define ORDER_PP_DEF_8fib                       \
ORDER_PP_FN(8fn(8N,                             \
                8fib_iter(8N, 0, 1)))
owen-lang (pl, appeared 2019)
Creators: Paw Møller
Origin: https://github.com/pawwkm/owen/issues
Country: Denmark
Website: http://owen-lang.org



GitHub description: An imperative, statically but weakly typed systems programming  language with manual memory management.

// An imperative, statically but weakly typed systems programming
// language with manual memory management.

namespace Hello.Owen

function main
    output i32
    print("Hello World\n")
    return 0
end
OWL (xmlFormat, appeared 2004)
Stands for: One World Language
Origin: World Wide Web Consortium
Country: United States


The Web Ontology Language (OWL) is a family of knowledge representation languages for authoring ontologies. Ontologies are a formal way to describe taxonomies and classification networks, essentially defining the structure of knowledge for various domains: the nouns representing classes of objects and the verbs representing relations between the objects. Ontologies resemble class hierarchies in object-oriented programming but there are several critical differences. Class hierarchies are meant to represent structures used in source code that evolve fairly slowly (typically monthly revisions) whereas ontologies are meant to represent information on the Internet and are expected to be evolving almost constantly. Similarly, ontologies are typically far more flexible as they are meant to represent information on the Internet coming from all sorts of heterogeneous data sources. Class hierarchies on the other hand are meant to be fairly static and rely on far less diverse and more structured sources of data such as corporate databases. The OWL languages are characterized by formal semantics. They are built upon the World Wide Web Consortium's (W3C) XML standard for objects called the Resource Description Framework (RDF). OWL and RDF have attracted significant academic, medical and commercial interest. In October 2007, a new W3C working group was started to extend OWL with several new features as proposed in the OWL 1.1 member submission. W3C announced the new version of OWL on 27 October 2009. This new version, called OWL 2, soon found its way into semantic editors such as Protégé and semantic reasoners such as Pellet, RacerPro, FaCT++ and HermiT. The OWL family contains many species, serializations, syntaxes and specifications with similar names. OWL and OWL2 are used to refer to the 2004 and 2009 specifications, respectively. Full species names will be used, including specification version (for example, OWL2 EL). When referring more generally, OWL Family will be used.
OX (pl, appeared 1996)
Creators: Jurgen A. Doornik
Origin: OxMetrics Technologies
Country: United Kingdom
Website: http://www.oxmetrics.net/


Ox is an object-oriented matrix programming language with a mathematical and statistical function library, developed by Jurgen Doornik. It has been designed for econometric programming. It is available for Windows, Mac OS X and Linux platforms. The downloadable console version of Ox is free for academic use. A commercial version is available for non-academic use. According to its documentation, it should be cited whenever results are published.The programming environment for econometric modelling OxMetrics is based on Ox.
Oxygene (pl, appeared 2002)
Origin: RemObjects Software
Country: United States
Website: http://elementscompiler.com


Oxygene (formerly known as Chrome) is a programming language developed by RemObjects Software for Microsoft's Common Language Infrastructure, the Java Platform and Cocoa. Oxygene is Object Pascal-based, but also has influences from C#, Eiffel, Java, F# and other languages. Compared to the now deprecated Delphi.NET, Oxygene does not emphasize total backward compatibility, but is designed to be a "reinvention" of the language, be a good citizen on the managed development platforms, and leverage all the features and technologies provided by the .NET and Java runtimes. Oxygene is commercial product, and offers full integration into Microsoft's Visual Studio IDE on Windows, as well as its own IDE, Fire for use on macOS. The command line compiler is available free. Oxygene is one of three languages supported by the underlying Elements Compiler toolchain, next to C# and Swift. From 2008 to 2012, RemObjects Software has licensed its compiler and IDE technology to Embarcadero to be used in their Embarcadero Prism product. Starting in the Fall of 2011, Oxygene became available in two separate editions, with the second edition adding support for the Java and Android runtimes. Starting with the release of XE4, Embarcadero Prism is no longer part of the RAD Studio SKU. Numerous support and upgrade paths for Prism customers exist to migrate to Oxygene. As of 2016, there is only one edition of Oxygene, which allows development on Windows or macOS, and which can create executables for Windows .NET, iOS, Android, Java and macOS.
Oz (pl, appeared 1991)
Creators: Gert Smolka
Origin: Universität des Saarlandes
Country: Germany
Website: http://mozart.github.io


Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Université catholique de Louvain, for programming language education. It has a canonical textbook: Concepts, Techniques, and Models of Computer Programming. Oz was first designed by Gert Smolka and his students in 1991. In 1996, development of Oz continued in cooperation with the research group of Seif Haridi and Peter Van Roy at the Swedish Institute of Computer Science. Since 1999, Oz has been continually developed by an international group, the Mozart Consortium, which originally consisted of Saarland University, the Swedish Institute of Computer Science, and the Université catholique de Louvain. In 2005, the responsibility for managing Mozart development was transferred to a core group, the Mozart Board, with the express purpose of opening Mozart development to a larger community. The Mozart Programming System is the primary implementation of Oz. It is released with an open source license by the Mozart Consortium. Mozart has been ported to different flavors of Unix, FreeBSD, Linux, Windows, and macOS.
P* (pl, appeared 2013)
Also known as: p-star
Creators: Atle Solbakken
Origin: https://github.com/P-star
Country: Norway
Website: https://www.p-star.org/home

P* (pronounced P-star) is a programming language specifically designed for web development. P* provides easy in-language support for common tasks in this field.


GitHub description: Main repository for the P* web programming language.

#!/usr/bin/wpl -f
SCENE main {
    /* Create a variable named 'env' of special type 'ENV' */
    ENV env;
    /* Create a variable named 'path' of type 'string' */
    string path;
    /* Tell the env variable to retrieve the environment
    variable PATH and put the result into our 'path' variable */
    path = env->PATH;
    /* Put the variable 'path' into a text string and then print it out */
    echo "My shell looks for programs in these directories: $path\n";
}
P4 (pl, appeared 2014)
Origin: Barefoot Networks
Intel
Stanford University
Princeton University
Google
Microsoft Research
Country: United States
Website: http://p4.org


P4 is a programming language designed to allow programming of packet forwarding planes. In contrast to a general purpose language such as C or Python, P4 is a domain-specific language with a number of constructs optimized around network data forwarding.  P4 is an open-source, permissively licensed language and is maintained by a non-profit organization called the P4 Language Consortium.  The language was originally described in a SIGCOMM CCR paper in 2014 titled “Programming Protocol-Independent Packet Processors” – the alliterative name shortens to “P4”.