pldb/PLDB huggingface dataset:
SPARC (isa, appeared 1987)
Origin: Sun Microsystems


SPARC, for Scalable Processor Architecture, is a reduced instruction set computing (RISC) instruction set architecture (ISA) originally developed by Sun Microsystems. Its design was strongly influenced by the experimental Berkeley RISC system developed in the early 1980s. First released in 1987, SPARC was one of the most successful early commercial RISC systems, and its success led to the introduction of similar RISC designs from a number of vendors through the 1980s and 90s. The first implementation of the original 32-bit architecture (SPARC V7) was used in Sun's Sun-4 workstation and server systems, replacing their earlier Sun-3 systems based on the Motorola 68000 series of processors. SPARC V8 added a number of improvements that were part of the SuperSPARC series of processors released in 1992. SPARC V9, released in 1993, introduced a 64-bit architecture and was first released in Sun's UltraSPARC processors in 1995. Later, SPARC processors were used in SMP and CC-NUMA servers produced by Sun, Solbourne and Fujitsu, among others. The design was turned over to the SPARC International trade group in 1989, and since then its architecture has been developed by its members. SPARC International is also responsible for licensing and promoting the SPARC architecture, managing SPARC trademarks (including SPARC, which it owns), and providing conformance testing. SPARC International was intended to grow the SPARC architecture to create a larger ecosystem; SPARC has been licensed to several manufacturers, including Atmel, Bipolar Integrated Technology, Cypress Semiconductor, Fujitsu, Matsushita and Texas Instruments. Due to SPARC International, SPARC is fully open, non-proprietary and royalty-free. By September 2017, the latest commercial high-end SPARC processors are Fujitsu's SPARC64 XII (introduced in 2017 for its SPARC M12 server) and SPARC64 XIfx (introduced in 2015 for its PRIMEHPC FX100 supercomputer); and Oracle's SPARC M8 (introduced in September 2017 for its high-end servers). On Friday, September 1, 2017, after a round of layoffs that started in Oracle Labs in November of 2016, Oracle finally killed off SPARC design after the completion of the M8. Nearly the entire processor core development group in Austin was let go, and the same for the SOC teams in California and Burlington.
SPARK (pl, appeared 1988)
Country: United Kingdom


SPARK is a formally defined computer programming language based on the Ada programming language, intended for the development of high integrity software used in systems where predictable and highly reliable operation is essential. It facilitates the development of applications that demand safety, security, or business integrity. Originally, there were three versions of the SPARK language (SPARK83, SPARK95, SPARK2005) based on Ada 83, Ada 95 and Ada 2005 respectively. A fourth version of the SPARK language, SPARK 2014, based on Ada 2012, was released on April 30, 2014. SPARK 2014 is a complete re-design of the language and supporting verification tools. The SPARK language consists of a well-defined subset of the Ada language that uses contracts to describe the specification of components in a form that is suitable for both static and dynamic verification. In SPARK83/95/2005, the contracts are encoded in Ada comments (and so are ignored by any standard Ada compiler), but are processed by the SPARK "Examiner" and its associated tools. SPARK 2014, in contrast, uses Ada 2012's built-in "aspect" syntax to express contracts, bringing them into the core of the language. The main tool for SPARK 2014 (GNATprove) is based on the GNAT/GCC infrastructure, and re-uses almost the entirety of the GNAT Ada 2012 front-end.
SPARQL (queryLanguage, appeared 2008)
Stands for: SPARQL Protocol and RDF Query Language
Origin: W3C
Keywords: add
as
asc
ask
base
by
clear
construct
copy
create
data
delete
desc
describe
distinct
drop
false
filter
from
graph
group
having
in
insert
limit
load
minus
move
named
not
offset
optional
order
prefix
reduced
select
service
silent
to
true
undef
union
using
values
where
with


