pldb/PLDB huggingface dataset:
Occam π (pl, appeared 2005)
Origin: University of Kent
Country: United Kingdom

occam-pi is a concurrent programming language using the process-oriented programming model, which aims to make it straightforward to write correct, expressive concurrent programs. occam-pi is supported on a variety of platforms by a collection of open source tools, and is used and maintained by a community of developers around the world.

In computer science, occam-π (or occam-pi) is the name of a variant of the programming language occam developed by the Kent Retargetable occam Compiler (KRoC) team at the University of Kent. The name reflects the introduction of elements of π-calculus (pi-calculus) into occam, especially concepts involving mobile agents (processes) and data. The language contains several extensions to occam 2.1, including:  Nested protocols Run-time process creation Mobile channels, data, and processes Recursion Protocol inheritance Array constructors Extended rendezvous
Occam (pl, appeared 1983)
Creators: David May
Origin: Inmos International plc
Country: United Kingdom


occam is a concurrent programming language that builds on the communicating sequential processes (CSP) process algebra, and shares many of its features. It is named after William of Ockham of Occam's Razor fame. occam is an imperative procedural language (such as Pascal). It was developed by David May and others at INMOS, advised by Tony Hoare, as the native programming language for their transputer microprocessors, but implementations for other platforms are available. The most widely known version is occam 2; its programming manual was written by Steven Ericsson-Zenith and others at INMOS.
OCL (pl, appeared 1997)
Origin: IBM
Country: United States

The Object Constraint Language (OCL) is a textual sublanguage of the Unified Modelling Language (UML). It can be used to express additional constraints on UML models that cannot be expressed, or are very difficult to express, with the graphical means provided by UML. OCL is based on first-order predicate logic but it uses a syntax similar to programming languages and closely related to the syntax of UML. It is, thus, more adequate for every-day modelling than pure first-order predicate logic.

The Object Constraint Language (OCL) is a declarative language describing rules applying to Unified Modeling Language (UML) models developed at IBM and is now part of the UML standard. Initially, OCL was merely a formal specification language extension for UML. OCL may now be used with any Meta-Object Facility (MOF) Object Management Group (OMG) meta-model, including UML. The Object Constraint Language is a precise text language that provides constraint and object query expressions on any MOF model or meta-model that cannot otherwise be expressed by diagrammatic notation. OCL is a key component of the new OMG standard recommendation for transforming models, the Queries/Views/Transformations (QVT) specification.


context Person inv: self.age >=0
context Person inv: self.age<18 implies self.cars->isEmpty()
GNU Octave (pl, appeared 1988)
Origin: University of Wisconsin-Madison
University of Texas
Country: United States
Website: https://gnu.org/software/octave/


GNU Octave is software featuring a high-level programming language, primarily intended for numerical computations. Octave helps in solving linear and nonlinear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with Matlab. It may also be used as a batch-oriented language. Since it is part of the GNU Project, it is free software under the terms of the GNU General Public License. Octave is one of the major free alternatives to Matlab, others being Scilab and FreeMat. Scilab, however, puts less emphasis on (bidirectional) syntactic compatibility with Matlab than Octave does.
Open Data Protcol (protocol, appeared 2007)
Origin: Microsoft
Country: United States
Website: https://www.odata.org/


In computing, Open Data Protocol (OData) is an open  protocol which allows the creation and consumption of queryable and interoperable RESTful  APIs in a simple and standard way. Microsoft initiated OData in 2007. Versions 1.0, 2.0, and 3.0 are released under the Microsoft Open Specification Promise. Version 4.0 was standardized at OASIS, with a release in March 2014. In April 2015 OASIS submitted OData v4 and OData JSON Format v4 to ISO/IEC JTC 1 for approval as an international standard.The protocol enables the creation and consumption of  REST APIs, which allow  Web clients to publish and edit resources, identified using URLs and defined in a data model, using simple HTTP messages. OData shares some similarities with JDBC and with ODBC; like ODBC, OData is not limited to relational databases.


