pldb/PLDB huggingface dataset:
Sweet Expressions (dataNotation, appeared 2013)
Creators: David A. Wheeler
Alan Manuel K. Gloria
Website: https://srfi.schemers.org/srfi-110/srfi-110.html

This SRFI describes a set of syntax extensions for Scheme, called sweet-expressions (t-expressions), that has the same descriptive power as s-expressions but is designed to be easier for humans to read.



define fibfast(n)   ; Typical function notation
  if {n < 2}        ; Indentation, infix {...}
     n              ; Single expr = no new list
     fibup n 2 1 0  ; Simple function calls
SWI Prolog (pl, appeared 1987)
Website: http://www.swi-prolog.org/


SWI-Prolog is a free implementation of the programming language Prolog, commonly used for teaching and semantic web applications. It has a rich set of features, libraries for constraint logic programming, multithreading, unit testing, GUI, interfacing to Java, ODBC and others, literate programming, a web server, SGML, RDF, RDFS, developer tools (including an IDE with a GUI debugger and GUI profiler), and extensive documentation. SWI-Prolog runs on Unix, Windows, Macintosh and Linux platforms. SWI-Prolog has been under continuous development since 1987. Its main author is Jan Wielemaker. The name SWI is derived from Sociaal-Wetenschappelijke Informatica ("Social Science Informatics"), the former name of the group at the University of Amsterdam, where Wielemaker is employed. The name of this group has changed to HCS (Human-Computer Studies).

GitHub description: SWI-Prolog Main development repository
SIL (ir, appeared 2012)
Stands for: Swift Intermediate Language
Origin: Apple
Website: https://github.com/apple/swift/blob/master/docs/SIL.rst
File extensions: sil

SIL is an SSA-form IR with high-level semantic information designed to implement the Swift programming language. In contrast to LLVM IR, SIL is a generally target-independent format representation that can be used for code distribution, but it can also express target-specific concepts as well as LLVM can.



// SIL is reliant on Swift's type system and declarations, so SIL syntax is an extension of Swift's. A .sil file is a Swift source file with added SIL definitions. The Swift source is parsed only for its declarations; Swift func bodies (except for nested declarations) and top-level code are ignored by the SIL parser. In a .sil file, there are no implicit imports; the swift and/or Builtin standard modules must be imported explicitly if used.
sil_stage canonical

import Swift

// Define types used by the SIL function.

struct Point {
  var x : Double
  var y : Double
}

class Button {
  func onClick()
  func onMouseDown()
  func onMouseUp()
}

// Declare a Swift function. The body is ignored by SIL.
func taxicabNorm(_ a:Point) -> Double {
  return a.x + a.y
}

// Define a SIL function.
// The name @_T5norms11taxicabNormfT1aV5norms5Point_Sd is the mangled name
// of the taxicabNorm Swift function.
sil @_T5norms11taxicabNormfT1aV5norms5Point_Sd : $(Point) -> Double {
bb0(%0 : $Point):
  // func Swift.+(Double, Double) -> Double
  %1 = function_ref @_Tsoi1pfTSdSd_Sd
  %2 = struct_extract %0 : $Point, #Point.x
  %3 = struct_extract %0 : $Point, #Point.y
  %4 = apply %1(%2, %3) : $(Double, Double) -> Double
  return %4 : Double
}

// Define a SIL vtable. This matches dynamically-dispatched method
// identifiers to their implementations for a known static class type.
sil_vtable Button {
  #Button.onClick: @_TC5norms6Button7onClickfS0_FT_T_
  #Button.onMouseDown: @_TC5norms6Button11onMouseDownfS0_FT_T_
  #Button.onMouseUp: @_TC5norms6Button9onMouseUpfS0_FT_T_
}
Swift (pl, appeared 2014)
Creators: Chris Lattner
Origin: Apple
Website: https://swift.org
File extensions: swift
Keywords: associatedtype
class
deinit
enum
extension
func
import
init
inout
internal
let
operator
private
protocol
public
static
struct
subscript
typealias
var
break
case
continue
default
defer
do
else
fallthrough
for
guard
if
in
repeat
return
switch
where
while
as
catch
dynamicType
false
is
nil
rethrows
super
self
Self
throw
throws
true
try
#column
#file
#function
#line
#available
#column
#else#elseif
#endif
#file
#function
#if
#line
#selector
associativity
convenience
dynamic
didSet
final
get
infix
indirect
lazy
left
mutating
none
nonmutating
optional
override
postfix
precedence
prefix
Protocol
required
right
set
Type
unowned
weak
willSet


