pldb/PLDB huggingface dataset:
Ramis software (pl, appeared 1960)
Origin: Mathtech, Inc
Country: United States


RAMIS (Random Access Management Information System) is a fourth-generation programming language (4GL) capable of creating and maintaining databases consisting of named files containing both numeric and alphabetic fields and subsequently producing detailed simple or complex reports using a very simple English like language.  As such it is easily mastered by non-programmers. A typical program - either to create or maintain a database or to create quite complex reports - would normally consist of a handful of lines of code which could be written or understood by non-professional programmers.  "End users" as they became known. Such end users could be trained to use RAMIS in a matter of days and so large companies would often have several hundred such users scattered throughout the company.
RAPID (pl, appeared 1994)
Origin: ABB Group


RAPID is a high-level programming language used to control ABB industrial robots. RAPID was introduced along with S4 Control System in 1994 by ABB, superseding the ARLA programming language. Features in the language include:  Routine parameters: Procedures - used as a subprogram. Functions - return a value of a specific type and are used as an argument of an instruction. Trap routines - a means of responding to interrupts. Arithmetic and logical expressions Automatic error handling Modular programs Multi tasking
rapidgen-rpl (pl, appeared 1983)
Origin: RapidGen Software Ltd
Country: United Kingdom

RapidGen translates the XML into a concise and transparent format of decision tables for decision logic programming —RPL— a rich, purpose-built language developed by the company. Supports high speed execution of decision models. Is capable of processing large data volumes. Preserves traceability to the original DMN model.



Days_leave <- 22
AGE < 18         Y N N N N ELSE
AGE >= 60        N Y - N N -
SERVICE >= 30    N - Y N N -
SERVICE >= 15    N - - Y N -
AGE >= 45        N - - - Y -
Days_leave + 5   X X X . . .
Days_leave + 2   . . . X X .
Days_leave + 3   . X X . . .
RapidQ (pl, appeared 2000)
Origin: https://groups.io/g/rapidq
Country: Unknown


RapidQ (also known as Rapid-Q) is a free, cross-platform, semi-object-oriented dialect of the BASIC programming language. It can create console, graphical user interface, and Common Gateway Interface applications. The integrated development environment includes a drag-and-drop form designer, syntax highlighting, and single-button compilation. Versions are available for Microsoft Windows, Linux, Solaris, and HP-UX. Additional functionality not normally seen in BASIC languages are function callbacks and primitive object-orientation. The language is called semi-object-oriented by its author because there are only two levels of the class hierarchy: built-in classes, and user-defined classes derived from those; the latter cannot be extended further. The ability to call external shared libraries is available, thus giving full access to the underlying operating system's application program interface. Other capabilities include built-in interfaces to DirectX and MySQL. RapidQ features a bytecode compiler that produces standalone executables by binding the generated bytecode with the interpreter. No external run time libraries are needed; the bytecode interpreter is self-contained. The file sizes of executable files created by RapidQ are about 150 kilobytes or larger for console applications. RapidQ's author, William Yu, sold the source code to REAL Software, the makers of REALbasic, in 2000.The freely distributed program has been improved and many additional components have been created by an active user group.
Rapira (pl, appeared 1987)
Creators: Andrey Ershov
Country: Russia
Website: http://freeduke33.github.io/rerap2


Rapira is also a name for the T-12 antitank gun. Rapira (Russian: Рапира, rapier) is an educational procedural programming language developed in the Soviet Union and implemented on Agat computer, PDP-11 clones (Electronika, DVK, BK series) and Intel-8080/Z80 clones (Korvet). It was an interpreted language with dynamic type system and high level constructions. The language originally had a Russian-based set of keywords, but English and Moldovan were added later. Also, it was more elegant and easier to use than existing Pascal implementations of the time. Rapira was used in teaching computer programming in Soviet schools. The programming environment included a text editor and an integrated debugger. Sample program:  ПРОЦ СТАРТ()     ВЫВОД: 'Привет, мир!!!' КОН ПРОЦ  The same, but using the English lexics [sic, from the article referenced below]:  proc start()      output: 'Hello, world!!!'; end proc  Rapira's ideology was based on such languages as POP-2 and SETL, with strong influences from ALGOL.

