pldb/PLDB huggingface dataset:
Sather (pl, appeared 1990)
Creators: Steve Omohundro
Origin: University of California, Berkeley and University of Waikato and GNU project
Country: United States and New Zealand
Website: https://www.gnu.org/software/sather/


Sather is an object-oriented programming language. It originated circa 1990 at the International Computer Science Institute (ICSI) at the University of California, Berkeley, developed by an international team led by Steve Omohundro. It supports garbage collection and generics by subtypes. Originally, it was based on Eiffel, but it has diverged, and now includes several functional programming features. It is probably best to view it as an object-oriented language, with many ideas borrowed from Eiffel. Even the name is inspired by Eiffel; the Sather Tower is a recognizable landmark at Berkeley, named after Jane Krom Sather, the widow of Peder Sather, who donated large sums to the foundation of the university. Sather also takes inspiration from other programming languages and paradigms: iterators, design by contract, abstract classes, multiple inheritance, anonymous functions, operator overloading, contravariant type system. The original Berkeley implementation (last stable version 1.1 was released in 1995, no longer maintained) has been adopted by the Free Software Foundation therefore becoming GNU Sather. Last stable GNU version (1.2.3) was released in July 2007 and the software is currently not maintained. There were several other variants: Sather-K from the University of Karlsruhe; Sather-W from the University of Waikato (implementation of Sather version 1.3); Peter Naulls' port of ICSI Sather 1.1 to RISC OS; and pSather, a parallel version of ICSI Sather addressing non-uniform memory access multiprocessor architectures but presenting a shared memory model to the programmer. The former ICSI Sather compiler (now GNU Sather) is implemented as a compiler to C, i.e., the compiler does not output object or machine code, but takes Sather source code and generates C source code as an intermediate language. Optimizing is left to the C compiler. The GNU Sather compiler, written in Sather itself, is dual licensed under the GNU GPL & LGPL.
Sawzall (pl, appeared 2003)
Origin: Google, Inc
Country: United States


Sawzall is a procedural domain-specific programming language, used by Google to process large numbers of individual log records. Sawzall was first described in 2003, and the szl runtime was open-sourced in August 2010. However, since the MapReduce table aggregators have not been released, the open-sourced runtime is not useful for large-scale data analysis of multiple log files off the shelf. Sawzall has been replaced by Lingo (logs in Go) for most purposes within Google.
SBASIC (pl, appeared 1983)
Creators: Gilbert Ohnysty
Origin: Topaz Programming
Country: United States


