pldb/PLDB huggingface dataset:
Stockholm format (textDataFormat, appeared 1997)


Stockholm format is a multiple sequence alignment format used by Pfam and Rfam to disseminate protein and RNA sequence alignments. The alignment editors Ralee  and Belvu support Stockholm format as do the probabilistic database search tools, Infernal and HMMER, and the phylogenetic analysis tool Xrate. A simple example of an Rfam alignment (UPSK RNA) with a pseudoknot in Stockholm format is shown below: # STOCKHOLM 1.0 #=GF ID    UPSK #=GF SE    Predicted; Infernal  #=GF SS    Published; PMID 9223489 #=GF RN    [1] #=GF RM    9223489 #=GF RT    The role of the pseudoknot at the 3' end of turnip yellow mosaic #=GF RT    virus RNA in minus-strand synthesis by the viral RNA-dependent RNA #=GF RT    polymerase. #=GF RA    Deiman BA, Kortlever RM, Pleij CW; #=GF RL    J Virol 1997;71:5990-5996.  AF035635.1/619-641             UGAGUUCUCGAUCUCUAAAAUCG M24804.1/82-104                UGAGUUCUCUAUCUCUAAAAUCG J04373.1/6212-6234             UAAGUUCUCGAUCUUUAAAAUCG M24803.1/1-23                  UAAGUUCUCGAUCUCUAAAAUCG #=GC SS_cons                   .AAA....<<<<aaa....>>>> //  Here is a slightly more complex example showing the Pfam CBS domain:  # STOCKHOLM 1.0 #=GF ID CBS #=GF AC PF00571 #=GF DE CBS domain #=GF AU Bateman A #=GF CC CBS domains are small intracellular modules mostly found #=GF CC in 2 or four copies within a protein. #=GF SQ 5 #=GS O31698/18-71 AC O31698 #=GS O83071/192-246 AC O83071 #=GS O83071/259-312 AC O83071 #=GS O31698/88-139 AC O31698 #=GS O31698/88-139 OS Bacillus subtilis O83071/192-246          MTCRAQLIAVPRASSLAEAIACAQKMRVSRVPVYERS #=GR O83071/192-246 SA  9998877564535242525515252536463774777 O83071/259-312          MQHVSAPVFVFECTRLAYVQHKLRAHSRAVAIVLDEY #=GR O83071/259-312 SS  CCCCCHHHHHHHHHHHHHEEEEEEEEEEEEEEEEEEE O31698/18-71            MIEADKVAHVQVGNNLEHALLVLTKTGYTAIPVLDPS #=GR O31698/18-71 SS    CCCHHHHHHHHHHHHHHHEEEEEEEEEEEEEEEEHHH O31698/88-139           EVMLTDIPRLHINDPIMKGFGMVINN..GFVCVENDE #=GR O31698/88-139 SS   CCCCCCCHHHHHHHHHHHHEEEEEEEEEEEEEEEEEH #=GC SS_cons            CCCCCHHHHHHHHHHHHHEEEEEEEEEEEEEEEEEEH O31699/88-139           EVMLTDIPRLHINDPIMKGFGMVINN..GFVCVENDE #=GR O31699/88-139 AS   ________________*____________________ #=GR O31699/88-139 IN   ____________1____________2______0____ //  A minimal well formed Stockholm files should contain the header which states the format and version identifier, currently '# STOCKHOLM 1.0'. Followed by the sequences and corresponding unique sequence names:  <seqname> <aligned sequence> <seqname> <aligned sequence> <seqname> <aligned sequence>  '<seqname>' stands for "sequence name", typically in the form "name/start-end" or just "name". Finally, the "//" line indicates the end of the alignment. Sequence letters may include any characters except whitespace. Gaps may be indicated by "." or "-".
StoneCutter (grammarLanguage, appeared 2020)
Creators: John D. Leidel
David Donofrio
Frank Conlon

In this work we introduce the StoneCutter instruction set design language and tool infrastructure. StoneCutter provides a familiar, C-like language construct by which to develop the implementation for individual, programmable instructions. The LLVM-based StoneCutter compiler performs individual instruction and whole-ISA optimizations in order to generate a high performance, Chisel HDL representation of the target design. Utilizing the existing Chisel tools, users can also generate C++ cycle accurate simulation models as well as Verilog representations of the target design. As a result, StoneCutter provides a very rapid design environment for development and experimentation.
stoneknifeforth (pl, appeared 2008)

