pldb/PLDB huggingface dataset:
SQL-92 (pl, appeared 1992)


SQL-92 was the third revision of the SQL database query language. Unlike SQL-89, it was a major revision of the standard.  Aside from a few minor incompatibilities, the SQL-89 standard is forward-compatible with SQL-92. The standard specification itself grew about five times compared to SQL-89. Much of it was due to more precise specifications of existing features; the increase due to new features was only by a factor of 1.5–2. Many of the new features had already been implemented by vendors before the new standard was adopted. However, most of the new features were added to the "intermediate" and "full" tiers of the specification, meaning that conformance with SQL-92 entry level was scarcely any more demanding than conformance with SQL-89. Later revisions of the standard include SQL:1999 (SQL3), SQL:2003, SQL:2008, SQL:2011 and SQL:2016.
SQL/PSM (pl, appeared 1996)


SQL/PSM (SQL/Persistent Stored Modules) is an ISO standard mainly defining an extension of SQL with a procedural language for use in stored procedures. Initially published in 1996 as an extension of SQL-92 (ISO/IEC 9075-4:1996, a version sometimes called PSM-96 or even SQL-92/PSM), SQL/PSM was later incorporated into the multi-part SQL:1999 standard, and has been part 4 of that standard since then, most recently in SQL:2016.  The SQL:1999 part 4 covered less than the original PSM-96 because the SQL statements for defining, managing, and invoking routines were actually incorporated into part 2 SQL/Foundation, leaving only the procedural language itself as SQL/PSM. The SQL/PSM facilities are still optional as far as the SQL standard is concerned; most of them are grouped in Features P001-P008. SQL/PSM standardizes syntax and semantics for control flow, exception handling (called "condition handling" in SQL/PSM), local variables, assignment of expressions to variables and parameters, and (procedural) use of cursors. It also defines an information schema (metadata) for stored procedures.  SQL/PSM is one language in which methods for the SQL:1999 structured types can be defined.  The other is Java, via SQL/JRT. IBM's SQL PL (used in DB2) and Mimer SQL's PSM were the first two products implementing SQL/PSM. In practice those two, and perhaps also MySQL/MariaDB's procedural language, are closest to the SQL/PSM standard. SQL/PSM resembles and is inspired by PL/SQL, as well as PL/pgSQL, so they are similar languages.  With PostgreSQL v9 some SQL/PSM features, like overloading of SQL-invoked functions and procedures are now supported.  A PostgreSQL addon implements SQL/PSM (alongside its own procedural language), although it is not part of the core product.RDF functionality in OpenLink Virtuoso was developed entirely through SQL/PSM, combined with custom datatypes (e.g., ANY for handling URI and Literal relation objects), sophisticated indexing, and flexible physical storage choices (column-wise or row-wise).
SQLite (queryLanguage, appeared 2000)
Creators: Dwayne Richard Hipp
Website: https://sqlite.org
Keywords: ABORT
ACTION
ADD
AFTER
ALL
ALTER
ANALYZE
AND
AS
ASC
ATTACH
AUTOINCREMENT
BEFORE
BEGIN
BETWEEN
BY
CASCADE
CASE
CAST
CHECK
COLLATE
COLUMN
COMMIT
CONFLICT
CONSTRAINT
CREATE
CROSS
CURRENT_DATE
CURRENT_TIME
CURRENT_TIMESTAMP
DATABASE
DEFAULT
DEFERRABLE
DEFERRED
DELETE
DESC
DETACH
DISTINCT
DROP
EACH
ELSE
END
ESCAPE
EXCEPT
EXCLUSIVE
EXISTS
EXPLAIN
FAIL
FOR
FOREIGN
FROM
FULL
GLOB
GROUP
HAVING
IF
IGNORE
IMMEDIATE
IN
INDEX
INDEXED
INITIALLY
INNER
INSERT
INSTEAD
INTERSECT
INTO
IS
ISNULL
JOIN
KEY
LEFT
LIKE
LIMIT
MATCH
NATURAL
NO
NOT
NOTNULL
NULL
OF
OFFSET
ON
OR
ORDER
OUTER
PLAN
PRAGMA
PRIMARY
QUERY
RAISE
RECURSIVE
REFERENCES
REGEXP
REINDEX
RELEASE
RENAME
REPLACE
RESTRICT
RIGHT
ROLLBACK
ROW
SAVEPOINT
SELECT
SET
TABLE
TEMP
TEMPORARY
THEN
TO
TRANSACTION
TRIGGER
UNION
UNIQUE
UPDATE
USING
VACUUM
VALUES
VIEW
VIRTUAL
WHEN
WHERE
WITH
WITHOUT