{
  "@odata.context": "http://services.odata.org/V4/OData/OData.svc/$metadata#Products",
  "value": [
    {
      "ID": 0,
      "Name": "Meat",
      "Description": "Red Meat",
      "ReleaseDate": "1992-01-01T00:00:00Z",
      "DiscontinuedDate": null,
      "Rating": 14,
      "Price": 2.5
    },
    {
      "ID": 1,
      "Name": "Milk",
      "Description": "Low fat milk",
      "ReleaseDate": "1995-10-01T00:00:00Z",
      "DiscontinuedDate": null,
      "Rating": 3,
      "Price": 3.5
    }
  ]
}
Open Database Connectivity (protocol, appeared 1990)
Origin: Microsoft
Simba Technologies Inc
Country: United States and Canada


In computing, Open Database Connectivity (ODBC) is a standard application programming interface (API) for accessing database management systems (DBMS). The designers of ODBC aimed to make it independent of database systems and operating systems. An application written using ODBC can be ported to other platforms, both on the client and server side, with few changes to the data access code. ODBC accomplishes DBMS independence by using an ODBC driver as a translation layer between the application and the DBMS. The application uses ODBC functions through an ODBC driver manager with which it is linked, and the driver passes the query to the DBMS. An ODBC driver can be thought of as analogous to a printer driver or other driver, providing a standard set of functions for the application to use, and implementing DBMS-specific functionality. An application that can use ODBC is referred to as "ODBC-compliant". Any ODBC-compliant application can access any DBMS for which a driver is installed.  Drivers exist for all major DBMSs, many other data sources like address book systems and Microsoft Excel, and even for text or comma-separated values (CSV) files. ODBC was originally developed by Microsoft and Simba Technologies during the early 1990s, and became the basis for the Call Level Interface (CLI) standardized by SQL Access Group in the Unix and mainframe field. ODBC retained several features that were removed as part of the CLI effort. Full ODBC was later ported back to those platforms, and became a de facto standard considerably better known than CLI. The CLI remains similar to ODBC, and applications can be ported from one platform to the other with few changes.
odin (pl, appeared 2016)
Origin: https://github.com/odin-lang
Country: The Netherlands and Denmark and Sweden and United States and Germany
Website: https://odin-lang.org



GitHub description: Odin Programming Language

package main

import "core:fmt"

main :: proc() {
 program := "+ + * 😃 - /";
 accumulator := 0;

 for token in program {
   switch token {
   case '+': accumulator += 1;
   case '-': accumulator -= 1;
   case '*': accumulator *= 2;
   case '/': accumulator /= 2;
   case '😃': accumulator *= accumulator;
   case: // Ignore everything else
   }
 }

 fmt.printf("The program \"%s\" calculates the value %d\n",
            program, accumulator);
}
OEM (schema, appeared 1995)
Stands for: Object Exchange Model
Origin: Stanford University
Country: United States


The Object Exchange Model  (OEM) is a model for exchanging semi-structured data between object-oriented databases. It serves as the basic data model in numerous projects of the Stanford University Database Group, including Tsimmis, Lore, and C3. Slight variations of OEM have evolved across different Stanford projects. In Lore, labels are actually on parent-child "links" rather than objects. For example, if an OEM object has multiple parents, different parent objects may use different labels to identify that object. An atomic value encoding a person's name might be included in one complex object using the label "Author" and in another complex object using the label "Editor." In C3, additional attributes are required for each object to annotate the changes to the object that have occurred over time.


<DB:: Eats { // A Sample Database
<Restaurant {
<Name "Darbar">
<Entree {
<Name str "Masala Dosa"> <_895: Price 8.95>
}>
<Entree {
<Name "Mushroom Bhajee">
<Opinion "This entree is excellent, " #
"though it is a bit spicy">
<&_895>
}>
<"Credit Card" "Visa">
}>
}>
OGNL (pl, appeared 2007)
Origin: OGNL Technology, Inc
Country: United States


Object-Graph Navigation Language (OGNL) is an open-source Expression Language (EL) for Java, which, while using simpler expressions than the full range of those supported by the Java language, allows getting and setting properties (through defined setProperty and getProperty methods, found in JavaBeans), and execution of methods of Java classes. It also allows for simpler array manipulation. It is aimed to be used in Java EE applications with taglibs as expression language. OGNL was created by Luke Blanshard and Drew Davidson of OGNL Technology. OGNL development was continued by OpenSymphony, which closed in 2011. OGNL is developed now as a part of the Apache Commons.
Ohayo (pl, appeared 2017)
Creators: Breck Yunits
Origin: https://github.com/breck7/ohayo/issues
Country: United States
Website: https://ohayo.computer/