SPARQL (pronounced "sparkle", a recursive acronym for SPARQL Protocol and RDF Query Language) is an RDF query language, that is, a semantic query language for databases, able to retrieve and manipulate data stored in Resource Description Framework (RDF) format. It was made a standard by the RDF Data Access Working Group (DAWG) of the World Wide Web Consortium, and is recognized as one of the key technologies of the semantic web. On 15 January 2008, SPARQL 1.0 became an official W3C Recommendation, and SPARQL 1.1 in March, 2013. SPARQL allows for a query to consist of triple patterns, conjunctions, disjunctions, and optional patterns. Implementations for multiple programming languages exist. There exist tools that allow one to connect and semi-automatically construct a SPARQL query for a SPARQL endpoint, for example ViziQuer. In addition, there exist tools that translate SPARQL queries to other query languages, for example to SQL and to XQuery.
Spatial (pl, appeared 2018)
Stands for: Specify Parameterized Accelerators Through Inordinately Abstract Language
Creators: David Koeplinger
Website: https://spatial-lang.org/

Spatial: A High Level Programming Language for FPGAs


GitHub description: Spatial: "Specify Parameterized Accelerators Through Inordinately Abstract Language"

import spatial.dsl._

@spatial object HelloSpatial extends SpatialApp {
  def main(args: Array[String]): Void = {
    // Create ArgIn
    val x = ArgIn[Int]
    
    // Set `x` to the value of the first command line argument
    setArg(x, args(0).to[Int])
    
    Accel {
      // Create 16x32 SRAM and a Register
      val s = SRAM[Int](16,32)
      val r = Reg[Int]
      
      // Loop over each element in SRAM
      Foreach(16 by 1, 32 by 1){(i,j) => 
        s(i,j) = i + j
      }
      // Store element into the register, based on the input arg
      r := s(x,x)

      // Print value of register (only shows in Scala simulation)
      println(r"Value of SRAM at (${x.value},${x.value}) is ${r.value}")
    }

  }
}
Speakeasy (pl, appeared 2006)
Creators: Stanley Cohen
Website: http://speakeasy.com


Speakeasy is a numerical computing interactive environment also featuring an interpreted programming language. It was initially developed for internal use at the Physics Division of Argonne National Laboratory by the theoretical physicist Stanley Cohen. He eventually founded Speakeasy Computing Corporation to make the program available commercially. Speakeasy is a very long-lasting numerical package. In fact, the original version of the environment was built around a core dynamic data repository called "Named storage" developed in the early 1960s, while the most recent version has been released in 2006. Speakeasy was aimed to make the computational work of the physicists at the Argonne National Laboratory easier. It was initially conceived to work on mainframes (the only kind of computers at that time), and was subsequently ported to new platforms (minicomputers, personal computers) as they became available. The porting of the same code on different platforms was made easier by using Mortran metalanguage macros to face systems dependencies and compilers deficiencies and differences. Speakeasy is currently available on several platforms : PCs running Windows, macOS, Linux, departmental computers and workstations running several flavors of Linux, AIX or Solaris. Speakeasy was also among the first interactive numerical computing environments, having been implemented in such a way on a CDC 3600 system, and later on IBM TSO machines as one was in beta-testing at the Argonne National Laboratory at the time. Almost since the beginning (as the dynamic linking functionality was made available in the operating systems) Speakeasy features the capability of expanding its operational vocabulary using separated modules, dynamically linked to the core processor as they are needed. For that reason such modules  were called "linkules" (LINKable-modULES). They are functions with a generalized interface, which can be written in  FORTRAN or in C. The independence of each of the new modules from the others and from the main processor is of great help in improving the system, especially it was in the old days. This easy way of expanding the functionalities of the main processor was often exploited by the users to develop their own specialized packages. Besides the programs, functions and subroutines the user can write in the Speakeasy's own interpreted language, linkules add functionalities carried out with the typical performances of compiled programs. Among the packages developed by the users, one of the most important is "Modeleasy", originally developed as "FEDeasy" in the early 1970s at the research department of the Federal Reserve Board of Governors in Washington D.C.. Modeleasy implements special objects and functions for large econometric models estimation and simulation. Its evolution led eventually to its distribution as an independent product.
Spec Sharp (pl, appeared 2004)


Spec# is a programming language with specification language features that extends the capabilities of the C# programming language with Eiffel-like contracts, including object invariants, preconditions and postconditions. Like ESC/Java, it includes a static checking tool based on a theorem prover that is able to statically verify many of these invariants. It also includes a variety of other minor extensions to the language, such as non-null reference types. The code contracts API in the .NET Framework 4.0 has evolved with Spec#. Microsoft Research developed both Spec# and C#; in turn, Spec# serves as the foundation of the Sing# programming language, which Microsoft Research also developed.
specrtl (pl, appeared 2011)