This is StoneKnifeForth, a very simple language inspired by Forth. It is not expected to be useful; instead, its purpose is to show how simple a compiler can be. The compiler is a bit under two pages of code when the comments are removed. This package includes a “metacircular compiler” which is written in StoneKnifeForth and compiles StoneKnifeForth to an x86 Linux ELF executable.


GitHub description: a tiny self-hosted Forth implementation
storyscript (pl, appeared 2017)
Website: https://storyscript.com

Storyscript is a language, editor, database, infra and community all-in-one. Create holistic apps, tools and workflows blazing fast that power your business.


GitHub description: The polyglot, cloud-native programming language for zero-devops deployments into Kubernetes.

### 
Storyscript is a language, editor, database, infra and community all-in-one.
Create holistic apps, tools and workflows blazing fast that power your business. 
###


# Pull data from a microservice
output = service action key:value
output = team/service action key:value
# Discover and create services in the Storyscript Hub
# Call a function
output = function_name(key:value)
# A Storyscript function
# or another programming language
# Call type methods
output = variable.mutation(key:value)
# Event streaming microservice
when service action event key:value as output
    ... # run this block for every event
# Types
string = "Hello"
integer = 1
number = 1.3
bool = true
list = ["a", "b", "c"]
map = {"apple": "red", "banana": "yellow"}
regexp = /^foobar/
empty = null
time = 1d35m
# Destructuring
{ apple, banana } = map
# apple = "red", banana = "yellow"
# Conditions
if one > 1
    # ...
else if one == 1
    # ...
else
    # ...
# Loops
foreach list as item
    # ...
while true
    # ...
# Functions
function name input:int returns int
    # ...
    return input
name(input:1)
# >>> 1
STOS BASIC (pl, appeared 1988)


STOS BASIC is a dialect of the BASIC programming language implemented on the Atari ST computer. STOS BASIC was originally developed by Jawx, François Lionet, and Constantin Sotiropoulos and published by Mandarin Software (now known as Europress Software). STOS Basic was a version of BASIC that was designed for creating games, but the set of powerful high-level graphics and sound commands it offered made it suitable for developing multimedia-intense software without any knowledge of the internals of the Atari ST.
Stratego/XT (grammarLanguage, appeared 1998)


Stratego/XT is a language and toolset for constructing stand-alone program transformation systems.  It combines the Stratego transformation language with the XT toolset of transformation components, providing a framework for constructing stand-alone program transformation systems. The Stratego language is based on a programming paradigm called strategic term rewriting. It provides rewrite rules for expressing basic transformation steps. The application of these rules can be controlled using strategies, a form of subroutines. The XT toolset provides reusable transformation components and declarative languages for deriving new components, such as parsing grammars using the Modular Syntax Definition Formalism (SDF) and implementing pretty-printing.
Streem (pl, appeared 2014)
Creators: Yukihiro Matsumoto
Origin: Ruby Association,NaCl
Country: Japan
Website: https://github.com/matz/streem
Keywords: case
class
def
else
emit
false
if
import
method
namespace
new
nil
return
skip
true

Streem is a stream based concurrent scripting language. It is based on a programming model similar to the shell, with influences from Ruby, Erlang, and other functional programming languages.



# channel to broadcast to all clients
broadcast = chan()
tcp_server(8008) | {s ->
  broadcast | s   # connect to broadcast channel
  s | broadcast   # broadcast incoming message
}
Strips (pl, appeared 1969)


In artificial intelligence, STRIPS (Stanford Research Institute Problem Solver) is an automated planner developed by Richard Fikes and Nils Nilsson in 1971 at SRI International. The same name was later used to refer to the formal language of the inputs to this planner. This language is the base for most of the languages for expressing automated planning problem instances in use today; such languages are commonly known as action languages. This article only describes the language, not the planner.
Strongtalk (pl, appeared 1994)
Country: United States
Website: http://strongtalk.org/

Strongtalk is a major re-thinking of the Smalltalk-80 programming language and system. While retaining the basic Smalltalk syntax and semantics, it contains a number of significant advances.

Strongtalk is a Smalltalk environment with optional static typing support. Strongtalk can make some compile time checks, and offer "stronger" type safety guarantees; this is the source of its name. It is non-commercial, though it was originally a commercial project developed by a small start-up company called LongView Technologies (trading as Animorphic Systems).
Structured text (pl, appeared 2019)


