pldb/PLDB huggingface dataset:
ROOT (library, appeared 1994)
Origin: Conseil européen pour la recherche nucléaire or CERN
Country: Switzerland
Website: https://root.cern.ch/

A modular scientific software toolkit. It provides all the functionalities needed to deal with big data processing, statistical analysis, visualisation and storage. It is mainly written in C++ but integrated with other languages such as Python and R.

ROOT is an object-oriented program and library developed by CERN. It was originally designed for particle physics data analysis and contains several features specific to this field, but it is also used in other applications such as astronomy and data mining.  Release 6.14.04 as of 2018-08-23


#include "Riostream.h"
void basic() {
// read file $ROOTSYS/tutorials/tree/basic.dat
// this file has 3 columns of float data
   TString dir = gROOT->GetTutorialDir();
   dir.Append("/tree/");
   dir.ReplaceAll("/./","/");
   ifstream in;
   in.open(Form("%sbasic.dat",dir.Data()));
   Float_t x,y,z;
   Int_t nlines = 0;
   auto f = TFile::Open("basic.root","RECREATE");
   TH1F h1("h1","x distribution",100,-4,4);
   TNtuple ntuple("ntuple","data from ascii file","x:y:z");
   while (1) {
      in >> x >> y >> z;
      if (!in.good()) break;
      if (nlines < 5) printf("x=%8f, y=%8f, z=%8f\n",x,y,z);
      h1.Fill(x);
      ntuple.Fill(x,y,z);
      nlines++;
   }
   printf(" found %d points\n",nlines);
   in.close();
   f->Write();
}
Rosetta-2 (pl, appeared 2006)
Origin: Apple Inc
Country: United State


Rosetta is a dynamic binary translator developed by Apple Inc. for macOS, an application compatibility layer between different instruction set architectures. It enables a transition to newer hardware, by automatically translating software. The name is a reference to the Rosetta Stone, the artifact which enabled translation of Egyptian hieroglyphs. The first version of Rosetta, introduced in 2006 in Mac OS X Tiger, was part of the Mac transition from PowerPC processors to Intel processors, allowing PowerPC applications to run on Intel-based Macs. The second version, introduced in 2020 as a component of macOS Big Sur, is part of the Mac transition from Intel processors to Apple silicon, allowing Intel applications to run on Apple silicon Macs.


   https://dougallj.files.wordpress.com/2022/11/fupg8ipuuaehi0a-1.jpg
rosette-lang (pl, appeared 2013)
Creators: Emina Torlak
Rastislav Bodik
Origin: University of California, Berkeley
Country: United States
Website: https://emina.github.io/rosette/

Rosette is a solver-aided programming language that extends Racket with language constructs for program synthesis, verification, and more. To verify or synthesize code, Rosette compiles it to logical constraints solved with off-the-shelf SMT solvers. By combining virtualized access to solvers with Racket’s metaprogramming, Rosette makes it easy to develop synthesis and verification tools for new languages.



#lang rosette