Swift is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. for iOS, macOS, watchOS, tvOS, and Linux. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and the large body of existing Objective-C (ObjC) code written for Apple products. It is built with the open source LLVM compiler framework and has been included in Xcode since version 6. On platforms other than Linux, it uses the Objective-C runtime library which allows C, Objective-C, C++ and Swift code to run within one program. Apple intended Swift to support many core concepts associated with Objective-C, notably dynamic dispatch, widespread late binding, extensible programming and similar features, but "safer" (easier to catch software bugs); Swift has features addressing some common programming errors like null pointers and provides syntactic sugar to help avoid the pyramid of doom. Swift supports the concept of protocol extensibility, an extensibility system that can be applied to types, structs and classes, which Apple promotes as a real change in programming paradigms they term "protocol-oriented programming" (similar to traits). Swift was introduced at Apple's 2014 Worldwide Developers Conference (WWDC). It underwent an upgrade to version 1.2 during 2014 and a more major upgrade to Swift 2 at WWDC 2015. Initially a proprietary language, version 2.2 was made open-source software under the Apache License 2.0 on December 3, 2015, for Apple's platforms and Linux. In March 2017, Swift made the top 10 in the monthly TIOBE index ranking of popular programming languages, while since then it slipped down the list to 20.

GitHub description: The Swift Programming Language
swizzle (esolang, appeared 2018)
Creators: Robert Swierczek



GitHub description: An esoteric programming language

{M
    1=i
    (i 100 <=?
        (i 15 % 0 ==?
            "FizzBuzz" P;
        :(i 3 % 0 ==?
            "Fizz" P;
        :(i 5 % 0 ==?
            "Buzz" P;
        :
            i "%d" P;;
        )))
        10 "%c" P;;
        i++;
    @)
}
M
Semantic Web Rule Language (xmlFormat, appeared 2004)
Stands for: Semantic Web Rule Language


The Semantic Web Rule Language (SWRL) is a proposed language for the Semantic Web that can be used to express rules as well as logic, combining OWL DL or OWL Lite with a subset of the Rule Markup Language (itself a subset of Datalog).The specification was submitted in May 2004 to the W3C by the National Research Council of Canada, Network Inference (since acquired by webMethods), and Stanford University in association with the Joint US/EU ad hoc Agent Markup Language Committee. The specification was based on an earlier proposal for an OWL rules language.SWRL has the full power of OWL DL, but at the price of decidability and practical implementations. However, decidability can be regained by restricting the form of admissible rules, typically by imposing a suitable safety condition.Rules are of the form of an implication between an antecedent (body) and consequent (head). The intended meaning can be read as: whenever the conditions specified in the antecedent hold, then the conditions specified in the consequent must also hold.


<ruleml:imp> 
 <ruleml:_rlab ruleml:href="#example1"/>
 <ruleml:_body> 
   <swrlx:individualPropertyAtom  swrlx:property="hasParent"> 
     <ruleml:var>x1</ruleml:var>
     <ruleml:var>x2</ruleml:var>
   </swrlx:individualPropertyAtom> 
   <swrlx:individualPropertyAtom  swrlx:property="hasBrother"> 
     <ruleml:var>x2</ruleml:var>
     <ruleml:var>x3</ruleml:var>
   </swrlx:individualPropertyAtom> 
 </ruleml:_body> 
 <ruleml:_head> 
   <swrlx:individualPropertyAtom  swrlx:property="hasUncle"> 
     <ruleml:var>x1</ruleml:var>
     <ruleml:var>x3</ruleml:var>
   </swrlx:individualPropertyAtom> 
 </ruleml:_head> 
</ruleml:imp>
SYMBOL (pl, appeared 1971)


A symbol is a mark, sign  or word that indicates, signifies, or is understood as representing an idea, object, or relationship. Symbols allow people to go beyond what is known or seen by creating linkages between otherwise very different concepts and experiences. All communication (and data processing) is achieved through the use of symbols. Symbols take the form of words, sounds, gestures, ideas or visual images and are used to convey other ideas and beliefs. For example, a red octagon may be a symbol for "STOP". On a map, a blue line might represent a river. Numerals are symbols for numbers. Alphabetic letters may be symbols for sounds. Personal names are symbols representing individuals. A red rose may symbolize love and compassion. The variable 'x', in a mathematical equation, may symbolize the position of a particle in space. In cartography, an organized collection of symbols forms a legend for a map.
SYMBOLIC ASSEMBLY (assembly, appeared 1956)
Origin: IBM