Structured text, abbreviated as ST or STX, is one of the five languages supported by the IEC 61131-3 standard, designed for programmable logic controllers (PLCs). It is a high level language that is block structured and syntactically resembles Pascal, on which it is based. All of the languages share IEC61131 Common Elements. The variables and function calls are defined by the common elements so different languages within the IEC 61131-3 standard can be used in the same program. Complex statements and nested instructions are supported:  Iteration loops (REPEAT-UNTIL; WHILE-DO) Conditional execution (IF-THEN-ELSE; CASE) Functions (SQRT(), SIN())
strudel (textDataFormat, appeared 2011)

Strudel is our graphical tool for visualizing genetic and physical maps of genomes for comparative purposes. The Strudel data format is tab delimited text with all features, homologs and potential reference URLs included in the same file.



feature  Rice  1 LOC_Os05g01020  gene  1903    "TBC domain containing protein, expressed"
feature Rice  1 LOC_Os09g20010  gene  10218   expressed protein
feature Barley  1H  12_30969  SNP 15    
feature Barley  1H  11_11223  SNP 78    
feature Barley  1H  11_11224  SNP 100   
homolog Barley  12_30969  Rice  LOC_Os05g01020  7.00E-91    #00FF00
homolog Barley  11_11223  Rice  LOC_Os09g20010  6.00E-50    
chromosome  Barley  1H  #593423       
URL Rice  http://rice.plantbiology.msu.edu/cgi-bin/gbrowse/rice/?name=
StruQL (queryLanguage, appeared 1999)
Creators: Mary Fernández
Dan Suciu
and Igor Tatarinov

A StruQL query is a function from a set of input graphs to an output graph.



 // Link root page to page of all accounts
 link Root() -> "Accounts" -> AccountsPage()
 // AccountsPage refers to each account in account database and its associated page
 { where (acct, name, street, city, state, zip) in SQL.query("AccountDB", "select acct ...")
 link AccountsPage() -> "Info" -> Info(acct),
 Info(acct) -> { "Acct" acct, "Name" name, "Street" street,
 "City" city, "State" state, "Zip" zip,
 "AcctPage" AcctPage(acct) },
 AcctPage(acct) -> "Info" -> Info(acct)
 
  // AcctPage refers to non-zero usage records in the usage database.
  { where (date, dom is int, intl is int) in SQL.query("UsageDB", "select date ...", acct)
  dom + intl > 0
  link AcctPage(acct) -> "UsageData" -> UsageData(acct),
  UsageData(acct) -> "Entry" -> UsageEntry(acct, date),
  UsageEntry(acct, date) -> { "Date" date, "Total" (dom + intl) }
  }
  // Query postal database to determine possible aliases for account
  { where XMLRoot{root}, root -> "addresses"."entry" -> addr,
  addr -> { "name" alias, "address"."street" street1, "address"."zip" zip },
  street1 = street
  link Info(acct) -> "Alias" -> alias
  }
  }
Stutter (esolang, appeared 2018)

The design goals of the Stutter Programming Language focus on the underlying idea that Stutter Code is a speakable language that contains no special syntax characters that are unpronounciable.


GitHub description: :book: The Stutter Language Specification and Test Suite

let ratio be a Number and set it to 0.37
let variable be a Number
set variable to 5

comment add is a method on the Number data type
add 12.0 to variable

comment all methods accept multiple parameters via the and conjunction
multiply variable with ratio and 1.5

comment results of methods can be redirected with the to preposition
print variable to standard output

comment generic calls can be done with the call verb
call log on console with variable and ratio


if variable is greater than 2 then

 if variable is greater than 2.5 then
   call log on console with this is an example
 else if variable is lower than 2.5 then
   call alert on console with this is another example
 else
   call log on console with foo bar
 end

end


let examples be a Number Array
set examples to 1, 3, 7 and 9

set index 0 on examples to 4
push 3 to examples


comment whatever is the string representation of examples
let whatever be a String
join examples to whatever

comment copy is the string copy of examples
let copy be a String Array
split whatever to copy


for each examples as key and value do

 let temp be value
 add 5 to value
 divide value by 1.76

 if temp is greater than 5 then
   break
 else
   call log on console with temp
 end

end
stx (pl, appeared 1999)
Website: https://www.kfs.oeaw.ac.at/manual/3.8/html/programmerguide/1687.htm

STx implements a powerful scripting language. This document will try to give you the necessary information to program your own applications. Scripts can be used to implement: simple processing lists, calling standard STx signal processing applications, signal processing application (like the Spectrogram & Parameters Viewer), complex database operations on the STx DataSet, in fact, everything you see in STx can be programmed in the macro language. The term STx script is a synonym for an application implemented using one or more STx macros, classes and SPU's, and executed by the script controller application BScript.
Stylus (stylesheetLanguage, appeared 2010)
Creators: TJ Holowaychuk
Website: http://stylus-lang.com/