Ohayo is a fast and free tool for data science. Ohayo consists of a very high level programming language and a visual web studio for that language. The goal of Ohayo is to enable people to do data science at the speed of voice.


GitHub description: A free, fast, public domain data science studio

web.get ohayo/packages/samples/welcome.md
 parser text
 hidden
 markdown.toHtml
templates.list
challenge.list
OK (pl, appeared 2021)
Creators: Jesse Duffield
Origin: https://github.com/jesseduffield/OK/issues
Country: Australia



GitHub description: Welcome to the future of programming languages: OK?

let divide = fn(a, b) {
  return switch b {
    case 0: [NO!, "cannot divide by zero"];
    default: [a / b, ""];
  };
};

result = divide(5, 0)
switch result[1] {
  case "": puts(result[0])
  default: puts(result[1]) // prints "cannot divide by zero"
}
Object Linking and Embedding (protocol, appeared 1990)
Origin: Microsoft
Country: United States


Object Linking &  Embedding  (OLE) is a proprietary technology developed by Microsoft that allows embedding and linking to documents and other objects. For developers, it brought OLE Control Extension (OCX), a way to develop and use custom thing of users using interface elements. On a technical level, an OLE object is any object that implements the IOleObject interface, possibly along with a wide range of other interfaces, depending on the object's needs.
OMAR (pl, appeared 1999)
Stands for: Object Modelling And Rendering
Origin: University of Wisconsin
Country: United States

Hypercosm produced a specialized programming language called OMAR (Object Modelling And Rendering) suitable for describing 3-D content. Hypercosm made available a web browser plugin for displaying this 3-D content. Unlike many other plugins, the Hypercosm plugin was available for Windows, MacOS, and Linux systems.
omega (pl, appeared 2005)
Creators: Tim Sheard
Origin: Portland State University
Country: United States
Website: http://web.cecs.pdx.edu/~sheard/Omega/index.html

The Ωmega interpreter is styled after the Hugs Haskell Interpreter. The Ωmega syntax is based upon the syntax of Haskell. If you’re unsure of what syntax to use, a best first approximation is to use Haskell syntax. It works most of the time. While clearly descended from Haskell, Ωmega has several important syntactic and semantic differences.



--
-- This code written by James Hook
-- This file should work with Omega version 1.1
-- released May 23, 2005
-- See http://www.cs.pdx.edu/~sheard/Omega/index.html