The Symbolic Assembly Program (SAP) is an assembler program for the IBM 704 computer. It was written by Roy Nutt at United Aircraft Corporation, and was distributed by the SHARE user's group beginning in 1956 as the Share Assembly Program. SAP succeeded an earlier program called NYAP1 (New York Assembly Program 1), which it closely resembled, and became the standard assembler for 704 users. It "set the external form of an assembly language that was to be a model for all its successors and which persists almost unchanged to the present day."
SYMPL (pl, appeared 1970)
Country: United States


SYMPL is an obsolete programming language developed by the Control Data Corporation (CDC) for use on the CDC 6000 series computer systems in the 1970s and 1980s.  It was based on a subset of CDCs version of JOVIAL, as an alternative to assembly language.  A number of important CDC software products were implemented in SYMPL, including compilers, libraries, a full-screen editor, and major subsystems. SYMPL is a compiled, imperative, and procedural language.  Compared to the Fortran of the day, SYMPL supports:  Stronger data typing - All variables must be declared prior to use, Data structures - Including "based" dynamically allocated structures, Structured programming constructs, Nested procedures, In-fix "bead" (bit) and character manipulation A simple macro facilitySimplifications compared to JOVIAL include: fewer built-in data types, no recursive calls to procedures, and no COMPOOL concept.
SYNAPSE (pl, appeared 1990)


SyNAPSE is a DARPA program that aims to develop electronic neuromorphic machine technology, an attempt to build a new kind of cognitive computer with form, function, and architecture similar to the mammalian brain.  Such artificial brains would be used in robots whose intelligence would scale with the size of the neural system in terms of total number of neurons and synapses and their connectivity. SyNAPSE is a backronym standing for Systems of Neuromorphic Adaptive Plastic Scalable Electronics. The name alludes to synapses, the junctions between biological neurons. The program is being undertaken by HRL Laboratories (HRL), Hewlett-Packard, and IBM Research.  In November 2008, IBM and its collaborators were awarded $4.9 million in funding from DARPA while HRL and its collaborators were awarded $5.9 million in funding from DARPA.  For the next phase of the project, DARPA added $16.1 million more to the IBM effort while HRL received an additional $10.7 million. In 2011, DARPA added $21 million more to the IBM project. and an additional $17.9 million to the HRL project. The SyNAPSE team for IBM is led by Dharmendra Modha, manager of IBM's cognitive computing initiative. The SyNAPSE team for HRL is led by Narayan Srinivasa, manager of HRL's Center for Neural and Emergent Systems.The initial phase of the SyNAPSE program developed nanometer scale electronic synaptic components capable of adapting the connection strength between two neurons in a manner analogous to that seen in biological systems (Hebbian learning), and simulated the utility of these synaptic components in core microcircuits that support the overall system architecture. Continuing efforts will focus on hardware development through the stages of microcircuit development, fabrication process development, single chip system development, and multi-chip system development. In support of these hardware developments, the program seeks to develop increasingly capable architecture and design tools, very large-scale computer simulations of the neuromorphic electronic systems to inform the designers and validate the hardware prior to fabrication, and virtual environments for training and testing the simulated and hardware neuromorphic systems.
SMIL (pl, appeared 1997)


Synchronized Multimedia Integration Language (SMIL ()) is a World Wide Web Consortium recommended Extensible Markup Language (XML) markup language to describe multimedia presentations. It defines markup for timing, layout, animations, visual transitions, and media embedding, among other things. SMIL allows presenting media items such as text, images, video, audio, links to other SMIL presentations, and files from multiple web servers. SMIL markup is written in XML, and has similarities to HTML.
SysML (pl, appeared 2000)
Stands for: Systems Modeling Language


The Systems Modeling Language (SysML) is a general-purpose modeling language for systems engineering applications. It supports the specification, analysis, design, verification and validation of a broad range of systems and systems-of-systems. SysML was originally developed by an open source specification project, and includes an open source license for distribution and use. SysML is defined as an extension of a subset of the Unified Modeling Language (UML) using UML's profile mechanism.
System V ABI (binaryExecutable, appeared 1983)
Also known as: SysV ABI