SQLite ( or ) is a relational database management system contained in a C programming library. In contrast to many other database management systems, SQLite is not a client–server database engine. Rather, it is embedded into the end program. SQLite is ACID-compliant and implements most of the SQL standard, using a dynamically and weakly typed SQL syntax that does not guarantee the domain integrity. SQLite is a popular choice as embedded database software for local/client storage in application software such as web browsers. It is arguably the most widely deployed database engine, as it is used today by several widespread browsers, operating systems, and embedded systems (such as mobile phones), among others. SQLite has bindings to many programming languages.
SQLPL (pl, appeared 2009)


SQL PL stands for Structured Query Language Procedural Language and was developed by IBM as a set of commands that extend the use of SQL in the IBM DB2 (DB2 UDB Version 7) database system. It provides procedural programmability in addition to the querying commands of SQL. It is a subset of the SQL Persistent Stored Modules (SQL/PSM) language standard. As of DB2 version 9, SQL PL stored procedures can run natively inside the DB2 process (inside the DBM1 address space, more precisely) instead of being fenced in an external process. In DB2 version 9.7 IBM also added a PL/SQL front-end to this infrastructure (called "SQL Unified Runtime Engine"), meaning that procedural SQL using either the ISO standard or Oracle's syntax compile to bytecode running on the same engine in DB2.
SQRL (queryLanguage, appeared 2018)
Stands for: Smyte Query and Rules Language
Creators: Josh Yudaken
Pete Hunt
Julian Tempelsman
Paul Mou
Yunjing Xu
David Newman
Origin: Smyte
Website: https://sqrl-lang.github.io/sqrl/

SQRL was the language designed by Smyte, and later acquired by Twitter in 2018. It is a safe, stateful language for event streams, designed to make it easy to enforce anti-abuse rules.


GitHub description: A safe, stateful rules language for event streams

LET Username := input();
LET Message := concat("Hello, ", Username, "!");
EOF
Squeak (pl, appeared 1996)
Website: http://www.squeak.org


The Squeak programming language is a dialect of Smalltalk. It is object-oriented, class-based, and reflective. It was derived directly from Smalltalk-80 by a group at Apple Computer that included some of the original Smalltalk-80 developers. Its development was continued by the same group at Walt Disney Imagineering, where it was intended for use in internal Disney projects. Later on the group moved on to be supported by HP labs, SAP Labs and most recently Y Combinator. Squeak is cross-platform. Programs produced on one platform run bit-identical on all other platforms, and versions are available for many platforms including the obvious Windows/macOS/linux versions. The Squeak system includes code for generating a new version of the virtual machine (VM) on which it runs. It also includes a VM simulator written in Squeak. For these reasons, it is easily ported.
Squirrel (pl, appeared 2003)
Creators: Alberto Demichelis
Website: http://squirrel-lang.org/
File extensions: nut


Squirrel is a high level imperative, object-oriented programming language, designed to be a light-weight scripting language that fits in the size, memory bandwidth, and real-time requirements of applications like video games and hardware such as Electric Imp. MirthKit, a simple toolkit for making and distributing open source, cross-platform 2D games, uses Squirrel for its platform. It is used extensively by Code::Blocks for scripting and was also used in Final Fantasy Crystal Chronicles: My Life as a King. It is also used in Left 4 Dead 2, Portal 2 and Thimbleweed Park for scripted events.

GitHub description: Official repository for the programming language Squirrel
SR (pl, appeared 1988)


SR (short for Synchronizing Resources) is a programming language designed for concurrent programming. Resources encapsulate processes and the variables they share, and can be separately compiled. Operations provide the primary mechanism for process interaction. SR provides a novel integration of the mechanisms for invoking and servicing operations. Consequently, it supports local and remote procedure call, rendezvous, message passing, dynamic process creation, multicast, semaphores and shared memory. Version 2.2 has been ported to the Apollo, DECstation, Data General AViiON, HP 9000 Series 300, Multimax, NeXT, PA-RISC, RS/6000, Sequent Symmetry, SGI IRIS, Sun-3, Sun-4 and others.
SRL (queryLanguage, appeared 2016)
Stands for: Simple Regex Language
Creators: Karim Geiger
Website: https://simple-regex.com/