specRTL (Spec Register Transfer Language) is a language designed to replace the existing RTL form machine descriptions which along with C Code forms the backend of GCC.



concrete *cmp_ccno_1.insn instantiates set_compare
{
  root(reg(NULL:FLAGS_REG),0=nonimmediate_operand:SWI:",?m",
1=const0_operand:SWI:"");
}
{:
  "ix86_match_ccmode (insn, CCNOmode)"
  "@
  test{}\t%0, %0
  cmp{}\t{%1, %0|%0,%1}"
  [(set_attr "type" "test,icmp")
  (set_attr "length_immediate" "0,1")
  (set_attr "mode" "")]
:}
Speedcoding (pl, appeared 1953)
Creators: John Backus


Speedcoding or Speedcode was the first high-level programming language created for an IBM computer. The language was developed by John Backus in 1953 for the IBM 701 to support computation with  floating point numbers. Here high level means symbolic and aiming for natural language expressivity as a goal as opposed to machine or hardware instruction oriented coding. The idea arose from the difficulty of programming the IBM SSEC machine when Backus was hired to calculate astronomical positions in early 1950. The speedcoding system was an interpreter and focused on ease of use at the expense of system resources. It provided pseudo-instructions for common mathematical functions: logarithms, exponentiation, and trigonometric operations. The resident software analyzed pseudo-instructions one by one and called the appropriate subroutine. Speedcoding was also the first implementation of decimal input/output operations. Although it substantially reduced the effort of writing many jobs, the running time of a program that was written with the help of Speedcoding was usually ten to twenty times that of machine code. The interpreter took 310 memory words, about 30% of the memory available on a 701.
Speedie (pl, appeared 2022)
Creators: Theodore H Smith
Country: United Kingdom
Website: http://github.com/gamblevore/speedie
File extensions: spd
scproj
Keywords: #require
#expect
#error
and
asm
break
class
continue
else
elseif
false
for
if
is
in
import
module
or
return
require
expect
error
virtual
behaviour
function
syntax
syx
self
true
with
yield
while
xor

"General-purpose modern and clean object-oriented programming language."
Spice Lisp (pl, appeared 1980)
Creators: Scott Fahlman


Spice Lisp is a Lisp dialect and its implementation originally written by CMU's Spice Lisp Group which targeted the microcode of the 16-bit PERQ workstation and its Accent operating system; it used that workstation's microcode abilities (it provided microcodes for Pascal, C, and Ada besides) to implement a stack architecture to store its data structures as 32-bit objects and to enable runtime type-checking. It would later be popular on other workstations. Spice Lisp evolved into CMUCL, a Common Lisp implementation.
SpiderBasic (pl, appeared 2015)
Origin: Fantaisie Software
Country: France
Website: https://www.spiderbasic.com/
File extensions: pb
Keywords: And
Array
Bool
Break
CallDebugger
Case
ClearStructure
CompilerCase
CompilerElse
CompilerElseIf
CompilerEndIf
CompilerEndSelect
CompilerIf
CompilerSelect
Continue
CopyStructure
Data
DataSection
Debug
DebugLevel
Declare
DeclareModule
Default
Define
Defined
Dim
DisableExplicit
DisableDebugger
DisableJS
Else
ElseIf
EnableASM
EnableExplicit
EnableDebugger
EnableJS
End
EndDataSection
EndDeclareModule
EndEnumeration
EndIf
EndImport
EndInterface
EndMacro
EndModule
EndProcedure
EndSelect
EndStructure
EndWith
Enumeration
Extends
For
ForEach
Forever
Global
Import
IncludeFile
IncludePath
Interface
List
Macro
MacroExpandedCount
Map
Module
NewList
NewMap
Next
Not
OffsetOf
Or
Procedure
ProcedureReturn
Protected
Prototype
Read
ReDim
Repeat
Restore
Runtime
Select
Shared
SizeOf
Static
Step
Structure
Subsystem
Swap
To
TypeOf
UndefineMacro
Until
UnuseModule
UseModule
Wend
With
While
XIncludeFile
XOr



GitHub description: PureBasic OpenSource Projects
Spin (pl, appeared 2006)