S-BASIC (for Structured Basic) was a "structured" BASIC variant, distributed with Kaypro CP/M systems.  It was made by Topaz Programming is distributed by Micro-Ap (San Ramon, CA).SBasic was compatible with the syntax of Basic, a programming language commonly used in the 1970s through the 1980s, as well as Fortran77.  However, the language relaxed many of the requirements of Basic and had more flexibility than Fortran.  For instance, line numbers were optional, and permitted non-numeric characters.  In addition, SBasic offered developers structured programming concepts, including recursion and nesting. Many PL-1 programs could be compiled with little modification, though SBasic did not offer an extensive function library. Among the more advanced features was the ability to "base" a variable or array, making the memory location dynamic and modifiable during execution.  SBasic programs had the ability to access memory areas reserved for the operating system unless prohibited from doing so by the operating system itself.  (Kaypro's CP/M had no such prohibitions.)  This enabled direct utilization and modification of DMA and other memory areas.  This feature also permitted a program to modify itself at run-time.  This capability also allowed modifying the instruction pointer, so a program could effectively link other executable modules that were read during execution as data. Unlike Basic interpreters that stored "p-code" that was parsed by an execution module, SBasic was a two-pass compiler, ultimately producing .com files that were executable.  The language was written in a subset of itself and compiled using a .com kernel, then stored on diskette (or hard drive on the last KayPro model).  The source was distributed with some KayPro models.  This encouraged open-source-like modification of the language, with some early pre-Internet user groups exchanging physical diskettes by regular mail. Not to be confused with the namesake SBasic (S for Spectral Basic) Programming Language for the commercial Spectral UV-Visible software.
Steel Bank Common Lisp (pl, appeared 1999)
Stands for: Steel Bank Common Lisp
Origin: Carnegie Mellon University
Country: United States
Website: http://www.sbcl.org


Steel Bank Common Lisp (SBCL) is a free Common Lisp implementation that features a high-performance native compiler, Unicode support and threading. The name "Steel Bank Common Lisp" is a reference to Carnegie Mellon University Common Lisp from which SBCL forked: Andrew Carnegie made his fortune in the steel industry and Andrew Mellon was a successful banker.
Systems Biology Markup Language (xmlFormat, appeared 2006)
Stands for: Systems Biology Markup Language


The Systems Biology Markup Language (SBML) is a representation format, based on XML, for communicating and storing computational models of biological processes. It is a free and open standard with widespread software support and a community of users and developers. SBML can represent many different classes of biological phenomena, including metabolic networks, cell signaling pathways, regulatory networks, infectious diseases, and many others. It has been proposed as a standard for representing computational models in systems biology today.
Scala.js (pl, appeared 2013)
Creators: Martin Odersky
Origin: https://github.com/scala-js
Country: United States and Switzerland
Website: https://www.scala-js.org/


Scala ( SKAH-lah) is a general-purpose programming language providing support for functional programming and a strong static type system. Designed to be concise, many of Scala's design decisions aimed to address criticisms of Java.Scala source code is intended to be compiled to Java bytecode, so that the resulting executable code runs on a Java virtual machine. Scala provides language interoperability with Java, so that libraries written in both languages may be referenced directly in Scala or Java code. Like Java, Scala is object-oriented, and uses a curly-brace syntax reminiscent of the C programming language. Unlike Java, Scala has many features of functional programming languages like Scheme, Standard ML and Haskell, including currying, type inference, immutability, lazy evaluation, and pattern matching. It also has an advanced type system supporting algebraic data types, covariance and contravariance, higher-order types (but not higher-rank types), and anonymous types. Other features of Scala not present in Java include operator overloading, optional parameters, named parameters, and raw strings. Conversely, a feature of Java not in Scala is checked exceptions, which have proved controversial.The name Scala is a portmanteau of scalable and language, signifying that it is designed to grow with the demands of its users.

GitHub description: Scala.js, the Scala to JavaScript compiler

class Person(val firstName: String, val lastName: String) {
 def fullName(): String =
   s"$firstName $lastName"
}
Scala (pl, appeared 2004)
Creators: Martin Odersky
Origin: École Polytechnique Fédérale de Lausanne
Country: Switzerland
Website: http://www.scala-lang.org
File extensions: scala
sc
Keywords: abstract
case
catch
class
def
do
else
extends
false
final
finally
for
forSome
if
implicit
import
lazy
match
new
null
object
override
package
private
protected
return
sealed
super
this
throw
trait
try
true
type
val
var
while
with
yield


Scala ( SKAH-lah) is a general-purpose programming language providing support for functional programming and a strong static type system. Designed to be concise, many of Scala's design decisions aimed to address criticisms of Java. Scala source code is intended to be compiled to Java bytecode, so that the resulting executable code runs on a Java virtual machine. Scala provides language interoperability with Java, so that libraries written in both languages may be referenced directly in Scala or Java code. Like Java, Scala is object-oriented, and uses a curly-brace syntax reminiscent of the C programming language. Unlike Java, Scala has many features of functional programming languages like Scheme, Standard ML and Haskell, including currying, type inference, immutability, lazy evaluation, and pattern matching. It also has an advanced type system supporting algebraic data types, covariance and contravariance, higher-order types (but not higher-rank types), and anonymous types. Other features of Scala not present in Java include operator overloading, optional parameters, named parameters, and raw strings. Conversely, a feature of Java not in Scala is checked exceptions, which have proved controversial. The name Scala is a portmanteau of scalable and language, signifying that it is designed to grow with the demands of its users.
Scenic (pl, appeared 2019)
Origin: University of California, Berkeley
Country: United States

A Language for Scenario Specification and Scene Generation. We propose a new probabilistic programming language for the design and analysis of perception systems, especially those based on machine learning. Specifically, we consider the problems of training a perception system to handle rare events, testing its performance under different conditions, and debugging failures. We show how a probabilistic programming language can help address these problems by specifying distributions encoding interesting types of inputs and sampling these to generate specialized training and test sets. More generally, such languages can be used for cyber-physical systems and robotics to write environment models, an essential prerequisite to any formal analysis. In this paper, we focus on systems like autonomous cars and robots, whose environment is a scene, a configuration of physical objects and agents. We design a domain-specific language, Scenic, for describing scenarios that are distributions over scenes. As a probabilistic programming language, Scenic allows assigning distributions to features of the scene, as well as declaratively imposing hard and soft constraints over the scene. We develop specialized techniques for sampling from the resulting distribution, taking advantage of the structure provided by Scenic's domain-specific syntax. Finally, we apply Scenic in a case study on a convolutional neural network designed to detect cars in road images, improving its performance beyond that achieved by state-of-the-art synthetic data generation methods.
Schema.org (dataValidationLanguage, appeared 2011)
Origin: https://groups.google.com/g/schema-org-sg
Country: Various
Website: http://schema.org


Schema.org is an initiative launched on 2 June 2011 by Bing, Google and Yahoo! (then operators of the world's largest search engines) to “create and support a common set of schemas for structured data markup on web pages.” In November 2011 Yandex (whose search engine is the largest one in Russia) joined the initiative. They propose using the schema.org vocabulary along with the Microdata, RDFa, or JSON-LD formats to mark up website content with metadata about itself. Such markup can be recognized by search engine spiders and other parsers, thus gaining access to the meaning of the sites (see Semantic Web). The initiative also describes an extension mechanism for adding additional properties. Public discussion of the initiative largely takes place on the W3C public vocabularies mailing list. In 2012, the GoodRelations ontology was integrated into Schema.org. Much of the vocabulary on schema.org was inspired by earlier formats such as Microformats, FOAF, and OpenCyc. Microformats, with its most dominant representative hCard, continue (as of 2015) to be published widely in the Web, where the deployment of schema.org has strongly increased between 2012 and end 2014. To test the validity of the data marked up with the schemas and Microdata, such validators as the Google Structured Data Testing Tool, Yandex Microformat validator and Bing Markup Validator can be used. Some Schema markups such as Organization and Person are used to influence Google's Knowledge Graph results.
Schematron (xmlFormat, appeared 1999)
Origin: Academia Sinica
Country: Republic of China (Taiwan)


Schematron is a rule-based validation language for making assertions about the presence or absence of patterns in XML trees.  It is a structural schema language expressed in XML using a small number of elements and XPath. In a typical implementation, the Schematron schema XML is processed into normal XSLT code for deployment anywhere that XSLT can be used. Schematron is capable of expressing constraints in ways that other XML schema languages like XML Schema and DTD cannot. For example, it can require that the content of an element be controlled by one of its siblings. Or it can request or require that the root element, regardless of what element that is, must have specific attributes. Schematron can also specify required relationships between multiple XML files. Constraints and content rules may be associated with "plain-English" validation error messages, allowing translation of numeric Schematron error codes into meaningful user error messages. The current ISO recommendation is Information technology, Document Schema Definition Languages (DSDL), Part 3: Rule-based validation, Schematron (ISO/IEC 19757-3:2016).


<schema xmlns="http://purl.oclc.org/dsdl/schematron">
  <pattern>
     <title>Date rules</title>
     <rule context="Contract">
        <assert test="ContractDate &lt; current-date()">ContractDate should be
in the past because future contracts are not allowed.</assert>
     </rule>
  </pattern>
</schema>
Scheme (pl, appeared 1970)
Creators: Guy Steele
Gerald Jay Sussman
Origin: https://community.scheme.org/
Country: United States
Website: http://www.scheme-reports.org/
File extensions: scm
ss
Keywords: case
do
let
loop
if
else
when
cons
car
cdr
cond
lambda
lambda*
syntax-rules
format
set!
quote
eval
append
list
list?
member?
load


Scheme is a functional programming language and one of the two main dialects of the programming language Lisp. Unlike Common Lisp, the other main dialect, Scheme follows a minimalist design philosophy specifying a small standard core with powerful tools for language extension. Scheme was created during the 1970s at the MIT AI Lab and released by its developers, Guy L. Steele and Gerald Jay Sussman, via a series of memos now known as the Lambda Papers. It was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support first-class continuations. It had a significant influence on the effort that led to the development of Common Lisp. The Scheme language is standardized in the official IEEE standard and a de facto standard called the Revisedn Report on the Algorithmic Language Scheme (RnRS). The most widely implemented standard is R5RS (1998); a new standard, R6RS, was ratified in 2007. Scheme has a diverse user base due to its compactness and elegance, but its minimalist philosophy has also caused wide divergence between practical implementations, so much that the Scheme Steering Committee calls it "the world's most unportable programming language" and "a family of dialects" rather than a single language.
Scikit-learn (library, appeared 2007)
Creators: David Cournapeau
Origin: https://github.com/scikit-learn
Country: Various
Website: http://scikit-learn.org/stable/


Scikit-learn (formerly scikits.learn) is a free software machine learning library for the Python programming language. It features various classification, regression and clustering algorithms including support vector machines, random forests, gradient boosting, k-means and DBSCAN, and is designed to interoperate with the Python numerical and scientific libraries NumPy and SciPy.

GitHub description: scikit-learn: machine learning in Python
Scilab (pl, appeared 1990)
Origin: https://gitlab.com/groups/scilab/-/issues
Country: Various


Scilab is an open source, cross-platform numerical computational package and a high-level, numerically oriented programming language. It can be used for signal processing, statistical analysis, image enhancement, fluid dynamics simulations, numerical optimization, and modeling, simulation of explicit and implicit dynamical systems and (if the corresponding toolbox is installed) symbolic manipulations. Scilab is one of the two major open-source alternatives to MATLAB, the other one being GNU Octave. Scilab is similar enough to MATLAB that some book authors (who use it) argue that it is easy to transfer skills between the two systems. Scilab however puts less emphasis on (bidirectional) syntactic compatibility with MATLAB than Octave does.
SciPy (library, appeared 2001)
Creators: Eric Jones
Origin: https://github.com/scipy
Country: Various
Website: https://www.scipy.org/scipylib/index.html


SciPy (pronounced "Sigh Pie") is an open source Python library used for scientific computing and technical computing. SciPy contains modules for optimization, linear algebra, integration, interpolation, special functions, FFT, signal and image processing, ODE solvers and other tasks common in science and engineering. SciPy builds on the NumPy array object and is part of the NumPy stack which includes tools like Matplotlib, pandas and SymPy, and an expanding set of scientific computing libraries. This NumPy stack has similar users to other applications such as MATLAB, GNU Octave, and Scilab. The NumPy stack is also sometimes referred to as the SciPy stack. SciPy is also a family of conferences for users and developers of these tools: SciPy (in the United States), EuroSciPy (in Europe) and SciPy.in (in India). Enthought originated the SciPy conference in the United States and continues to sponsor many of the international conferences as well as host the SciPy website. The SciPy library is currently distributed under the BSD license, and its development is sponsored and supported by an open community of developers. It is also supported by Numfocus which is a community foundation for supporting reproducible and accessible science.

GitHub description: SciPy library main repository
Structured Control Language (pl, appeared 1998)
Stands for: Structured Control Language




CASE TW OF
 1: DISPLAY := OVEN_TEMP;
 2: DISPLAY := MOTOR_SPEED;
 3: DISPLAY := GROSS_TARE;
  QW4 := 16#0003;
 4..10:DISPLAY := INT_TO_DINT (TW);
  QW4 := 16#0004;
 11,13,19:DISPLAY:= 99;
  QW4 := 16#0005;
ELSE: DISPLAY := 0;
 TW_ERROR := 1;
END_CASE;
Sclipting (esolang, appeared 2011)

Sclipting is a stack-based golf language, inspired by GolfScript, that uses Chinese characters for instructions and Hangul syllables for data (strings and integers). The basic idea is that to minimise the number of characters in a program, the language should provide as many single-character instructions as possible. It was invented by Timwi in 2011. Sclipting is not considered finished as it can trivially be extended with more and more instructions assigned to new Chinese characters.
SCM (pl, appeared 1990)
Creators: Aubrey Jaffer


SCM is a programming language, a dialect of the language Scheme. It is written in the  language C, by Aubrey Jaffer, the author of the SLIB Scheme library and the JACAL interactive computer algebra (symbolic mathematics) program. It conforms to the standards R4RS, R5RS, and IEEE P1178. It is free and open-source software released under a GNU Lesser General Public License (LGPL).SCM runs on many different operating systems such as AmigaOS (also emulation), Linux, Atari-ST, macOS (SCM Mac), DOS, OS/2, NOS/VE, Unicos, VMS, Unix, and similar systems. SCM includes Hobbit, a Scheme-to-C compiler written originally in 2002 by Tanel Tammet. It generates C files which binaries can be dynamically or statically linked with an SCM executable. SCM includes linkable modules for SLIB features like sequence comparison, arrays, records, and byte-number conversions, and modules for Portable Operating System Interface (POSIX) system calls and network sockets, Readline, curses, and Xlib. On some platforms, SCM supports unexec (developed for Emacs and bash), which dumps an executable image from a running SCM. This results in a fast startup for SCM. SCM developed from Scheme In One Defun (SIOD) in about 1990. GNU Guile developed from SCM in 1993.
Scrapscript (pl, appeared 2023)
Creators: Taylor Troesh
Website: https://scrapscript.org/

All programs are data, expressions are content-addressable "scraps".Scrapscript rejects traditional package-management. Instead, “scrapyards” combine features from Smalltalk, Hackage, IPFS, GitHub, and StackOverflow. 



greet <| person:ron 3

. greet :: person -> text =
  | :cowboy -> "howdy"
  | :ron n -> "hi " ++ a ++ "ron" , a = text/repeat n "a"
  | :parent :m -> "hey mom"
  | :parent :f -> "greetings father"
  | :friend n -> "yo" |> list/repeat n |> string/join " "
  | :stranger "felicia" -> "bye"
  | :stranger name -> "hello " ++ name

. person =
  : cowboy
  : ron int
  : parent s , s = (: m : f)
  : friend int
  : stranger text
Scratch (visual, appeared 2002)
Website: https://scratch.mit.edu/
File extensions: scratch
sb
sprite
sb2
sprite2


Scratch is a free visual programming language developed by the MIT Media Lab. Scratch was created to help young people learn to think creatively, reason systematically and work collaboratively. It is used by students, teachers and parents to easily create interactive stories, animations, games, etc. It provides a stepping stone to the world of computer programming. It can also be used for a range of educational and entertainment constructionist purposes from math and science projects, including simulations and visualizations of experiments, recording lectures with animated presentations, to social sciences animated stories, and interactive art.
Scratchpad (pl, appeared 1971)


Scratchpad may refer to:  A pad of paper, such as a notebook, for preliminary notes, sketches, or writings Scratchpad memory, also known as scratchpad, scratchpad RAM or local store. is a high-speed internal memory used for temporary storage of calculations, data, and other work in progress Scratchpad, the former name of Axiom, a free, general-purpose computer algebra system
scribble (pl, appeared 1997)
Creators: Matthew Flatt




#lang scribble/doc
@(require scribble/manual "utils.rkt"
          (for-syntax racket/base)
          (for-label scribble/manual-struct
                     version/utils
                     syntax/quote))

@(define lit-ellipses (racket ...))
@(define lit-ellipses+ (racket ...+))

@title[#:tag "manual" #:style 'toc]{Manual Forms}

@defmodulelang[scribble/manual]{The @racketmodname[scribble/manual]
language provides all of @racketmodname[scribble/base] plus many
additional functions that are specific to writing Racket
documentation. It also associates @tech{style properties} with the
generated @racket[doc] export to select the default Racket manual
style for rendering; see @secref["manual-render-style"] for more
information.

The @racketmodname[scribble/manual] name can also be used as a library
with @racket[require], in which case it provides all of the same
bindings, but without setting the reader or setting the default
rendering format to the Racket manual format.}