GitHub description: Simple Regex Language

begin with any of (digit, letter, one of "._%+-") once or more,
literally "@",
any of (digit, letter, one of ".-") once or more,
literally ".",
letter at least 2 times,
must end, case insensitive
srv (idl, appeared 2010)
Website: http://wiki.ros.org/srv
File extensions: srv




#request constants
int8 FOO=1
int8 BAR=2
#request fields
int8 foobar
another_pkg/AnotherMessage msg
---
#response constants
uint32 SECRET=123456
#response fields
another_pkg/YetAnotherMessage val
CustomMessageDefinedInThisPackage value
uint32 an_integer
Script.NET (pl, appeared 2007)
Also known as: Script.NET
Website: http://www.protsyk.com/scriptdotnet/

S# is a weakly-typed dynamic language and runtime infrastructure to make your applications extendable, customizable and highly flexible.

Script.NET or S# is a metaprogramming language that provides scripting functionality in Microsoft .NET applications, allowing runtime execution of custom functionality, similar to VBA in Microsoft Office applications. The syntax of Script.NET is similar to JavaScript. It is designed to be simple and efficient scripting language allowing to customize .NET applications. The language has a true runtime interpreter, and it is executed without generating additional in-memory assemblies. Script.NET is an open-source project.

GitHub description: S# is a weakly-typed dynamic language and runtime infrastructure to make your applications extendable, customizable and highly flexible. It allows introducing expressions and large code blocks evaluation within your applications in the similar way Microsoft Office deals with VBScript, gives you possibilities providing rich formula evaluation capabilities like it can be seen in MS Excel and other office applications.
SSI (template, appeared 2004)
Stands for: Server Side Includes


Server Side Includes (SSI) is a simple interpreted server-side scripting language used almost exclusively for the Web. Code is processed by web servers. The most frequent use of SSI is to include the contents of one or more files into a web page on a web server. For example, a web page containing a daily quotation could include the quotation by placing the following code into the file of the web page:  With one change of the quote.txt file, all pages that include the file will display the latest daily quotation. The inclusion is not limited to files, and may also be the text output from a program, or the value of a system variable such as the current time. Server Side Includes are useful for including a common piece of code throughout a site, such as a page header, a page footer and a navigation menu. Conditional navigation menus can be conditionally included using control directives. In order for a web server to recognize an SSI-enabled HTML file and therefore carry out these instructions, either the filename should end with a special extension, by default .shtml, .stm, .shtm, or, if the server is configured to allow this, set the execution bit of the file.As a simple programming language, SSI supports only one type: text. Its control flow is rather simple, choice is supported, but loops are not natively supported and can only be done by recursion using include or using HTTP redirect. The simple design of the language makes it easier to learn and use than most server-side scripting languages, while complicated server-side processing is often done with one of the more feature-rich programming languages. SSI is Turing complete.Apache, LiteSpeed, nginx, and IIS are the four major web servers that support this language. SSI has a simple syntax: <!--#directive parameter=value parameter=value -->. Directives are placed in HTML comments so that if SSI is not enabled, users will not see the SSI directives on the page, unless they look at its source. Note that the syntax does not allow spaces between the leading "<" and the directive.
ssl-lang (pl, appeared 1976)

SSL (Software Specification Language) is a new formalism for the definition of specifications for software systems. The language provides a linear format for the representation of the information normally displayed in a two-dimensional module inter-dependency diagram. In comparing SSL to FORTRAN or ALGOL, it is found to be largely complementary to the algorithmic (procedural) languages. SSL is capable of representing explicitly module interconnections and global data flow, information which is deeply imbedded in the algorithmic languages. On the other hand, SSL is not designed to depict the control flow within modules. The SSL level of software design explicitly depicts intermodule data flow as a functional specification.



a+b*

3.0 * sin ( r + 1.0)

2 * (ifix(c) + blank_coinmon.icount)

name. feldl

name set + [oe, fred)
Speech Synthesis Markup Language (xmlFormat, appeared 2010)




<?xml version="1.0"?>
<speak xmlns="http://www.w3.org/2001/10/synthesis"
       xmlns:dc="http://purl.org/dc/elements/1.1/"
       version="1.0">
  <metadata>
    <dc:title xml:lang="en">Telephone Menu: Level 1</dc:title>
  </metadata>

  <p>
    <s xml:lang="en-US">
      <voice name="David" gender="male" age="25">
        For English, press <emphasis>one</emphasis>.
      </voice>
    

    <s xml:lang="es-MX">
      <voice name="Miguel" gender="male" age="25">
        Para español, oprima el <emphasis>dos</emphasis>.
      </voice>
    

  </p>