GitHub description: ReRap2 is an interpreter for the Russian and English dialects of the Rapira programming language.
Rascal (grammarLanguage, appeared 2013)
Origin: https://github.com/usethesource
Country: The Netherlands
Website: https://www.rascal-mpl.org/

Rascal solves this problem by integrating source code analysis, transformation, and generation primitives on the language level. Use it for any kind of metaprogramming task: to construct parsers for programming languages, to analyze and transform source code, or to define new DSLs with full IDE support. Rascal is a programming language; such that meta programs can be created by, understood by, and debugged by programmers.

Rascal is an experimental domain specific language for metaprogramming, such as static code analysis, program transformation and implementation of domain specific languages. It is a general meta language in the sense that it does not have a bias for any particular software language. It includes primitives from relational calculus and term rewriting. Its syntax and semantics are based on procedural (imperative) and functional programming.

GitHub description: The implementation of the Rascal meta-programming language (including interpreter, type checker, parser generator, compiler and JVM based run-time system)
RascalMPL (pl, appeared 2010)
Origin: Centrum Wiskunde & Informatica
Country: The Netherlands
Website: http://www.rascal-mpl.org


Rascal is an experimental domain specific language for metaprogramming, such as static code analysis, program transformation and implementation of domain specific languages. It is a general meta language in the sense that it does not have a bias for any particular software language. It includes primitives from relational calculus and term rewriting. Its syntax and semantics are based on procedural (imperative) and functional programming.
rason (pl, appeared 2015)
Origin: Frontline Systems Inc
Country: United States
Website: https://www.rason.com/




{
    data :
    {
        "price" : { value: 200 },
        "capacity" : { value: 100 },
        "sold" : { value: 110 },
        "refund_no_shows" : { value: 0.5 },
        "refund_overbook" : { value: 1.25 }
    },
    uncertainVariables : 
    {
        "no_shows" : { formula: "PsiLogNormal(0.1*sold, 0.06*sold)" }
    },
    formulas :
    {
        "show_ups" : { formula: "sold - Round(no_shows, 0)" },
        "overbook" : { formula: "Max(0, show_ups - capacity)" }
    },
    uncertainFunctions :
    {
        "revenue" : { formula: "price*(sold - refund_no_shows * Round(no_shows, 0) - refund_overbook * overbook)",
        mean : [], stdev: [], max : [], min : [] }
    }
}
RASP (pl, appeared 1988)
Origin: University of Belgrade
Country: Yugoslavia


A rasp is a tool used for shaping wood or other material. Rasp or RASP may also refer to:  Ranger Assessment and Selection Program, the United States Army Rangers selection and training RASP computing model, random-access stored-program machine The Rasp, a book by Philip MacDonald Residents Against SARP Pollution Runtime application self-protection
Ratfiv (pl, appeared 1980)
Origin: Institute for Cancer Research
Country: United States


Ratfiv is an enhanced version of the Ratfor programming language, a preprocessor for Fortran designed to give it C-like capabilities. Fortran was widely used for scientific programming but had very basic control-flow primitives ("do" and "goto") and no "macro" facility which limited its expressiveness. The name of the language is a pun (Ratfor (RATional FORtran) -> "Rat Four" -> "Rat Five" -> RatFiv). Ratfiv was developed by Bill Wood at the Institute for Cancer Research, Philadelphia, PA in the early 1980s and released on several DECUS (Digital Equipment Users Group) SIG (Special Interest Group) tapes.  It is based on the original Ratfor by B. Kernighan and P. J. Plauger, with rewrites and enhancements by David Hanson and friends (U. of Arizona), Joe Sventek and Debbie Scherrer (Lawrence Berkeley National Laboratory). Ratfiv V2.1 was distributed on the DECUS RSX82a SIG tape.
RATFOR (pl, appeared 1976)
Origin: Stanford University
Country: United States
Website: http://sepwww.stanford.edu/doku.php?id=sep:software:ratfor

Ratfor (short for Rational Fortran) is a programming language implemented as a preprocessor for Fortran 66. It provided modern control structures, unavailable in Fortran 66, to replace GOTOs and statement numbers.