Stylus is a dynamic stylesheet language that is compiled into Cascading Style Sheets (CSS). Its design is influenced by Sass and LESS. It's regarded as the fourth most used CSS preprocessor syntax. It was created by TJ Holowaychuk, a former programmer for Node.js and the creator of the Luna language. It is written in JADE and Node.js.
Sublime Syntax Test Lang (grammarLanguage, appeared 2008)
Website: https://www.sublimetext.com/docs/3/syntax.html#testing

A language for testing sublime syntax files.



// SYNTAX TEST "Packages/C/C.sublime-syntax"
#pragma once
// <- source.c meta.preprocessor.c++
 // <- keyword.control.import

// foo
// ^ source.c comment.line
// <- punctuation.definition.comment

/* foo */
// ^ source.c comment.block
// <- punctuation.definition.comment.begin
//     ^ punctuation.definition.comment.end

#include "stdio.h"
// <- meta.preprocessor.include.c++
//       ^ meta string punctuation.definition.string.begin
//               ^ meta string punctuation.definition.string.end
int square(int x)
// <- storage.type
//  ^ meta.function entity.name.function
//         ^ storage.type
{
    return x * x;
//  ^^^^^^ keyword.control
}

"Hello, World! // not a comment";
// ^ string.quoted.double
//                  ^ string.quoted.double - comment
Sublime Syntax (grammarLanguage, appeared 2008)
Website: https://www.sublimetext.com/docs/3/syntax.html
File extensions: sublime-syntax

Sublime Syntax files are YAML files with a small header, followed by a list of contexts. Each context has a list of patterns that describe how to highlight text in that context, and how to change the current text.



%YAML 1.2
---
name: C
file_extensions: [c, h]
scope: source.c

contexts:
  main:
    - match: \b(if|else|for|while)\b
      scope: keyword.control.c
Subtext (pl, appeared 2005)
Website: http://www.subtext-lang.org/


Subtext is a moderately visual programming language and environment, for writing application software. It is an experimental, research attempt to develop a new programming model, called Example Centric Programming, by treating copied blocks as first class prototypes, for program structure. It uses live text, similar to what occurs in spreadsheets as users update cells, for frequent feedback. It is intended to eventually be developed enough to become a practical language for daily use. It is planned to be open software; the license is not yet determined. Subtext was created by Jonathan Edwards who submitted a paper on the language to OOPSLA. It was accepted as part of the 2005 conference.
Subversion (application, appeared 2000)
Origin: Apache
Website: http://subversion.apache.org/


Apache Subversion (often abbreviated SVN, after its command name svn) is a software versioning and revision control system distributed as open source under the Apache License. Software developers use Subversion to maintain current and historical versions of files such as source code, web pages, and documentation. Its goal is to be a mostly compatible successor to the widely used Concurrent Versions System (CVS). The open source community has used Subversion widely: for example in projects such as Apache Software Foundation, Free Pascal, FreeBSD, GCC and SourceForge. CodePlex offers access to Subversion as well as to other types of clients. Subversion was created by CollabNet Inc. in 2000, and is now a top-level Apache project being built and used by a global community of contributors.
SubX (assembly, appeared 2019)
Creators: Kartik K. Agaram
File extensions: subx

Author of Mu decided this year to switch implementation from C++ to his own x86 assembler subset named SubX.



# 0x20-0x7e: basic latin
# 0x20 = space
  08/size
  00/is-combine
  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Sugar (pl, appeared 2006)
Creators: Sébastien Pierre
Country: New Zealand
Website: https://github.com/sebastien/sugar/blob/master/Documentation/sugar-quickref.pdf
File extensions: sjs

Makes JavaScript development sweeter !


GitHub description: Makes JavaScript development sweeter !

   @module helloworld
   @class HelloWorld
   | This is a docstring for my hello world
       @property message
       @constructor
           message = "Hello, World !"
       @end
       @method say
           alert ( message )
       @end
   @end
Sun Raster (binaryDataFormat, appeared 1989)
File extensions: sun
ras