</speak>
Stackless Python (interpreter, appeared 1998)


Stackless Python, or Stackless, is a Python programming language interpreter, so named because it avoids depending on the C call stack for its own stack. In practice, Stackless Python uses the C stack, but the stack is cleared between function calls . The most prominent feature of Stackless is microthreads, which avoid much of the overhead associated with usual operating system threads. In addition to Python features, Stackless also adds support for coroutines, communication channels and task serialization.
Stalin (compiler, appeared 2006)
Creators: Jeffrey Mark Siskind


Stalin (STAtic Language ImplementatioN) is an aggressive optimizing batch whole-program Scheme compiler written by Jeffrey Mark Siskind.  It uses advanced flow analysis and type inference and a variety of other optimization techniques to produce code. Stalin is intended for production use in generating an optimized executable. The compiler itself runs slowly, and there is little or no support for debugging or other niceties.  Full R4RS Scheme is supported, with a few minor and rarely encountered omissions.  Interfacing to external C libraries is straightforward.  The compiler itself does lifetime analysis and hence does not generate as much garbage as might be expected, but global reclamation of storage is done using the Boehm garbage collector. The name is a joke: "Stalin brutally optimizes." Stalin is free software, licensed under the GNU General Public License (GPL), and is available online.
Standard ML (pl, appeared 1990)
Also known as: sml
standardml
Website: http://sml-family.org
File extensions: sml


Standard ML (SML; Standard Meta Language) is a general-purpose, modular, functional programming language with compile-time type checking and type inference. It is popular among compiler writers and programming language researchers, as well as in the development of theorem provers. SML is a modern dialect of ML, the programming language used in the Logic for Computable Functions (LCF) theorem-proving project. It is distinctive among widely used languages in that it has a formal specification, given as typing rules and operational semantics in The Definition of Standard ML (1990, revised and simplified as The Definition of Standard ML (Revised) in 1997).
starlark (pl, appeared 2018)
Creators: Laurent Le Brun

The language used in Bazel. Starlark is designed to be small, simple, and thread-safe. Although it is inspired from Python, it is not a general-purpose language and most Python features are not included. Starlark is syntactically a subset of Python 3


GitHub description: Starlark Language

# Define a number
number = 18

# Define a dictionary
people = {
    "Alice": 22,
    "Bob": 40,
    "Charlie": 55,
    "Dave": 14,
}

names = ", ".join(people.keys())  # Alice, Bob, Charlie, Dave

# Define a function
def greet(name):
  """Return a greeting."""
  return "Hello {}!".format(name)

greeting = greet(names)

above30 = [name for name, age in people.items() if age >= 30]

print("{} people are above 30.".format(len(above30)))

def fizz_buzz(n):
    """Print Fizz Buzz numbers from 1 to n."""
    for i in range(1, n + 1):
        s = ""
        if i % 3 == 0:
            s += "Fizz"
        if i % 5 == 0:
            s += "Buzz"
        print(s if s else i)

fizz_buzz(20)
StarLogo (pl, appeared 2008)


StarLogo is an agent-based simulation language developed by Mitchel Resnick, Eric Klopfer, and others at MIT Media Lab and MIT Scheller Teacher Education Program in Massachusetts. It is an extension of the Logo programming language, a dialect of Lisp. Designed for education, StarLogo can be used by students to model the behavior of decentralized systems. The first StarLogo ran on a Connection Machine 2 parallel computer. A subsequent version ran on Macintosh computers; this version became known later as MacStarLogo (and now is called MacStarLogo Classic). The current StarLogo is written in Java and works on most computers. StarLogo is also available in a version called OpenStarLogo. The source code for OpenStarLogo is available online, although the license under which it is released is not an open source license according to the Open Source Definition, because of restrictions on the commercial use of the code. StarLogo TNG (The Next Generation) version 1.0 was released in July 2008. It provides a 3D world using OpenGL graphics and a block-based graphical language to increase ease of use and learnability. It is written in C and Java. StarLogo TNG uses "blocks" to put together puzzle-like pieces. StarLogo TNG reads the blocks in the order you fit them together, and sets the program in the Spaceland view. StarLogo is a primary influence for the Kedama particle system, programmed by Yoshiki Oshima, found in the  Etoys educational programming environment and language, which can be viewed as a Logo done originally in Squeak Smalltalk.
StarOffice Basic (pl, appeared 2000)


