pldb/PLDB huggingface dataset:
NWScript (pl, appeared 2004)
Origin: BioWare


NWScript is the scripting language developed by BioWare for the role-playing video game Neverwinter Nights. It is based on the C programming language and is implemented in the Aurora toolset. Neverscript, an open source 3rd party editor, has been created for the Mac OS X and Linux versions of NWN because the Aurora toolset has not been ported to those platforms. NWScript is also used in the video games The Witcher, Star Wars: Knights of the Old Republic and Star Wars: Knights of the Old Republic II The Sith Lords, which use the Odyssey Engine. Neverwinter Nights 2, the sequel to the original NWN, features a modified version of this scripting language.
Not eXactly C (pl, appeared 2006)
Origin: https://sourceforge.net/p/bricxcc/_list/tickets
Country: United States


Not eXactly C, or NXC, is a high-level programming language for the Lego Mindstorms NXT designed by John Hansen in 2006. NXC, which is short for Not eXactly C, is based on Next Byte Codes, an assembly language. NXC has a syntax like C. The IDE for NXC is the Bricx Command Center. The NXC compiler is available under the Mozilla Public License. A sample code is as shown below:
NXT-G (pl, appeared 2006)
Origin: The Lego Group
Country: Denmark


LEGO Mindstorms NXT is a programmable robotics kit released by Lego in late July 2006. It replaced the first-generation Lego Mindstorms kit, which was called the Robotics Invention System. The base kit ships in two versions: the Retail Version (set #8527) and the Education Base Set (set #9797). It comes with the NXT-G programming software, or optionally LabVIEW for Lego Mindstorms. A variety of unofficial languages exist, such as NXC, NBC, leJOS NXJ, and RobotC. The second generation of the set, the Lego Mindstorms NXT 2.0, was released on August 1, 2009, featuring a color sensor and other upgraded capabilities. The third generation, the EV3, was released in September 2013.
nydp (pl, appeared 2014)
Origin: https://github.com/conanite/nydp/issues
Country: United States



GitHub description: nydp - a modern, more dangerous kind of lisp

(def pre-compile (expr)
  (map pre-compile
    (if (mac-names (car expr))
        (pre-compile (mac-expand (car expr) (cdr expr)))
        expr)))
(mac yoyo (thing) `(do-yoyo ,thing))
Nymph (pl, appeared 2017)
Creators: Brandon Barber
Origin: https://github.com/maelswarm/nymph/issues
Country: United States
File extensions: n



GitHub description: 🧚 A slightly different version of C.

#include <stdio.h>
#include <stdlib.h>

class Mammal {

    + int population = 0;             // Class Variable (+)
    - int height = 0, weight = 100;   // Object Variable (-)

    + Mammal *init(int height, int weight) {  // Class Method (+) Constructor
        this->height = height;
        this->weight = weight;
        Mammal->population++;
        return this;
    }

    - void print() {                          // Object Method (-)
        printf("print instance properties...\n");
    }
}
O-Matrix (pl, appeared 1994)
Origin: Harmonic Software Inc
Country: United States

O-Matrix is a matrix programming language for mathematics, engineering, science, and financial analysis, marketed by Harmonic Software. The language is designed for use in high-performance computing.

O-Matrix is a matrix programming language for mathematics, engineering, science, and financial analysis, marketed by Harmonic Software.   The language is designed for use in high-performance computing. O-Matrix provides an integrated development environment  and a matrix-based scripting language. The environment includes mathematical, statistical, engineering and visualization functions. The set of analysis functions is designed for development of complex, computationally intensive scientific, mathematical and engineering applications. The integrated environment provides a mode that is largely compatible with version 4 of the MATLAB language in the commercial product from MathWorks. Certain features of MATLAB, such as non-numeric data types (structures, cell arrays and objects), error handling with try/catch, and nested and anonymous functions, are missing in O-Matrix. The O-Matrix environment includes a virtual machine of the O-Matrix language to enable re-distribution of applications.
o:XML (pl, appeared 2002)
Origin: https://web.archive.org/web/20190210195527/http://www.pingdynasty.com/
Country: United Kingdom


o:XML is an open source, dynamically typed, general-purpose object-oriented programming language based on XML-syntax.  It has threads, exception handling, regular expressions and namespaces.  Additionally o:XML has an expression language very similar to XPath that allows functions to be invoked on nodes and node sets.
o42a (pl, appeared 2010)
Creators: Ruslan Lopatin
Country: Russia
Website: http://o42a.org/

o42a is a high-level general purpose programming language. It is: compiled, statically-typed, prototype-based, logic-driven, and primarily declarative, while the imperative programming style is also supported. A program written in o42a is closer to natural English text than one written in any C-like programming language. The language is designed with programming productivity and code maintainability as main priorities. This achieved by powerful, yet restrained, semantics, and expressive and natural syntax.



Use namespace 'Console'
@Main (
  Print "Hello, World!" nl
)
oasis-operating-system (os, appeared 1977)
Origin: Phase One Systems
Country: United States

The OASIS operating system was originally developed and distributed in 1977 by Phase One Systems of Oakland, California (President Howard Sidorsky). OASIS was developed for the Z80 processor and was the first multi-user operating system for 8-bit microprocessor based computers (Z-80 from Zilog). "OASIS" was a backronym for "Online Application System Interactive Software".
Oberon-2 (pl, appeared 1991)
Creators: Niklaus Wirth
Hanspeter Mössenböck
Origin: Eidgenössische Technische Hochschule Zürich
Country: Switzerland


Oberon-2 is an extension of the original Oberon programming language that adds limited reflection and object-oriented programming facilities, open arrays as pointer base types, read-only field export and reintroduces the FOR loop from Modula-2. It was developed in 1991 at ETH Zurich by Niklaus Wirth and Hanspeter Mössenböck, who is now at Institut für Systemsoftware (SSW) of the University of Linz, Austria.  Oberon-2 is a superset of Oberon, and is fully compatible with it.  Oberon-2 was a redesign of Object Oberon. Oberon-2 inherited limited reflection and single inheritance ("type extension") without interfaces or mixins from Oberon, but added efficient virtual methods ("type bound procedures"). Method calls were resolved at run-time using C++-style virtual method tables. Compared to fully object-oriented programming languages like Smalltalk, in Oberon-2 basic types are not objects, classes are not objects, many operations are not methods, there is no message passing (to a certain extent it can be emulated by reflection and through message extension, as demonstrated in ETH Oberon), and polymorphism is limited to subclasses of a common class (no duck typing like in  Python, and it's not possible to define interfaces like in Java). Oberon-2 does not support encapsulation at object/class level, but modules can be used for this purpose. Reflection in Oberon-2 does not use meta-objects, but simply reads from type descriptors compiled into the executable binaries, and exposed in the modules that define the types and/or procedures.  If the format of these structures are exposed at the language level (as is the case for ETH Oberon, for example), reflection could be implemented at the library level.  It could therefore be implemented almost entirely at library level, without changing the language code.  Indeed, ETH Oberon makes use of language-level and library-level reflection capabilities extensively. Oberon-2 provides built-in run-time support for garbage collection similar to Java and performs bounds and array index checks, etc. that eliminate the potential stack and array bounds overwriting problems and manual memory management issues inherent in C/C++.  Separate compilation using symbol files and name-spaces via the module architecture ensure quick rebuilds since only modules with changed interfaces need to be recompiled. The language Component Pascal  is a refinement (a superset) of Oberon-2.
Oberon (pl, appeared 1986)
Creators: Niklaus Wirth
Origin: Eidgenössische Technische Hochschule Zürich
Country: Switzerland
Website: http://www.projectoberon.com/


Oberon is a general-purpose programming language created in 1986 by Niklaus Wirth and the latest member of the Wirthian family of ALGOL-like languages (Euler, Algol-W, Pascal, Modula, and Modula-2). Oberon was the result of a concentrated effort to increase the power of Modula-2, the direct successor of Pascal, and simultaneously to reduce its complexity. Its principal new feature is the concept of type extension of record types: It permits the construction of new data types on the basis of existing ones and to relate them, deviating from the dogma of strictly static data typing. Type extension is Wirth's way of inheritance reflecting the viewpoint of the parent site. Oberon was developed as part of the implementation of the Oberon operating system at ETH Zurich in Switzerland. The name is from the moon of Uranus, Oberon. Oberon is still maintained by Wirth and the latest revision is dated May 3, 2016.
OBJ (pl, appeared 1976)
Origin: University of California, Los Angeles
Country: United States


OBJ is a programming language family introduced by Joseph Goguen in 1976. It is a family of declarative "ultra high-level" languages. It features abstract types, generic modules, subsorts (subtypes with multiple inheritance), pattern-matching modulo equations, E-strategies (user control over laziness), module expressions (for combining modules), theories and views (for describing module interfaces) for the massively parallel RRM (rewrite rule machine). Members of the OBJ family of languages include CafeOBJ, Eqlog, FOOPS, Kumo, Maude and OBJ3.
ObjDump (application, appeared 1991)
Origin: Cygnus Solutions
Country: United States


objdump is a program for displaying various information about object files on Unix-like systems. For instance, it can be used as a disassembler to view an executable in assembly form. It is part of the GNU Binutils for fine-grained control over executables and other binary data. For example,  $ objdump -D -M intel file.bin | grep main.: -A20  This performs disassembly on the file «file.bin», with the assembly code shown in Intel syntax. We then redirect it to grep, which searches the main function and displays 20 lines of its code. Example output:  objdump uses the BFD library to read the contents of object files.  Similar utilities are Borland TDUMP, Microsoft DUMPBIN and readelf.
OQL (queryLanguage, appeared 1986)
Also known as: OQL
Origin: http://www.odbms.org/odmg-standard
Country: United States


Object Query Language (OQL) is a query language standard for object-oriented databases modeled after SQL.  OQL was developed by the Object Data Management Group (ODMG). Because of its overall complexity nobody has ever fully implemented the complete OQL. OQL has influenced the design of some of the newer query languages like JDOQL and EJB QL, but they can't be considered as different flavors of OQL.


select c.address
from Persons p, p.children c
where p.address.street = "Main Street" and count(p.children) >= 2 and c.address.city != p.address.city
Object Rexx (pl, appeared 1988)
Creators: Simon C. Nash
Origin: IBM
Country: United States
Website: http://www.oorexx.org
File extensions: rxs
rex


The Object REXX programming language is an object-oriented scripting language initially produced by IBM for OS/2. It is a follow-on to and a significant extension of the "Classic Rexx" language originally created for the CMS component of VM/SP and later ported to MVS, OS/2 and PC DOS. OS/2 version of IBM Object REXX is deeply integrated with SOM. On October 12, 2004, IBM released Object REXX as open source software, giving rise to Open Object Rexx (ooREXX), now available for various operating systems: Linux, Solaris, Windows. This implementation includes a WSH Scripting Engine for Rexx. The released sources however didn't include significant piece of the SOM support. Object REXX supports multiple inheritance via the use of mixin classes.
Object-Z (pl, appeared 1991)
Origin: University of Queensland
Country: Australia


Object-Z is an object-oriented extension to the Z notation developed at the University of Queensland, Australia. Object-Z extends Z by the addition of language constructs resembling the object-oriented paradigm, most notably, classes. Other object-oriented notions such as polymorphism and inheritance are also supported. While not as popular as its base language Z, Object-Z has still received significant attention in the formal methods community, and research on aspects of the language are ongoing, including hybrid languages using Object-Z, tool support (e.g., through the Community Z Tools project) and refinement calculi.
Objective-C (pl, appeared 1984)
Also known as: objectivec
Creators: Brad Cox
Origin: Apple
Country: United States
Website: https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html
File extensions: h
m
mm
C
Keywords: auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
inline
int
long
register
restrict
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
_Bool
_Complex
_Imaginary
BOOL
Class
bycopy
byref
id
IMP
in
inout
nil
NO
NULL
oneway
out
Protocol
SEL
self
Super
YES
@
@interface
@end
@implementation
@protocol
@class
@public
@protected
@private
@property
@try
@throw
@catch()
@finally
@synthesize
@dynamic
@selector
atomic
nonatomic
retain


Objective-C is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. It was the main programming language used by Apple for the OS X and iOS operating systems, and their respective application programming interfaces (APIs) Cocoa and Cocoa Touch prior to the introduction of Swift. The programming language Objective-C was originally developed in the early 1980s. It was selected as the main language used by NeXT for its NeXTSTEP operating system, from which OS X and iOS are derived. Portable Objective-C programs that do not use the Cocoa or Cocoa Touch libraries, or those using parts that may be ported or reimplemented for other systems, can also be compiled for any system supported by GNU Compiler Collection (GCC) or Clang. Objective-C source code 'implementation' program files usually have .m filename extensions, while Objective-C 'header/interface' files have .h extensions, the same as C header files. Objective-C++ files are denoted with a .mm file extension.
Objective-J (pl, appeared 2008)
Origin: https://github.com/cappuccino
Country: United States and United Kingdom and Sweden
Website: http://www.cappuccino-project.org/


Objective-J is a programming language developed as part of the Cappuccino web development framework. Its syntax is nearly identical to the Objective-C syntax and it shares with JavaScript the same relationship that Objective-C has with the C programming language: that of being a strict, but small, superset; adding traditional inheritance and Smalltalk/Objective-C style dynamic dispatch. Pure JavaScript, being a prototype-based language, already has a notion of object orientation and inheritance, but Objective-J adds the use of class-based programming to JavaScript. Programs written in Objective-J need to be preprocessed before being run by a web browser's JavaScript virtual machine. This step can occur in the web browser at runtime or by a compiler which translates Objective-J programs into pure JavaScript code.  The Objective-J compiler is written in JavaScript; consequently, deploying Objective-J programs does not require a web browser plug-in. Objective-J can be compiled and run on Node.js.
Objective-S (pl, appeared 1980)
Origin: https://github.com/mpw/Objective-Smalltalk/issues
Country: Germany
Website: https://objective.st/




-<void>deleteFile:filename {
   thumbs := self thumbsView subviews.
   viewsToRemove := thumbs selectWhereValueForKey:'filename' isEqual:filename.
   aView := viewsToRemove firstObject.

   UIView animateWithDuration:0.4
          animations: { aView setAlpha: 0.0. }
          completion: { aView removeFromSuperview. 
                        UIView animateWithDuration: 0.2
                               animations: { self thumbsView layoutSubviews. }
                               completion: { 3 }. 
                      }.
   url := self urlForFile:aFilename.
   NSFileManager defaultManager removeItemAtURL:url  error:nil.
   self thumbsView afterDelay:0.4 | setNeedsLayout.
}
ObjectPAL (pl, appeared 1993)
Origin: Corel Corporation
Country: United States


ObjectPAL is short for Object-Oriented Paradox Application Language, which is the programming language used by the Borland Paradox database application (now owned by Corel).  Paradox, now in its 11th version, is a constituent of Corel's Word Perfect X3 office suite, for 32-bit Microsoft Windows.  The language is tightly-bound to the application's forms, and provides a very rapid and robust development environment for creating database applications for Windows.  ObjectPAL is not a full free-standing object-oriented language. It belongs to the family of languages inspired by Hypercard, with influences from PAL (wherever functionality could be kept the same), Smalltalk, and Garnet (a UI language created by Brad Myers).  While its objects do encapsulate source code, there is no support for polymorphism, and only a very limited inheritance concept, which is wedded to objects on a form which can be controlled by code placed on a higher object in a form's object hierarchy.  However, for what it is, ObjectPAL provides a wideranging and versatile language for creating Paradox applications.  The syntax and structure of the language resembles Visual Basic, but knowing Visual Basic would only help someone new to ObjectPAL in the sense that any other programming skill would be transferable to ObjectPAL.  ObjectPAL was the successor to PAL, which was the Paradox for DOS programming language.  With the advent of Paradox for Windows 1.0 in 1993, which was then owned by Borland Corporation, ObjectPAL was born. Version 1.0 was quickly succeeded by version 4.5 that same year. It can be used as such as a web server scripting language when combined with the Corel Web Server Control OCX, which implements a server API similar to the  CGI, and its standalone console, the Corel Web Server.
ObjectScript (pl, appeared 2012)
Creators: unitpoint
Origin: https://github.com/unitpoint/objectscript/issues
Country: Russia
Website: http://objectscript.org



GitHub description: ObjectScript, OS for short, is a new programming language. It's free, cross-platform, lightweight, embeddable and open-source. It combines the benefits of multiple languages, including: JavaScript, Lua, Ruby, Python and PHP. OS features the syntax of Javascripts, the "multiple results" feature from lua, syntactic shugar from Ruby as well as magic methods from PHP and Ruby - and even more!
Obliq (pl, appeared 1993)
Origin: DEC


Obliq is an interpreted, object-oriented programming language designed to make distributed, and locally multi-threaded, computation simple and easy for the programmer, while providing program safety and implicit type system. The interpreter is written in Modula-3, and provides Obliq with full access to Modula-3's network objects capabilities. A type inference algorithm for record concatenation, subtyping and recursive types has been developed for Obliq, more important it has been proved to be NP-complete  and its lowest complexity to be Ο(n3) or if under other modeling up to certain conditions down to Ο(n2)  and its best known implementation runs in Ο(n5). Obliq's syntax is very similar to Modula-3, the biggest difference being that Obliq has no need of explicit typed variables (i.e., a variable can hold any data type allowed by the type checker and if does not accepts one, i.e., a given expression execution error will be thrown) although explicit type declarations are allowed and ignored by the interpreter. The basic data types in the language include booleans, integers, reals, characters, strings, and arrays. Obliq supports the usual set of sequential control structures (conditional, iteration, and exception handling forms), as well as special control forms for concurrency (mutexes and guarded statements). Besides that Obliq's objects are able to be cloned and safely copied remotely by any machine in a distributed network object and it can be done in a transparent way. Obliq's large standard library provides strong support for mathematical operations, I/O, persistence, thread control, graphics, and animation. Distributed computation is object-based: objects hold a state, which is local to a particular process. Scope of objects and other variables is purely lexical. Objects can call methods of other objects, even if those objects are on another machine on the network. Obliq objects are simply collections of named fields (similar to slots in Self and Smalltalk), and support inheritance by delegation (like Self). The common uses of Obliq involve programming over networks, 3D animation, and distributed computation over Ethernet LAN as. Obliq is included free with the DEC Modula-3 distribution, but other free versions exist elsewhere including pre-compiled binaries for several operating systems.
Observable (pl, appeared 2017)
Creators: Mike Bostock
Origin: Observable
Website: https://observablehq.com/

A partially open source derivative of Javascript modified for dataflow that powers the Observable data science web app.


GitHub description: The Observable dataflow runtime.

{
 let x = 0;
 for (let i = 1; i <= 100; ++i) {
   x += i;
 }
 return x;
}
OCaml (pl, appeared 1996)
Creators: Xavier Leroy
Origin: Institut national de recherche en sciences et technologies du numérique
Country: France
Website: http://ocaml.org
File extensions: ml
mli
Keywords: as
assert
begin
class
constraint
do
done
downto
else
end
exception
external
false
for
fun
function
functor
if
in
include
inherit
initializer
lazy
let
match
method
module
mutable
new
object
of
open
private
raise
rec
sig
struct
then
to
true
try
type
value
val
virtual
when
while
with


OCaml ( oh-KAM-əl), originally named Objective Caml, is the main implementation of the programming language Caml, created by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez and others in 1996. A member of the ML language family, OCaml extends the core Caml language with object-oriented programming constructs. OCaml's toolset includes an interactive top-level interpreter, a bytecode compiler, a reversible debugger, a package manager (OPAM), and an optimizing native code compiler. It has a large standard library, making it useful for many of the same applications as Python or Perl, and has robust modular and object-oriented programming constructs that make it applicable for large-scale software engineering. OCaml is the successor to Caml Light. The acronym CAML originally stood for Categorical Abstract Machine Language, although OCaml omits this abstract machine. OCaml is a free and open-source software project managed and principally maintained by French Institute for Research in Computer Science and Automation (INRIA). In the early 2000s, many new languages adopted elements from OCaml, most notably F# and Scala.