Ratfor (short for Rational Fortran) is a programming language implemented as a preprocessor for Fortran 66. It provided modern control structures, unavailable in Fortran 66, to replace GOTOs and statement numbers.
Ravenscar profile (pl, appeared 1997)
Origin: University of York
Country: United Kingdom


The Ravenscar profile is a subset of the Ada tasking features designed for safety-critical hard real-time computing. It was defined by a separate technical report in Ada 95; it is now part of the Ada 2012 Standard. It has been named after the English village of Ravenscar, the location of the 8th International Real-Time Ada Workshop (IRTAW 8).
rbasic (pl, appeared 1985)
Creators: Mike Welch
Origin: Diversified Data Design
Country: United States

RBASIC was an in-house language, written by Mike Welch of Hemet, California, in 1985, for Diversified Data Design (DDD), currently in Culver City, California, for use at DDD's customer Medi-Sec, formerly of Santa Monica, CA. DDD was run by Horace Clark at the time, Medi-Sec was run by Neal Green. RBASIC was a dialect of BASIC with an included relational database.
rbs (headerLang, appeared 2020)
Origin: Square Capital, LLC
Country: United States
File extensions: rbs

We defined a new language called RBS for type signatures for Ruby 3. The signatures are written in .rbs files which is different from Ruby code. You can consider the .rbs files are similar to .d.ts files in TypeScript or .h files in C/C++/ObjC. The benefit of having different files is it doesn't require changing Ruby code to start type checking. You can opt-in type checking safely without changing any part of your workflow.



# sig/merchant.rbs

class Merchant
  attr_reader token: String
  attr_reader name: String
  attr_reader employees: Array[Employee]

  def initialize(token: String, name: String) -> void

  def each_employee: () { (Employee) -> void } -> void
                   | () -> Enumerator[Employee, void]
end
Rc (pl, appeared 1989)
Creators: Tom Duff
Origin: Bell Labs
Country: United States


rc (for "run commands") is the command line interpreter for Version 10 Unix and Plan 9 from Bell Labs operating systems. It resembles the Bourne shell, but its syntax is somewhat simpler. It was created by Tom Duff, who is better known for an unusual C programming language construct ("Duff's device"). A port of the original rc to Unix is part of Plan 9 from User Space.  A rewrite of rc for Unix-like operating systems by Byron Rakitzis is also available but includes some incompatible changes. Rc uses C-like control structures instead of ALGOL-like, as the original Bourne shell, except that it uses an if not construct instead of else and has a Bourne-like for loop to iterate over lists. In rc all variables are lists of strings, which eliminates the need for constructs like "$@".
RDF Schema (grammarLanguage, appeared 1998)
Origin: World Wide Web Consortium
Country: United States


RDF Schema (Resource Description Framework Schema, variously abbreviated as RDFS, RDF(S), RDF-S, or RDF/S) is a set of classes with certain properties using the RDF extensible knowledge representation data model, providing basic elements for the description of ontologies, otherwise called RDF vocabularies, intended to structure RDF resources. These resources can be saved in a triplestore to reach them with the query language SPARQL. The first version was published by the World-Wide Web Consortium (W3C) in April 1998, and the final W3C recommendation was released in February 2004. Many RDFS components are included in the more expressive Web Ontology Language (OWL).


@prefix rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
@prefix ex:   <http://example.org/> .
@prefix zoo:   <http://example.org/zoo/> .
ex:dog1     rdf:type     ex:animal .
ex:cat1     rdf:type     ex:cat .
ex:cat    rdfs:subClassOf  ex:animal .
zoo:host   rdfs:range      ex:animal .
ex:zoo1     zoo:host     ex:cat2 .
RDF (dataNotation, appeared 1997)
Stands for: Resource Description Framework
Origin: World Wide Web Consortium
Country: United States
Website: https://www.w3.org/RDF/


The Resource Description Framework (RDF) is a family of World Wide Web Consortium (W3C) specifications originally designed as a metadata data model. It has come to be used as a general method for conceptual description or modeling of information that is implemented in web resources, using a variety of syntax notations and data serialization formats. It is also used in knowledge management applications. RDF was adopted as a W3C recommendation in 1999. The RDF 1.0 specification was published in 2004, the RDF 1.1 specification in 2014.
RDFa (xmlFormat, appeared 2004)
Origin: World Wide Web Consortium
Country: United States
Website: http://rdfa.info/