OpenOffice Basic (formerly known as StarOffice Basic or StarBasic or OOoBasic) is a dialect of the programming language BASIC that originated with the StarOffice office suite and spread through OpenOffice.org and derivatives such as LibreOffice (where it is known as LibreOffice Basic). The language is a domain-specific programming language which specifically serves the OpenOffice application suite.
Stata (pl, appeared 1985)
Creators: William Gould
Origin: StataCorp
Website: https://www.stata.com/


Stata is a general-purpose statistical software package created in 1985 by StataCorp. Most of its users work in research, especially in the fields of economics, sociology, political science, biomedicine and epidemiology. Stata's capabilities include data management, statistical analysis, graphics, simulations, regression, and custom programming. It also has a system to disseminate user-written programs that lets it grow continuously. The name Stata is a syllabic abbreviation of the words statistics and data. The FAQ for the official forum of Stata insists that the correct English pronunciation of Stata "must remain a mystery"; any of "Stay-ta", "Sta-ta" or "Stah-ta" are considered acceptable. There are four major builds of each version of Stata: Stata/MP for multiprocessor computers (including dual-core and multicore processors) Stata/SE for large databases Stata/IC, which is the standard version Numerics by Stata, supports any of the data sizes listed above in an embedded environment Small Stata, which was the smaller, student version for educational purchase only is no longer available.
stella (pl, appeared 1999)
Website: https://www.isi.edu/isd/LOOM/Stella/index.html
File extensions: ste

STELLA is a strongly typed, object-oriented, Lisp-like language, designed to facilitate symbolic programming tasks in artificial intelligence applications. STELLA preserves those features of Common Lisp deemed essential for symbolic programming such as built-in support for dynamic data structures, heterogeneous collections, first-class symbols, powerful iteration constructs, name spaces, an object-oriented type system with a meta-object protocol, exception handling, and language extensibility through macros, but without compromising execution speed, interoperability with non-STELLA programs, and platform independence. STELLA programs are translated into a target language such as C++, Common Lisp, or Java, and then compiled with the native target language compiler to generate executable code. The language constructs of STELLA are restricted to those that can be translated directly into native constructs of the intended target languages, thus enabling the generation of highly efficient as well as readable code. As of Fall 2000, we have programmed approximately 100,000 lines of STELLA code - about 50% for the STELLA kernel itself and the other 50% for the PowerLoom knowledge representation system and related systems. Our subjective experience has been that it is only slightly more difficult to write and debug a STELLA program than a Lisp program, and that the inconvenience of having to supply some type information is much outweighed by the benefits such as catching many errors during compile time instead of at run time. The biggest benefit, however, seems to be that we can still leverage all the incremental code development benefits of Lisp, since we use the Common Lisp-based version of STELLA for prototyping. This allows us to incrementally define and redefine functions, methods and classes and to inspect, debug and fix incorrect code on the fly. Even the most sophisticated C++ or Java IDE's don't yet seem to support this fully incremental development style, i.e., a change in a class (every change in Java is a change to a class) still requires recompilation and restart of the application, and it is the restart that can be the most time consuming if one debugs a complex application that takes a significant time to reach a certain state.



(defun (lisp-null-array-symbol-string STRING) ((rank INTEGER))
  ;; Used in the lisp translation code, insdie a verbatim
  ;; to return Lisp-specific-code.
  (CASE rank
    (1 (return "STELLA::NULL-1D-ARRAY"))
    (2 (return "STELLA::NULL-2D-ARRAY"))
    (3 (return "STELLA::NULL-3D-ARRAY"))
    (4 (return "STELLA::NULL-4D-ARRAY"))
    (5 (return "STELLA::NULL-5D-ARRAY"))
    (otherwise (return "STELLA::NULL"))))
Stencil (template, appeared 2018)
Creators: Kyle Fuller
Website: https://stencil.fuller.li/en/latest/

Stencil is a simple and powerful template language for Swift. It provides a syntax similar to Django and Mustache.


GitHub description: Stencil is a simple and powerful template language for Swift.

There are {{ articles.count }} articles.

<ul>
  {% for article in articles %}
    <li>{{ article.title }} by {{ article.author }}</li>
  {% endfor %}
</ul>