The multicore Propeller microcontroller opens up a new level of invention possibilities for students. Programming it in its native high-level language, Spin, makes optimal use of this unique and powerful multicore microcontroller. Spin's design was inspired by great attributes of three other languages, Delphi, C, and Python, and by envisioning new solutions to common programming problems. Like Python, Spin uses indentation whitespace, rather than curly braces or keywords, to delimit blocks.
SPIP (pl, appeared 1977)


SPIP (Système de Publication pour l'Internet) is a free software content management system designed for web site publishing, oriented towards online collaborative editing. The software is designed for easy setup, use and maintenance, and is used in public and private institutions. The last P in the word SPIP stands for both Partagé (shared) and Participatif (participative), in the sense that the software is designed for collective online editing. Its mascot is a flying squirrel. It is used both by institutional sites, community portals, academic sites, personal webpages, and news sites.
spir-v (ir, appeared 2015)

Abstract. SPIR-V is a new platform-independent intermediate language. It is a self-contained, fully specified, binary format for representing graphical-shader stages and compute kernels for multiple APIs. Physically, it is a stream of 32-bit words. Logically, it is a header and a linear stream of instructions. These encode, first, a set of annotations and decorations, and second a collection of functions. Each function encodes a control-flow graph (CFG) of basic blocks, with additional instructions to preserve source-code structured flow control. Load/store instructions are used to access declared variables, which includes all input/output (IO). Intermediate results bypassing load/store use single static-assignment (SSA) representation. Data objects are represented logically, with hierarchical type information: There is no flattening of aggregates or assignment to physical register banks, etc. Selectable addressing models establish whether general pointers may be used, or if memory access is purely logical.
SPITBOL (pl, appeared 1971)
Country: United States


SPITBOL (Speedy Implementation of SNOBOL) is a compiled implementation of the SNOBOL4 programming language. Originally targeted for the IBM System/360 and System/370 family of computers, it has now been ported to most major microprocessors including the SPARC. It was created by Robert Dewar and Ken Belcher, who were then at the Illinois Institute of Technology. Prior to the development of SPITBOL, SNOBOL4 was thought to be slow, memory-intensive, and impossible to compile due to its dynamic nature. While delayed binding prevents everything from being determined at compile time, SPITBOL adopts various strategies for making decisions as early as possible. Recent versions of the SPITBOL compiler are available. Since 2001 the source code for the original SPITBOL 360 compiler has been made available under the GNU General Public License. MACRO SPITBOL is an implementation of SPITBOL written in the 1970s by Robert Dewar and Anthony P. McCann. MACRO SPITBOL is coded in MINIMAL, an assembly language for an abstract machine. The instruction set is carefully defined to allow some latitude in its implementation, so that hardware operations favorable to string processing can be exploited. An implementation of MINIMAL that was designed for interpretation on microcomputers was done by translating MINIMAL into MICRAL using a translator that was itself implemented in SPITBOL. The MICRAL version of MACRO SPITBOL, together with the MICRAL interpreter ran in under 40K bytes. This extreme object code compression of MICRAL is achieved using a set of machine code macro substitutions that minimizes the space required for the object code and macro table. The complexity of known algorithms for an optimal solution to this problem are high, but efficient heuristics attain near-optimal results. The source code for MACRO SPITBOL was released under the GNU General Public License on April 17, 2009.
Structured Product Labeling (xmlFormat, appeared 2004)


Structured Product Labeling (SPL) is a Health Level Seven International (HL7) standard which defines the content of human prescription drug labeling in an XML format.  The "drug label" includes all published material accompanying a drug, such as the actual label on a prescribed dose as well as the package insert which contains a great deal of detailed information about the drug.  As of Release 4 of the SPL standard, 22,000 FDA informational product inserts have been encoded according to the standard.SPL documents contain both the content of labeling (all text, tables and figures) for a product along with additional machine readable information (drug listing data elements). Drug listing data elements include information about the product (product and generic names, ingredients, ingredient strengths, dosage forms, routes of administration, appearance, DEA schedule) and the packaging (package quantity and type).
Spline Font Database (application, appeared 2004)




SplineFontDB: 3.0
FontName: Ambrosia
FullName: Ambrosia
FamilyName: Ambrosia
DefaultBaseFilename: Ambrosia-1.0
Weight: Medium
Copyright: Copyright (C) 1995-2000 by George Williams
Comments: This is a funny font.
UComments: "This is a funny font."
FontLog: "Create Jan 2008"
Version: 001.000
ItalicAngle: 0
UnderlinePosition: -133
UnderlineWidth: 20
Ascent: 800
Descent: 200
sfntRevision: 0x00078106
WidthSeparation: 140
LayerCount: 4
Layer: 0 0 "Back" 1
Layer: 1 1 "Fore" 0
Layer: 2 0 "Cubic_Fore" 0
Layer: 3 0 "Test" 1
DisplaySize: -24
DisplayLayer: 1
AntiAlias: 1
WinInfo: 64 16 4
FitToEm: 1
UseUniqueID: 0
UseXUID: 1
XUID: 3 18 21
Encoding: unicode
Order2: 1
OnlyBitmaps: 0
MacStyle: 0
TeXData: 1 10485760 0 269484 134742 89828 526385 1048576 89828
CreationTime: 1151539072
ModificationTime: 11516487392
GaspTable 3 8 2 16 1 65535 3 0
DEI: 91125
ExtremaBound: 30
Split-C (pl, appeared 1995)


Split-C is a parallel extension of the C programming language. The Split-C project website describes Split-C as:  a parallel extension of the C programming language that supports efficient access to a global address space on current distributed memory multiprocessors. It retains the "small language" character of C and supports careful engineering and optimization of programs by providing a simple, predictable cost model. Development of Split-C appears to be at a standstill since 1996.  Split-C is similar to Cilk.
spry (pl, appeared 2015)
Also known as: ni
Creators: Göran Krampe
Website: http://sprylang.se/

Spry borrows homoiconicity from Rebol and Lisp, free form syntax from Forth and Rebol, the word of different types from Rebol, good data structure literal support from JavaScript and the general coding experience and style from Smalltalk. It also has a few ideas of its own, like an interesting argument passing mechanism and a relatively novel take on OO.


GitHub description: A Smalltalk and Rebol inspired language implemented as an AST interpreter in Nim

# Let's add a method to:do: that works as in Smalltalk.
# Methods take the first argument, the "receiver", from the left
# and binds it to "self".
to:do: = method [:to :block
  n = self
  [n <= to] whileTrue: [
    do block n
    ..n = (n + 1)]]

# Then we can loop in Smalltalk style echoing 1 to 5!
1 to: 5 do: [echo :x]

# We can similarly implement select: from Smalltalk
select: = method [:pred
  result = ([] clone)
  self reset
  [self end?] whileFalse: [
    n = (self next)
    do pred n then: [result add: n]]
  ^result]

# Then use it to produce [3 4]
echo ([1 2 3 4] select: [:x > 2])
SPSS (pl, appeared 1968)
Country: United States
Website: https://www.ibm.com/us-en/marketplace/spss-statistics


SPSS Statistics is a software package used for logical batched and non-batched statistical analysis. Long produced by SPSS Inc., it was acquired by IBM in 2009. The current versions (2015) are officially named IBM SPSS Statistics. Companion products in the same family are used for survey authoring and deployment (IBM SPSS Data Collection, now divested under UNICOM Intelligence), data mining (IBM SPSS Modeler), text analytics, and collaboration and deployment (batch and automated scoring services). The software name originally stood for Statistical Package for the Social Sciences (SPSS), reflecting the original market, although the software is now popular in other fields as well, including the health sciences and marketing.
Spyder (editor, appeared 2009)


Spyder is an open source cross-platform integrated development environment (IDE) for scientific programming in the Python language. Spyder integrates with a number of prominent packages in the scientific Python stack, including NumPy, SciPy, Matplotlib, pandas, IPython, SymPy and Cython, as well as other open source software. It is released under the MIT license.Initially created and developed by Pierre Raybaut in 2009, since 2012 Spyder has been maintained and continuously improved by a team of scientific Python developers and the community. Spyder is extensible with first- and third-party plugins, includes support for interactive tools for data inspection and embeds Python-specific code quality assurance and introspection instruments, such as Pyflakes, Pylint and Rope. It is available cross-platform through Anaconda, on Windows with WinPython and Python (x,y), on macOS through MacPorts, and on major Linux distributions such as Arch Linux, Debian, Fedora, Gentoo Linux, openSUSE and Ubuntu.Spyder uses Qt for its GUI, and is designed to use either of the PyQt or PySide Python bindings. QtPy, a thin abstraction layer developed by the Spyder project and later adopted by multiple other packages, provides the flexibility to use either backend.