Sun Raster was a raster graphics file format used on SunOS by Sun Microsystems. The format has no MIME type, it is specified in @(#)rasterfile.h 1.11 89/08/21 SMI. The format was used for some research papers.ACDSee, FFmpeg, GIMP, ImageMagick, IrfanView, LibreOffice, Netpbm, PaintShop Pro, and XnView among others support Sun Raster image files. In version 2.13 XnView supported the file extensions .ras and .sun for this graphics file format. In version 2.1.4 FFmpeg could encode and decode Sun Raster pixel formats bgr24, pal8, gray, and monow. The format does not support transparency. The plain text Sun icon format specified in @(#)icon_load.h 10.5 89/09/05 SMI is unrelated to the Sun Raster format.
SuperBASIC (pl, appeared 1984)


SuperBASIC is an advanced variant of the BASIC programming language with many structured programming additions. It was developed at Sinclair Research by Jan Jones during the early 1980s. Originally SuperBASIC was intended for a home computer, code-named SuperSpectrum, then under development. This project was later cancelled; however, SuperBASIC was subsequently included in the ROM firmware of the Sinclair QL microcomputer (announced in January 1984), also serving as the command line interpreter for the QL's Qdos operating system. It is notable for being the first second-generation BASIC to be integrated into a microcomputer's operating system, so making the latter user-extendable—as exemplified by Linus Torvalds in his formative years.
SuperCollider (pl, appeared 1996)
Website: http://supercollider.github.io


SuperCollider is an environment and programming language originally released in 1996 by James McCartney for real-time audio synthesis and algorithmic composition. Since then it has been evolving into a system used and further developed by both scientists and artists working with sound. It is an efficient and expressive dynamic programming language providing a framework for acoustic research, algorithmic music, interactive programming and live coding. Released under the terms of the GPLv2 in 2002, SuperCollider is free and open-source software.
Superjson (dataNotation, appeared 2014)
Creators: Matthew Mueller

A superset of JSON adding: undefined bigint Date RegExp Set Map Error


GitHub description: Safely serialize JavaScript expressions to a superset of JSON, which includes Dates, BigInts, and more.

const object = {
  normal: 'string',
  timestamp: new Date(),
  test: /superjson/,
};

const { json, meta } = serialize(object);
Svelte (pl, appeared 2019)
Creators: Rich Harris
Website: https://svelte.dev/

Svelte is a radical new approach to building user interfaces. Whereas traditional frameworks like React and Vue do the bulk of their work in the browser, Svelte shifts that work into a compile step that happens when you build your app. Instead of using techniques like virtual DOM diffing, Svelte writes code that surgically updates the DOM when the state of your app changes.


GitHub description: Cybernetically enhanced web apps

<script>
 let name = 'world';
</script>

<h1>Hello {name}!</h1>
SVG (textMarkup, appeared 2001)
Stands for: Scalable Vector Graphics
Origin: W3C


Scalable Vector Graphics (SVG) is an XML-based vector image format for two-dimensional graphics with support for interactivity and animation. The SVG specification is an open standard developed by the World Wide Web Consortium (W3C) since 1999. SVG images and their behaviors are defined in XML text files. This means that they can be searched, indexed, scripted, and compressed. As XML files, SVG images can be created and edited with any text editor, as well as with drawing software. All major modern web browsers—including Mozilla Firefox, Internet Explorer, Google Chrome, Opera, Safari, and Microsoft Edge—have SVG rendering support.
Swagger (framework, appeared 2011)
Website: http://swagger.io


Swagger is an open source software framework backed by a large ecosystem of tools that helps developers design, build, document, and consume RESTful Web services. While most users identify Swagger by the Swagger UI tool, the Swagger toolset includes support for automated documentation, code generation, and test case generation. Sponsored by SmartBear Software, Swagger has been a strong supporter of Open Source Software and has widespread adoption.
Sweave (template, appeared 2002)
File extensions: rnw


Sweave is a function in the statistical programming language R that enables integration of R code into LaTeX or LyX documents. The purpose is "to create dynamic reports, which can be updated automatically if data or analysis change".The data analysis is performed at the moment of writing the report, or more exactly, at the moment of compiling the Sweave code with Sweave (i.e., essentially with R) and subsequently with LaTeX. This can facilitate the creation of up-to-date reports for the author. Because the Sweave files together with any external R files that might be sourced from them and the data files contain all the information necessary to trace back all steps of the data analyses, Sweave also has the potential to make research more transparent and reproducible to others. However, this is only the case to the extent that the author makes the data and the R and Sweave code available. If the author only publishes the resulting PDF document or printed versions thereof, a report created using Sweave is no more transparent or reproducible than the same report created with other statistical and text preparation software.


%-------------------------------------------
\section{Introduction}
%--------------------------------------------

Just a simple introduction to Sweave. 

<<test1>>=
a=1
b=4
a+b
print("hello")
@

We can call R commands from the text. For example a+b= \Sexpr{a+b}