RDFa (or Resource Description Framework in Attributes) is  a W3C Recommendation that adds a set of attribute-level extensions to HTML, XHTML and various XML-based document types for embedding rich metadata within Web documents. The RDF data-model mapping enables its use for embedding RDF subject-predicate-object expressions within XHTML documents. It also enables the extraction of RDF model triples by compliant user agents. The RDFa community runs a wiki website to host tools, examples, and tutorials.


<div xmlns:dc="http://purl.org/dc/elements/1.1/"
  about="http://www.example.com/books/wikinomics">
  <span property="dc:title">Wikinomics</span>
  <span property="dc:creator">Don Tapscott</span>
  <span property="dc:date">2006-10-01</span>
</div>
RDoc (textMarkup, appeared 2004)
Origin: https://github.com/ruby
Country: Japan
Website: https://ruby.github.io/rdoc/


RDoc, designed by Dave Thomas, is an embedded documentation generator for the Ruby programming language. It analyzes Ruby source code, generating a structured collection of pages for Ruby objects and methods. Code comments can be added in a natural style. RDoc is included as part of the Ruby core distribution. The RDoc software and format are successors to the Ruby Document format (with associated software RD). RDoc can produce usable documentation even if the target source code does not contain explicit comments as it will still parse the classes, modules, and methods, and list them in the generated API files. RDoc also provides the engine for creating Ruby ri data files, providing access to API information from the command line. RDoc and ri are currently maintained by Eric Hodel and Ryan Davis.
Real-time Cmix (pl, appeared 1992)
Origin: Princeton University
Columbia University
University of Virginia
Country: United States


Real-Time Cmix (RTcmix) is one of the MUSIC-N family of computer music programming languages.  RTcmix is descended from the MIX program developed by Paul Lansky at Princeton University in 1978 to perform algorithmic composition using digital audio soundfiles on a IBM 3031 mainframe computer.  After synthesis functions were added, the program was renamed Cmix in the 1980s.  Real-time capability was added by Brad Garton and David Topper in the mid-1990s, with support for TCP socket connectivity,  interactive control of the scheduler, and object-oriented embedding of the synthesis engine into fully featured applications. Over the years Cmix/RTcmix has run on a variety of computer platforms and operating systems, including NeXT, Sun Microsystems, IRIX, Linux, and Mac OS X.  It is and has always been an open source project, differentiating it from commercial synthesizers and music software.  It is currently developed by a group of computer music researchers at Princeton, Columbia University, and the University of Virginia. RTcmix has a number of unique (or highly unusual) features when compared with other synthesis and signal processing languages.  For one, it has a built-in MINC parser, which enables the user to write C-style code within the score file, extending its innate capability for algorithmic composition and making it closer in some respects to later music software such as SuperCollider and Max/MSP.  It uses a single-script instruction file (the score file), and synthesis and signal processing routines (called instruments) exist as compile  shared libraries.  This is different from MUSIC-N languages such as  Csound where the instruments exist in a second file written in a specification language that builds the routines out of simple building blocks (organized as opcodes or unit generators).  RTcmix has similar functionality to Csound and other computer music languages, however, and their shared lineage means that scripts written for one language will be extremely familiar-looking (if not immediately comprehensible) to users of the other language.
Reason (pl, appeared 2016)
Also known as: reasonml
Origin: Facebook
Website: https://reasonml.github.io/
Keywords: as
assert
begin
class
constraint
do
done
downto
else
end
exception
external
false
for
fun
esfun
function
functor
if
in
include
inherit
initializer
lazy
let
switch
module
pub
mutable
new
nonrec
object
of
open
pri
rec
sig
struct
then
to
true
try
type
val
virtual
when
while
with



GitHub description: Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems

type schoolPerson = Teacher | Director | Student(string);

let greeting = person =>
  switch (person) {
  | Teacher => "Hey Professor!"
  | Director => "Hello Director."
  | Student("Richard") => "Still here Ricky?"
  | Student(anyOtherName) => "Hey, " ++ anyOtherName ++ "."
  };