An example of a symbol table can be found in the SysV Application Binary Interface (ABI) specification, which mandates how symbols are to be laid out in a binary file, so that different compilers, linkers and loaders can all consistently find and work with the symbols in a compiled object.



Address  Type  Name
00000020  a T_BIT
00000040  a F_BIT
00000080  a I_BIT
20000004  t irqvec
20000008  t fiqvec
2000000c  t InitReset
SystemVerilog (pl, appeared 2002)
Origin: Synopsys
Keywords: accept_on
alias
always
always_comb
always_ff
always_latch
and
assert
assign
assume
automatic
before
begin
bind
bins
binsof
bit
break
buf
bufif0
bufif1
byte
case
casex
casez
cell
chandle
checker
class
clocking
cmos
config
const
constraint
context
continue
cover
covergroup
coverpoint
cross
deassign
default
defparam
design
disable
dist
do
edge
else
end
endcase
endchecker
endclass
endclocking
endconfig
endfunction
endgenerate
endgroup
endinterface
endmodule
endpackage
endprimitive
endprogram
endproperty
endspecify
endsequence
endtable
endtask
enum
event
eventually
expect
export
extends
extern
final
first_match
for
force
foreach
forever
fork
forkjoin
function
generate
genvar
global
highz0
highz1
if
iff
ifnone
ignore_bins
illegal_bins
implements
implies
import
incdir
include
initial
inout
input
inside
instance
int
integer
interconnect
interface
intersect
join
join_any
join_none
large
let
liblist
library
local
localparam
logic
longint
macromodule
matches
medium
modport
module
nand
negedge
nettype
new
nexttime
nmos
nor
noshowcancelled
not
notif0
notif1
null
or
output
package
packed
parameter
pmos
posedge
primitive
priority
program
property
protected
pull0
pull1
pulldown
pullup
pulsestyle_ondetect
pulsestyle_onevent
pure
rand
randc
randcase
randsequence
rcmos
real
realtime
ref
reg
reject_on
release
repeat
restrict
return
rnmos
rpmos
rtran
rtranif0
rtranif1
s_always
s_eventually
s_nexttime
s_until
s_until_with
scalared
sequence
shortint
shortreal
showcancelled
signed
small
soft
solve
specify
specparam
static
string
strong
strong0
strong1
struct
super
supply0
supply1
sync_accept_on
sync_reject_on
table
tagged
task
this
throughout
time
timeprecision
timeunit
tran
tranif0
tranif1
tri
tri0
tri1
triand
trior
trireg
type
typedef
union
unique
unique0
unsigned
until
until_with
untyped
use
uwire
var
vectored
virtual
void
wait
wait_order
wand
weak
weak0
weak1
while
wildcard
wire
with
within
wor
xnor
xor


SystemVerilog, standardized as IEEE 1800, is a hardware description and hardware verification language used to model, design, simulate, test and implement electronic systems. SystemVerilog is based on Verilog and some extensions, and since 2008 Verilog is now part of the same IEEE standard. It is commonly used in the semiconductor and electronic design industry as an evolution of Verilog.
IBM System z (computingMachine, appeared 2000)


IBM System z (officially "IBM z Systems") is a family name used by IBM for all of its mainframe computers. In 2000, IBM renamed the existing System/390 to IBM eServer zSeries with the e depicted in IBM's red trademarked symbol, but because no specific machine names were changed for System/390, the zSeries name in common use refers only to the z900 and z990 generations of mainframes. In April 2006, with another generation of products, the official family was changed to IBM System z, which now includes both older IBM eServer zSeries models, the IBM System z9 models, the IBM System z10 models, and the newer IBM zEnterprise models. The IBM z13 is the last z Systems server to support running an operating system in ESA/390 architecture mode.
T (pl, appeared 1980)
Country: United States