(define (interpret formula)
  (match formula
    [`(∧ ,expr ...) (apply && (map interpret expr))]
    [`(∨ ,expr ...) (apply || (map interpret expr))]
    [`(¬ ,expr)     (! (interpret expr))]
    [lit            (constant lit boolean?)]))

; This implements a SAT solver.
(define (SAT formula)
  (solve (assert (interpret formula))))

(SAT `(∧ r o (∨ s e (¬ t)) t (¬ e)))
rosie (queryLanguage, appeared 2015)
Origin: https://gitlab.com/rosie-pattern-language
Country: United States
Website: https://rosie-lang.org

RPL is a variant of modern Regular Expressions (regex) that is designed to scale to big data, many developers, and large collections of patterns.  If you use regex, you already know a lot of RPL.



rosie --rpl 'd = [:digit:]' -o json match d
Roslyn compiler (compiler, appeared 2009)
Origin: https://github.com/dotnet
Country: United States
Website: https://docs.microsoft.com/dotnet/csharp/roslyn-sdk/


.NET Compiler Platform, also known by its nickname Roslyn, is a set of open-source compilers and code analysis APIs for C# and Visual Basic .NET languages from Microsoft.The project notably includes self-hosting versions of the C# and VB.NET compilers – compilers written in the languages themselves. The compilers are available via the traditional command-line programs but also as APIs available natively from within .NET code. Roslyn exposes modules for syntactic (lexical) analysis of code, semantic analysis, dynamic compilation to CIL, and code emission.

GitHub description: The Roslyn .NET compiler provides C# and Visual Basic languages with rich code analysis APIs.
Reactive Plan Language (pl, appeared 1993)
Also known as: rpl
Origin: Yale University
Country: United States

RPL (Reactive Plan Language) belongs to the family of notations for writing reactive plans for agents (e.g., robots) (Davis 1984, Ingrand and George 1990, Lyons 1990a,b, Gat 1991). Its immediate ancestor is Firby's (1987, 1989) RAP notation. Many of Firby's concepts have been carried over, but there are some differences



(DEF-INTERP-PROC LOOK-FOR (PL)
 (LOOK-FOR-PROPS PL)
 (WAIT-FOR VISUAL-INPUT*)
 (SEEN-OB-DESIGS PL) )

 ; Returns a list of desigs (Section 1.7), one for every object seen.
 (DEFFUNC SEEN-OB-DESIGS - (LST desig) (PL - (LST (LRCD symbol obj)))
  (FOR (I IN OB-POSITIONS*)
    (SAVE (CREATE-DESIG "Perceived object"
      ;Desig wil l print like: !:|Perceived object203|
      (CONS (LIST 'LOC I)
       (<# ( (X) (LIST (CAR X) (CADR X)))
        PL))
      ;Design property list
     ))))
RPL (pl, appeared 1984)
Stands for: Reverse Polish Lisp
Origin: Hewlett-Packard


RPL (derived from Reverse Polish Lisp according to its original developers, whilst for a short while in 1987 HP marketing attempted to coin the backronym ROM-based Procedural Language for it) is a handheld calculator operating system and application programming language used on Hewlett-Packard's scientific graphing RPN (Reverse Polish Notation) calculators of the HP 28, 48, 49 and 50 series, but it is also usable on non-RPN calculators, such as the 38, 39 and 40 series. RPL is a structured programming language based on RPN, but equally capable of processing algebraic expressions and formulae, implemented as a threaded interpreter. RPL has many similarities to Forth, both languages being stack-based, as well as the list-based LISP. Contrary to previous HP RPN calculators, which had a fixed four-level stack, the stack used by RPL is only limited by available calculator RAM. RPL originated from HP's Corvallis, Oregon development facility in 1984 as a replacement for the previous practice of implementing the operating systems of calculators in assembly language. The last calculator supporting RPL, the HP 50g, was discontinued in 2015.
Rpm (packageManager, appeared 1997)
Origin: Red Hat, Inc
Country: United States
Website: http://www.rpm.org


RPM Package Manager (RPM) (originally Red Hat Package Manager; now a recursive acronym) is a package management system. The name RPM refers to the following: the .rpm file format, files in the .rpm file format, software packaged in such files, and the package manager program itself. RPM was intended primarily for Linux distributions; the file format is the baseline package format of the Linux Standard Base. Even though it was created for use in Red Hat Linux, RPM is now used in many Linux distributions. It has also been ported to some other operating systems, such as Novell NetWare (as of version 6.5 SP3), IBM's AIX (as of version 4), CentOS, Fedora (operating system) created jointly between Red Hat and the Fedora community, and Oracle Linux. All versions or variants of the these Linux operating systems use the RPM Package Manager. An RPM package can contain an arbitrary set of files. The larger part of RPM files encountered are “binary RPMs” (or BRPMs) containing the compiled version of some software. There are also “source RPMs” (or SRPMs) files containing the source code used to produce a package. These have an appropriate tag in the file header that distinguishes them from normal (B)RPMs, causing them to be extracted to /usr/src on installation. SRPMs customarily carry the file extension “.src.rpm” (.spm on file systems limited to 3 extension characters, e.g. old DOS FAT).
R++ (pl, appeared 1990)
Origin: Bell Labs
Country: United States


R++ is a rule-based programming language based on C++. The United States patent describes R++ as follows:  The R++ extension permits rules to be defined as members of C++ classes. The programming system of the invention takes the classes with rules defined using R++ and generates C++ code from them in which the machinery required for the rules is implemented completely as C++ data members and functions of the classes involved in the rules. R++ was developed by Bell Labs in the 1990s, but due to the Bell System divestiture that split the legal rights to the work developed at the Laboratories between AT&T and Lucent, did not see immediate commercial development while the two companies disputed ownership.
Restricted Python (pl, appeared 2007)
Origin: https://foss.heptapod.net/pypy/pypy/-/issues
Country: Estonia and United States
Website: https://rpython.readthedocs.io/en/latest/rpython.html

RPython is a restricted subset of Python that is amenable to static analysis. RPython is a proper subset of Python, is statically typed, and does not allow dynamic modification of class or method definitions; however, it can still take advantage of Python features such as mixins and first-class methods and classes.
RSS (protocol, appeared 1999)
Also known as: RDF Site Summary
Stands for: Really Simple Syndication
Creators: Dan Libby
Ramanathan V. Guha
Origin: https://www.rssboard.org
Country: Various




<?xml version="1.0" encoding="ISO-8859-1" ?>
<rss version="2.0">
<channel>
 <title></title>
 <link>https://pldb.com/</link>
 <description>PLDB: a Programming Language Database. Build the next great programming language.</description>
 <lastBuildDate>Wed, 22 Feb 2023 13:36:44 +0000</lastBuildDate>
 <language>en-us</language>
 <item>
  <title>A brief interview with Tcl creator John Ousterhout</title>
  <link>https://pldb.com/posts/JohnOusterhout.html</link>
  <pubDate>Wed, 08 Feb 2023 00:00:00 +0000</pubDate>
 </item>
 <item>
  <title>Data entry Livestream</title>
  <link>https://pldb.com/posts/addingDataLivestream.html</link>
  <pubDate>Wed, 08 Feb 2023 00:00:00 +0000</pubDate>
 </item>
</channel>
</rss>
RStudio (editor, appeared 2011)
Origin: RStudio, Inc
Country: United States
Website: https://www.rstudio.com


RStudio is a free and open-source integrated development environment (IDE) for R, a programming language for statistical computing and graphics. RStudio was founded by JJ Allaire, creator of the programming language ColdFusion. Hadley Wickham is the Chief Scientist at RStudio.RStudio is available in two editions: RStudio Desktop, where the program is run locally as a regular desktop application; and RStudio Server, which allows accessing RStudio using a web browser while it is running on a remote Linux server. Prepackaged distributions of RStudio Desktop are available for Windows, macOS, and Linux. RStudio is available in open source and commercial editions and runs on the desktop (Windows, macOS, and Linux) or in a browser connected to RStudio Server or RStudio Server Pro (Debian, Ubuntu, Red Hat Linux, CentOS, openSUSE and SLES).RStudio is partly written in the C++ programming language and uses the Qt framework for its graphical user interface. The bigger percentage of the code is written in Java, JavaScript is also amongst the languages used.Work on RStudio started around December 2010, and the first public beta version (v0.92) was officially announced in February 2011. Version 1.0 was released on 1 November 2016. Version 1.1 was released on 9 October 2017. In April 2018 it was announced RStudio will be providing operational and infrastructure support for Ursa Labs. Ursa Labs will focus on building a new data science runtime powered by Apache Arrow.
RTL/2 (pl, appeared 1972)
Creators: John Barnes
Origin: Imperial Chemical Industries plc
Country: United Kingdom


RTL/2 was a high-level programming language developed at Imperial Chemical Industries Ltd by J.G.P. Barnes. It was originally used internally within ICI but was distributed by SPL International in 1974 It was designed for use in real-time computing (hence the initials RTL = real-time language). Based on concepts from Algol 68, it was intended to be a small, simple language. RTL/2 was standardised in 1980 by the British Standards Institution.RTL/2 was a strongly typed language with separate compilation. The compilation units contained one or more items known as "bricks", i.e.:  procedure bricks, data bricks, stack bricks.A procedure brick was a procedure, which may or may not return a (scalar) value, have (scalar) parameters, or have local (scalar) variables. The entry mechanism and implementation of local variables was re-entrant. Non-scalar data could only be accessed via reference (so-called REF variables were considered scalar). A data brick was a named static collection of scalars, arrays and records. Programmers had to implement memory management themselves (there was no heap or garbage collection). A stack brick was an area of storage reserved for running all the procedures of a single process and contained the call stack, local variables and other housekeeping items. The extent to which stack bricks were actually used varied depending upon the host environment in which RTL/2 programs actually ran. Access to the host environment of an RTL/2 program was provided via special procedure and data bricks called SVC procedures and SVC data. These were accessible in RTL/2 but implemented in some other language in the host environment.
Real-time Transport Protocol (protocol, appeared 1996)
Origin: Audio-Video Transport Working Group of the Internet Engineering Task Force
Country: United States


The Real-time Transport Protocol (RTP) is a network protocol for delivering audio and video over IP networks. RTP is used in communication and entertainment systems that involve streaming media, such as telephony, video teleconference applications including WebRTC, television services and web-based push-to-talk features. RTP typically runs over User Datagram Protocol (UDP).   RTP is used in conjunction with the RTP Control Protocol (RTCP). While RTP carries the media streams (e.g., audio and video), RTCP is used to monitor transmission statistics and quality of service (QoS) and aids synchronization of multiple streams. RTP is one of the technical foundations of Voice over IP and in this context is often used in conjunction with a signaling protocol such as the Session Initiation Protocol (SIP) which establishes connections across the network. RTP was developed by the Audio-Video Transport Working Group of the Internet Engineering Task Force (IETF) and first published in 1996 as RFC 1889, superseded by RFC 3550 in 2003.
Ruby Document format (textMarkup, appeared 1995)
Origin: https://ml.ruby-lang.org/mailman3/hyperkitty/list/ruby-talk@ml.ruby-lang.org
Country: Various


RD (Ruby Document) is a lightweight markup language for writing Ruby-related documents. It can be embedded in Ruby source code. RD is a traditional format. In modern Ruby, developers tend to write documents in RDoc instead of RD.
Ruby (pl, appeared 1995)
Creators: Yukihiro Matsumoto
Origin: https://ml.ruby-lang.org/mailman3/hyperkitty/list/ruby-talk@ml.ruby-lang.org/
Country: Japan
Website: https://www.ruby-lang.org
File extensions: rb
Keywords: __ENCODING__
__FILE__
__LINE__
alias
and
BEGIN
begin
break
case
class
def
defined
do
else
elsif
END
end
ensure
false
for
if
in
module
next
nil
not
or
redo
rescue
retry
return
self
super
then
true
undef
unless
until
when
while
yield


Ruby is a dynamic, reflective, object-oriented, general-purpose programming language. It was designed and developed in the mid-1990s by Yukihiro "Matz" Matsumoto in Japan. According to its creator, Ruby was influenced by Perl, Smalltalk, Eiffel, Ada, and Lisp. It supports multiple programming paradigms, including functional, object-oriented, and imperative. It also has a dynamic type system and automatic memory management.

GitHub description: The Ruby Programming Language
RubyGems (packageManager, appeared 2018)
Creators: Nick Quaranto
Origin: https://github.com/rubygems
Country: United States
Website: https://rubygems.org


RubyGems is a package manager for the Ruby programming language that provides a standard format for distributing Ruby programs and libraries (in a self-contained format called a "gem"), a tool designed to easily manage the installation of gems, and a server for distributing them. It was created by Chad Fowler and Richard Kilmer during RubyConf 2004.The interface for RubyGems is a command-line tool called gem which can install and manage libraries (the gems). RubyGems integrates with Ruby run-time loader to help find and load installed gems from standardized library folders. Though it is possible to use a private RubyGems repository, the public repository is most commonly used for gem management. The public repository helps users find gems, resolve dependencies and install them. RubyGems is bundled with the standard Ruby package as of Ruby 1.9.
RuleML (pl, appeared 2002)
Creators: Harold Boley
Benjamin Grosof
Said Tabet
Origin: RuleML Inc
Country: United States and Canada


RuleML is a global initiative, led by a non-profit organization RuleML Inc., that is devoted to advancing research and industry standards design activities in the technical area of rules that are semantic and highly inter-operable. The standards design takes the form primarily of a markup language, also known as RuleML. The research activities include an annual research conference, the RuleML Symposium, also known as RuleML for short. Founded in fall 2000 by Harold Boley, Benjamin Grosof, and Said Tabet, RuleML was originally devoted purely to standards design, but then quickly branched out into the related activities of coordinating research and organizing an annual research conference starting in 2002. The M in RuleML is sometimes interpreted as standing for Markup and Modeling. The markup language was developed to express both forward (bottom-up) and backward (top-down) rules in XML for deduction, rewriting, and further inferential-transformational tasks. It is defined by the Rule Markup Initiative, an open network of individuals and groups from both industry and academia that was formed to develop a canonical Web language for rules using XML markup and transformations from and to other rule standards/systems. Markup standards and initiatives related to RuleML include:  Rule Interchange Format (RIF): The design and overall purpose of W3C's Rule Interchange Format (RIF) industry standard is based primarily on the RuleML industry standards design. Like RuleML, RIF embraces a multiplicity of potentially useful rule dialects that nevertheless share common characteristics. RuleML Technical Committee from Oasis-Open: An industry standards effort devoted to legal automation utilizing RuleML. Semantic Web Rule Language (SWRL): An industry standards design, based primarily on an early version of RuleML, whose development was funded in part by the DARPA Agent Markup Language (DAML) research program. Semantic Web Services Framework], particularly its Semantic Web Services Language: An industry standards design, based primarily on a medium-mature version of RuleML, whose development was funded in part by the DARPA Agent Markup Language (DAML) research program and the WSMO research effort of the EU. Mathematical Markup Language (MathML): However, MathML's Content Markup is better suited for defining functions rather than relations or general rules Predictive Model Markup Language (PMML): With this XML-based language one can define and share various models for data-mining results, including association rules Attribute Grammars in XML (AG-markup): For AG's semantic rules, there are various possible XML markups that are similar to Horn-rule markup Extensible Stylesheet Language Transformations (XSLT): This is a restricted term-rewriting system of rules, written in XML, for transforming XML documents into other text documents
runic (template, appeared 2017)
Origin: https://github.com/XXIIVV
Country: Unknown
Website: https://wiki.xxiivv.com/#runic

Runic is a first order templating language operating on arrays of strings.



* Header
& Paragraph
- List Element 1
- List Element 2
| table | row1
| table | row2
# -- CODE BLOCK
> -- HTML BLOCK
λ -- LAIN BLOCK
Rust HIR (ir, appeared 2015)
Stands for: Rust High-level Intermediate Representation
Origin: https://github.com/rust-lang/rfcs/issues
Country: Various




#[prelude_import]
use ::std::prelude::rust_2015::*;
#[macro_use]
extern crate std;
fn main() { let mut vec = Vec::new(); vec.push(1); vec.push(2); }
Rust MIR (ir, appeared 2016)
Stands for: Rust Mid-level Intermediate Representation
Origin: https://github.com/rust-lang
Country: Various
Website: https://www.rust-lang.org




// WARNING: This output format is intended for human consumers only
// and is subject to change without notice. Knock yourself out.
fn main() -> () {
    let mut _0: ();                      // return place in scope 0 at src/main.rs:1:11: 1:11
    let mut _1: std::vec::Vec<i32>;      // in scope 0 at src/main.rs:2:9: 2:16
    let _2: ();                          // in scope 0 at src/main.rs:3:5: 3:16
    let mut _3: &mut std::vec::Vec<i32>; // in scope 0 at src/main.rs:3:5: 3:16
    let _4: ();                          // in scope 0 at src/main.rs:4:5: 4:16
    let mut _5: &mut std::vec::Vec<i32>; // in scope 0 at src/main.rs:4:5: 4:16
    scope 1 {
        debug vec => _1;                 // in scope 1 at src/main.rs:2:9: 2:16
    }

    bb0: {
        _1 = Vec::<i32>::new() -> bb1;   // scope 0 at src/main.rs:2:19: 2:29
                                         // mir::Constant
                                         // + span: src/main.rs:2:19: 2:27
                                         // + user_ty: UserType(0)
                                         // + literal: Const { ty: fn() -> Vec<i32> {Vec::<i32>::new}, val: Value(Scalar(<ZST>)) }
    }

    bb1: {
        _3 = &mut _1;                    // scope 1 at src/main.rs:3:5: 3:16
        _2 = Vec::<i32>::push(move _3, const 1_i32) -> [return: bb2, unwind: bb5]; // scope 1 at src/main.rs:3:5: 3:16
                                         // mir::Constant
                                         // + span: src/main.rs:3:9: 3:13
                                         // + literal: Const { ty: for<'r> fn(&'r mut Vec<i32>, i32) {Vec::<i32>::push}, val: Value( Scalar(<ZST>)) }
    }

    bb2: {
        _5 = &mut _1;                    // scope 1 at src/main.rs:4:5: 4:16
        _4 = Vec::<i32>::push(move _5, const 2_i32) -> [return: bb3, unwind: bb5]; // scope 1 at src/main.rs:4:5: 4:16
                                         // mir::Constant
                                         // + span: src/main.rs:4:9: 4:13
                                         // + literal: Const { ty: for<'r> fn(&'r mut Vec<i32>, i32) {Vec::<i32>::push}, val: Value( Scalar(<ZST>)) }
    }

    bb3: {
        drop(_1) -> bb4;                 // scope 0 at src/main.rs:5:1: 5:2
    }

    bb4: {
        return;                          // scope 0 at src/main.rs:5:2: 5:2
    }

    bb5 (cleanup): {
        drop(_1) -> bb6;                 // scope 0 at src/main.rs:5:1: 5:2
    }

    bb6 (cleanup): {
        resume;                          // scope 0 at src/main.rs:1:1: 5:2
    }
}