{-- These are predefined by the compiler
kind Nat = Z | S Nat

data Nat' n
  = Z where n = Z
  | forall m . S (Nat' m) where n = S m
-}


data LE a b
  = LeBase where a = b
  | ex c . LeStep (LE a c) where b = S c

reflLE :: LE a a
reflLE = LeBase

transLE :: (LE a b) -> (LE b c) -> (LE a c)
transLE p LeBase = p
transLE p (LeStep q) = LeStep (transLE p q)

compare :: Nat' a -> Nat' b -> ((LE a b)+(LE b a))
compare Z Z = L LeBase
compare Z (S x) =
  case compare Z x of L w -> L (LeStep w)
compare (S x) Z =
  case compare Z x of L w -> R (LeStep w)
compare (S x) (S y) = mapP g g (compare x y )
  where mapP f g (L x) = L(f x)
        mapP f g (R x) = R(g x)
        g :: LE x y -> LE (S x) (S y)
        g LeBase = LeBase
        g (LeStep x) = LeStep (g x)

data MonoList min max
  = MonoNil (LE min max)
  | forall n a . MonoCons (Nat' n) (LE a n) (LE n max) (MonoList min a)

appMonoList :: MonoList b c -> MonoList a b -> MonoList a c
appMonoList (MonoNil bc) (MonoNil ab) =
      MonoNil (transLE ab bc)
appMonoList (MonoNil bc) (MonoCons n an nb xs) =
      MonoCons n an (transLE nb bc) xs
appMonoList (MonoCons m dm mc ys) xs =
      MonoCons m dm mc (appMonoList ys xs)

singletonMonoList :: Nat' n -> MonoList n n
singletonMonoList n = MonoCons n reflLE reflLE (MonoNil reflLE)

data IntervalList min max
  = ILNil (LE min max)
  | forall x . ILCons (Nat' x) (LE min x) (LE x max) (IntervalList min max)

partition :: Nat' n -> LE a n -> LE n b -> IntervalList a b ->
                     (IntervalList a n, IntervalList n b)
partition x an nb xs = partitionAcc (ILNil an) (ILNil nb) xs
  where partitionAcc ls gs (ILNil ab) = (ls,gs)
        partitionAcc ls gs (ILCons y ay yb ys) =
            case compare y x of
              L yx -> partitionAcc (ILCons y ay yx ls) gs ys
              R xy -> partitionAcc ls (ILCons y xy yb gs) ys

qsort :: IntervalList a b -> MonoList a b
qsort (ILNil ab) = MonoNil ab
qsort (ILCons x ax xb (ILNil ab)) = MonoCons x ax xb (MonoNil reflLE)
qsort (ILCons x ax xb xs) =
     let (less,greater) = partition x ax xb xs
         sortedLess = qsort less
   sortedGreater = qsort greater
     in appMonoList sortedGreater (appMonoList (singletonMonoList x) sortedLess)

--
OMeta (grammarLanguage, appeared 2007)
Origin: Viewpoints Research Institute
Country: United States


OMeta is a specialized object-oriented programming language for pattern matching, developed by Alessandro Warth and Ian Piumarta in 2007 under the Viewpoints Research Institute. The language is based on Parsing Expression Grammars (PEGs) rather than Context-Free Grammars with the intent of providing “a natural and convenient way for programmers to implement tokenizers, parsers, visitors, and tree-transformers”.OMeta's main goal is to allow a broader audience to use techniques generally available only to language programmers, such as parsing. It is also known for its use in quickly creating prototypes, though programs written in OMeta are noted to be generally less efficient than those written in vanilla (base language) implementations, such as JavaScript.OMeta is noted for its use in creating domain-specific languages, and especially for the maintainability of its implementations (Newcome). OMeta, like other meta languages, requires a host language; it was originally created as a COLA implementation.
OMG IDL (idl, appeared 2018)
Stands for: OMG Interface Definition Language
Origin: Object Management Group
Country: United States
Website: https://www.omg.org/spec/IDL/About-IDL/




interface A {
    typedef long L1;
    short opA (in L1 l_1);
};
interface B {
    typedef short L1;
    L1 opB (in long l);
};
interface C: B, A {
    typedef L1 L2; // Error: L1 ambiguous
    typedef A::L1 L3; // A::L1 is OK
    B::L1 opC (in L3 l_3); // All OK no ambiguities
};
Omgrofl (esolang, appeared 2006)
Origin: https://github.com/OlegSmelov/omgrofl-interpreter/issues
Country: Lithuania



GitHub description: Omgrofl interpreter

lol iz 71
wtf lol iz liek 71
    lmao lol
brb
w00t Hello, World!
rofl lol
lol iz 101
rofl lol
lol iz 108
rofl lol
rofl lol
lool iz 111
rofl lool
loool iz 44
rofl loool
loool iz 32
rofl loool
loool iz 87
rofl loool
rofl lool
lool iz 114
rofl lool
rofl lol
lol iz 100
rofl lol
lol iz 33
rofl lol
stfu
Omnis Studio (pl, appeared 1982)


Omnis Studio is a rapid application development (RAD) tool that allows programmers and application developers to create enterprise, web, and mobile applications for Windows, Linux, and macOS personal computers and servers across all business sectors. The Omnis JavaScript Client allows developers to build all types of web applications and mobile applications by presenting a highly functional interface in the user's desktop web browser, or on tablet and mobile devices. The business logic and database access in such web and mobile applications is handled by the Omnis server. The Omnis server also can act as a hub between database servers, services based on Java and .Net and clients like Adobe Air & Flex transferring data in the form of XML or Web services.
OMNITAB 80 (pl, appeared 1980)
Origin: National Institute of Standards and Technology
Country: United States

OMNITAB 80 is a high-level statistical analysis program. OMNITAB, the precursor of Minitab(TM), was developed in the Statistical Engineering Division and is maintained by the Statistical Engineering Division. OMNITAB performs many different statistical analyses including: arithmetic and trigonometric calculations, and matrix and array operations. The software responds to simple instructions and uses reliable computational algorithms.
onex (application, appeared 2014)
Origin: http://cilux.org
Country: United Kingdom
Website: http://object.network/

This is the vision of the "Object Network" and its app and programming system called "Onex". Onex is a mobile app that will enable you to build your own programs and manage your own data, directly on your phone or tablet. It's as easy as spreadsheets, but can scale up over the network.
oopsilon (esolang, appeared 2017)
Origin: https://github.com/Oopsilon
Country: Scotland

<a href='http://github.com/Oopsilon/Oopsilon'>Oopsilon</a> is an object-oriented language in the Kayian tradition which is (perhaps uniquely) founded on a negativist philosophy drawing on critical theory and stressing the importance of hermeneutics in understanding the problems programmers experience.


GitHub description: Main repository - implementation of the dynamic programming environment Oopsilon
Office Open XML (xmlFormat, appeared 2006)
Origin: Microsoft
Country: United States


Office Open XML (also informally known as OOXML or Microsoft Open XML (MOX)) is a zipped, XML-based file format developed by Microsoft for representing spreadsheets, charts, presentations and word processing documents. The format was initially standardized by Ecma (as ECMA-376), and by the ISO and IEC (as ISO/IEC 29500) in later versions. Starting with Microsoft Office 2007, the Office Open XML file formats have become the default target file format of Microsoft Office. Microsoft Office 2010 provides read support for ECMA-376, read/write support for ISO/IEC 29500 Transitional, and read support for ISO/IEC 29500 Strict. Microsoft Office 2013 and Microsoft Office 2016 additionally support both reading and writing of ISO/IEC 29500 Strict.
Opa (pl, appeared 2011)
Origin: https://github.com/MLstate
Country: France
Website: http://opalang.org
Keywords: and
as
begin
case
client
css
database
db
do
else
end
external
forall
function
if
import
match
module
or
package
parser
rec
server
then
type
val
with
xml_parser


Opa is an open-source programming language for developing scalable web applications. It can be used for both client-side and server-side scripting, where complete programs are written in Opa and subsequently compiled to Nodejs on the server and JavaScript on the client, with the compiler automating all communication between the two. Opa implements strong, static typing, which can be helpful in protecting against security issues such as SQL injections and cross-site scripting attacks. The language was first officially presented at the OWASP conference in 2010, and the source code was released on GitHub in June 2011, under a GNU Affero General Public License. Later, the license changed to the MIT license for the framework part (library) and AGPL for the compiler so that applications written in Opa can be released under any license, proprietary or open source.

GitHub description: The Opa Language for Web Application Development
OpenNN (library, appeared 2003)
Origin: https://github.com/Artelnics/opennn
Website: https://www.opennn.net/


OpenNN (Open Neural Networks Library) is a software library written in the C++ programming language which implements neural networks, a main area of deep learning research.

GitHub description: OpenNN is a software library written in C++ for advanced analytics. It implements neural networks, the most successful machine learning method.
Open Shading Language (pl, appeared 2008)
Origin: Sony Pictures Imageworks Inc
Country: Canada
Website: http://openshadinglanguage.com


Open Shading Language (OSL) is a shading language developed by Sony Pictures Imageworks for use in its Arnold Renderer. It is also supported by Otoy's Octane Render, V-Ray 3, and by the Cycles render engine in Blender (starting with Blender 2.65). OSL's surface and volume shaders define how surfaces or volumes scatter light in a way that allows for importance sampling; thus, it is well suited for physically-based renderers that support ray tracing and global illumination.

GitHub description: Advanced shading language for production GI renderers
OpenCL (pl, appeared 2009)
Origin: Khronos Group
Website: https://www.khronos.org/opencl


Open Computing Language (OpenCL) is a framework for writing programs that execute across heterogeneous platforms consisting of central processing units (CPUs), graphics processing units (GPUs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs) and other processors or hardware accelerators. OpenCL specifies programming languages (based on C99 and C++11) for programming these devices and application programming interfaces (APIs) to control the platform and execute programs on the compute devices. OpenCL provides a standard interface for parallel computing using task- and data-based parallelism. OpenCL is an open standard maintained by the non-profit technology consortium Khronos Group. Conformant implementations are available from Altera, AMD, Apple, ARM, Creative, IBM, Imagination, Intel, Nvidia, Qualcomm, Samsung, Vivante, Xilinx, and ZiiLABS.