The T programming language is a dialect of the Scheme programming language developed in the early 1980s by Jonathan A. Rees, Kent M. Pitman, and Norman I. Adams of Yale University as an experiment in language design and implementation. T's purpose is to test the thesis developed by Steele and Sussman in their series of papers about Scheme: that Scheme may be used as the basis for a practical programming language of exceptional expressive power, and that implementations of Scheme could perform better than other Lisp systems, and competitively with implementations of programming languages, such as C and BLISS, which are usually considered to be inherently more efficient than Lisp on conventional machine architectures. In 1987 Stephen Slade published the book "The T Programming Language: A Dialect of LISP". T contains some features that modern Scheme does not have. For example, T is object-oriented, and it has first-class environments, called locales, which can be modified non-locally and used as a module system. T has several extra special forms for lazy evaluation and flow control, as well as an equivalent to Common Lisp's setf. T, like Scheme, supports call-with-current-continuation, but it also has a more limited form called catch. From the T manual, a hypothetical implementation of cons could be:  Through this example, we can see that objects in T are intimately related to closures and message-passing. A primitive called join puts two objects together, allowing for something resembling inheritance.
tablatal (pl, appeared 2017)
Website: https://wiki.xxiivv.com/#tablatal

This space-sensitive database format is designed to store a list of elements of the same length, accessible by id. The parser is 30 lines long, and allows for human-readable data structures for static sites such as Oscean, also see Indental. In the Tablatal file, the first line declares the key, the spacing between each key defines the length of the parameters for all subsequent lines.



NAME    AGE   COLOR
Erica   12    Opal
Alex    23    Cyan
Nike    34    Red
Ruca    45    Grey
Or, [{name:Erica,Age:12,Color:Blue},{name:Alex,Age..}
Tableau Software (application, appeared 2003)
Website: https://www.tableau.com/


Tableau Software ( tab-LOH) is an interactive data visualization software company founded on January 2003 by Christian Chabot, Pat Hanrahan and Chris Stolte, in Mountain View, California. The company is currently headquartered in Seattle, Washington, United States  focused on business intelligence. On June 10, 2019,  Salesforce.com announced it would be acquiring Tableau.Chabot, Hanrahan and Stolte were researchers at the Department of Computer Science at Stanford University  who specialized in visualization techniques for exploring and analyzing relational databases and data cubes. The company was started as a commercial outlet for research produced at Stanford between 1999-2002.  Tableau products query relational databases, online analytical processing cubes, cloud databases, and spreadsheets to generate graph-type data visualizations. The products can also extract, store, and retrieve data from an in-memory data engine.
taf (pl, appeared 2012)
Creators: Manuel Simoni

A Lisp with row polymorphism, delimited continuations, and hygienic macros. [vaporware]


GitHub description: A Lisp with row polymorphism, delimited continuations, and hygienic macros. [vaporware]

(define (make-person name email)
  #(person :name name :email email)) ; creates a person record with name and email fields

(define-generic (to-string obj))
(define-method (to-string (obj #(person :name :email))) ; matches persons and binds name and email field to local variables
  (concat (list name " <" email ">")))

(to-string (make-person "Manuel" "msimoni@gmail.com"))
; ==> "Manuel <msimoni@gmail.com>"
Tahoe-LAFS (filesystem, appeared 2007)


Tahoe-LAFS (Tahoe Least-Authority File Store) is a free and open, secure, decentralized, fault-tolerant, distributed data store and distributed file system. It can be used as an online backup system, or to serve as a file or Web host similar to Freenet, depending on the front-end used to insert and access files in the Tahoe system. Tahoe can also be used in a RAID-like fashion using multiple disks to make a single large Redundant Array of Inexpensive Nodes (RAIN) pool of reliable data storage. The system is designed and implemented around the "principle of least authority" (POLA). Strict adherence to this convention is enabled by the use of cryptographic capabilities that provide the minimum set of privileges necessary to perform a given task by asking agents. A RAIN array acts as a storage volume; these servers do not need to be trusted by confidentiality or integrity of the stored data.
Taichi (pl, appeared 2019)
Creators: Yuanming Hu
Website: https://taichi-lang.org/

Taichi Lang is an open-source, imperative, parallel programming language for high-performance numerical computation. It is embedded in Python and uses just-in-time (JIT) compiler frameworks, for example LLVM, to offload the compute-intensive Python code to the native GPU or CPU instructions.


GitHub description: Productive & portable high-performance programming in Python.

// For CPU
Parallelize(int num_threads) // Multi-threading
Vectorize(int width) // Loop vectorization
// For GPU
BlockDim(int blockDim) // Specify GPU block size
// For scratchpad optimization
AssumeInRange(Expr base, int lower, int upper)
Cache(Expr)
// Cache data into GPU L1 cache
CacheL1(Expr)
More discussions on h