Rebeca Modeling Language (pl, appeared 2004)
Creators: Marjan Sirjani
Origin: Sharif University of Technology
Country: Iran
Website: https://rebeca-lang.org


Rebeca (acronym for Reactive Objects Language) is an actor-based modeling language with a formal foundation, designed in an effort to bridge the gap between formal verification approaches and real applications. It can be considered as a reference model for concurrent computation, based on an operational interpretation of the actor model. It is also a platform for developing object-based concurrent systems in practice. Besides having an appropriate and efficient way for modeling concurrent and distributed systems, one needs a formal verification approach to ensure their correctness. Rebeca is supported by a set of verification tools. Earlier tools provided a front-end to work with Rebeca code, and to translate the Rebeca code into input languages of well-known and mature model checkers (like SPIN and NuSMV) and thus, were able to verify their properties. Rebeca, since 2005, is supported by a direct model checker based on Modere (the Model checking Engine of Rebeca). Modular verification and abstraction techniques are used to reduce the state space and make it possible to verify complicated reactive systems. Besides these techniques, Modere supports partial order reduction and symmetry reduction.
REBOL (pl, appeared 1997)
Stands for: Relative Expression-Based Object Language
Creators: Carl Sassenrath
Origin: REBOL Technologies
Website: http://www.rebol.com
File extensions: r
reb


Rebol ( REB-əl; historically REBOL) is a cross-platform data exchange language and a multi-paradigm dynamic programming language designed by Carl Sassenrath for network communications and distributed computing. It introduces the concept of dialecting: small, optimized, domain-specific languages for code and data, which is also the most notable property of the language according to its designer Carl Sassenrath:  Although it can be used for programming, writing functions, and performing processes, its greatest strength is the ability to easily create domain-specific languages or dialects  Douglas Crockford, known for his involvement in the development of JavaScript, has described Rebol as "a more modern language, but with some very similar ideas to Lisp, in that it's all built upon a representation of data which is then executable as programs" and as one of JSON's influences. Originally, the language and its official implementation were proprietary and closed source, developed by REBOL Technologies. Following discussion with Lawrence Rosen, the Rebol version 3 interpreter was released under the Apache 2.0 license on December 12, 2012. Older versions are only available in binary form, and no source release for them is planned. Rebol has been used to program Internet applications (both client- and server-side), database applications, utilities, and multimedia applications.
REC Studio (decompiler, appeared 2010)
Website: https://www.backerstreet.com/rec/rec.htm

REC Studio is an interactive decompiler. It reads a Windows, Linux, Mac OS X or raw executable file, and attempts to produce a C-like representation of the code and data used to build the executable file. It has been designed to read files produced for many different targets, and it has been compiled on several host systems.
Recfiles (dataNotation, appeared 1994)
Creators: Jose E. Marchesi
Origin: Free Software Foundation
Country: United States
File extensions: rec

GNU recutils is a set of tools and libraries to access human-editable, text-based databases called recfiles. The data is stored as a sequence of records, each record containing an arbitrary number of named fields. Advanced capabilities usually found in other data storage systems are supported: data types, data integrity (keys, mandatory fields, etc.) as well as the ability of records to refer to other records (sort of foreign keys). Despite its simplicity, recfiles can be used to store medium-sized databases.

recfiles is a file format for human-editable, plain text databases. Databases using this file format can be edited using any text editor. recfiles allow for basic relational database operations, typing, auto-incrementing, as well as a simple join operation. Recutils is a collection of tools, like recfmt, recsel, and rec2csv used to work with recfile databases. Various software libraries support the format.


%rec: Book
%mandatory: Title
%type: Location enum loaned home unknown
%doc:
+ A book in my personal collection.

Title: GNU Emacs Manual
Author: Richard M. Stallman
Publisher: FSF
Location: home

Title: The Colour of Magic
Author: Terry Pratchett
Location: loaned

Title: Mio Cid
Author: Anonymous
Location: home

Title: chapters.gnu.org administration guide
Author: Nacho Gonzalez
Author: Jose E. Marchesi
Location: unknown

Title: Yeelong User Manual
Location: home