pldb/PLDB huggingface dataset:
FLEX (grammarLanguage, appeared 1987)
Creators: Vern Paxson
Origin: University of California, Berkeley
Country: United States
Website: https://github.com/westes/flex


Flex (fast lexical analyzer generator) is a free and open-source software alternative to lex. It is a computer program that generates lexical analyzers (also known as "scanners" or "lexers"). It is frequently used as the lex implementation together with Berkeley Yacc parser generator on BSD-derived operating systems (as both lex and yacc are part of POSIX), or together with GNU bison (a version of yacc) in *BSD ports and in Linux distributions. Unlike Bison, flex is not part of the GNU Project and is not released under the GNU General Public License.

GitHub description: The Fast Lexical Analyzer - scanner generator for lexing in C and C++
FleXML (pl, appeared 2001)
Origin: École normale supérieure de Lyon
Country: France


FleXML is an XML transformation language originally developed by Kristofer Rose.  It allows a programmer to specify actions in C programming language or C++, and associate those actions with element definitions in an XML DTD.  It is similar in philosophy to Yacc and the Lex programming tool in that it is a syntax-directed driver; one could establish the analogies Yacc:LR(1) grammar::Lex:Regular grammar::FleXML::XML. The implementation is in Perl. A programmer supplied action file is input to FleXML; the output is a file suitable for input to Flex lexical analyser.
FLOW-MATIC (pl, appeared 1955)
Creators: Grace Hopper
Origin: Remington Rand
Country: United States


FLOW-MATIC, originally known as B-0 (Business Language version 0), was the first English-like data processing language. It was developed for the UNIVAC I at Remington Rand under Grace Hopper during the period from 1955 until 1959. It had a strong influence on the development of COBOL.
Flow9 (pl, appeared 2010)
Creators: Dmitry Solomennikov
Origin: https://github.com/area9innovation
Country: Unknown
Website: https://flow9.org/
Keywords: import
require
export
forbid
native
if
else
cast
unsafe
switch
default

The flow programming language, a safe, functional strongly-typed programming language


GitHub description: Platform for safe, easy and productive programming of complex, multi-platform apps with a modern user interface

import runtime;

main() {
	println("Hello world");
}
Flowcode (pl, appeared 2002)
Origin: Matrix Technology Solutions Ltd
Country: United Kingdom


Flowcode is a Microsoft Windows-based development environment commercially produced by Matrix TSL for programming embedded devices based on PIC, AVR (including Arduino) and ARM technologies using graphical programming styles (such as flowcharts) and imperative programming styles (through C and Pseudocode). It is currently in its eighth revision. Flowcode is dedicated to simplifying complex functionality such as Bluetooth, Mobile Phones Communications, USB communications etc. by using pre-developed dedicated component libraries of functions. This is achieved by dragging virtual representations of hardware onto a visual panel, providing access to associated libraries. Flowcode is therefore ideal for speeding up software development times and allowing those with little programming experience to get started and help with projects. This makes it appropriate for the formal teaching of principles of programming microcontrollers .. Flowcode allows the user to develop and view their program using four different visual modes. These are the Flowchart view, the Blocks view (a graphical programming paradigm inspired by Blockly), the C code view and the Pseudocode view. Flowcode also has compatibility with Solidworks.There is a large and helpful online community based at the Matrix user forums. There is also a dedicated Wiki.
flowlog (pl, appeared 2014)
Origin: Brown University
Country: United States

We present Flowlog, a tierless language for programming SDN controllers. In contrast to languages with different abstractions for each program tier---the control-plane, data-plane, and controller state---Flowlog provides a unified abstraction for all three tiers. Flowlog is reminiscent of both SQL and rule-based languages such as Cisco IOS and JunOS; unlike these network configuration languages, Flowlog supports programming with mutable state. We intentionally limit Flowlog’s expressivity to enable built-in verification and proactive compilation despite the integration of controller state. To compensate for its limited expressive power, Flowlog enables the reuse of external libraries through callouts. Flowlog proactively compiles essentially all forwarding behavior to switch tables. For rules that maintain controller state or generate fresh packets, the compiler instructs switches to send the minimum amount of necessary traffic to the controller. Given that Flowlog programs can be stateful, this process is non-trivial. We have successfully used Flowlog to implement real network applications. We also compile Flowlog programs to Alloy, a popular verification tool. With this we have verified several properties, including program-correctness properties that are topology-independent, and have found bugs in our own programs.



TABLE stolen(switchid );
REMOTE TABLE get_time(int );
FlowNet (protocol, appeared 1993)
Creators: Erann Gat
Mike Ciholas
Origin: https://rongarret.info
Country: United States

Ethernet alternative. Like ATM, FlowNet is a switched network based on fixed-size cells. Unlike ATM, FlowNet cells are large--800 bytes instead of 53. This allows room for a 14-byte Ethernet header plus an additional QoS extension. The QoS extension header is 18 bytes, making the full FlowNet header 32 bytes long. The remaining 768 bytes (=256+512) are data payload. FlowNet interoperates with Ethernet through a simple bridge device.
FLUX (pl, appeared 2014)
Creators: Paul O’Shannessy
Origin: https://github.com/fluxcd
Country: United States
Website: https://facebook.github.io/flux/

Application Architecture for Building User Interfaces


GitHub description: Application Architecture for Building User Interfaces

// concrete node signatures
Listen ()
  => (int socket);

ReadRequest (int socket)
  => (int socket, bool close, image_tag *request);

CheckCache (int socket, bool close, image_tag *request)
  => (int socket, bool close, image_tag *request);

// omitted for space:
// ReadInFromDisk, StoreInCache
Compress (int socket, bool close, image_tag *request, __u8 *rgb_data)
  => (int socket, bool close, image_tag *request);
Write (int socket, bool close, image_tag *request)
  => (int socket, bool close, image_tag *request);
Complete (int socket, bool close, image_tag *request) => ();

// source node
source Listen => Image;

// abstract node
Image = ReadRequest -> CheckCache -> Handler -> Write -> Complete;

// predicate type & dispatch
typedef hit TestInCache;
Handler:[_, _, hit] = ;
Handler:[_, _, _] =
ReadInFromDisk -> Compress -> StoreInCache;

// error handler
handle error ReadInFromDisk => FourOhFor;

// atomicity constraints
atomic CheckCache:{cache};
atomic StoreInCache:{cache};
atomic Complete:{cache};
FM broadcasting (standard, appeared 1950)


FM broadcasting is a method of radio broadcasting using frequency modulation (FM) technology. Invented in 1933 by American engineer Edwin Armstrong, wide-band FM is used worldwide to provide high-fidelity sound over broadcast radio. FM broadcasting is capable of better sound quality than AM broadcasting (under normal listening conditions), the chief competing radio broadcasting technology, so it is used for most music broadcasts. Theoretically wideband AM can offer equally good sound quality, provided the reception conditions are ideal. FM radio stations use the VHF frequencies.  The term "FM band" describes the frequency band in a given country which is dedicated to FM broadcasting.
fmj (pl, appeared 2003)
Origin: http://www.fmjlang.co.uk
Country: United States
Website: http://www.fmjlang.co.uk/fmj/FMJ.html

Full Metal Jacket is very different from other programming languages. It's intrinsically parallel, with no flow of control, and has no variables. Programs are composed almost entirely with the mouse rather than keyboard, and type inference and other checks take place while you edit your program. There are a few other visual dataflow languages out there, but Full Metal Jacket is simpler than them, and has a cleaner design. Full Metal Jacket is general-purpose, though it might in due course find a niche. Some adjustment will be needed by programmers who are most comfortable with imperative programming languages, such as Java or C. To master dataflow, they will have to change they way they think. They should regard this as a worthwhile challenge which will make them better programmers. Functional programmers might have a slightly easier time.
FML (pl, appeared 2012)
Stands for: Function Manipulation Language
Creators: Joe Groff
Origin: https://duriansoftware.com
Country: United States

fml is an optimizing, function-oriented, array programming language. Unlike other array programming languages, it aims to have a less symbol-heavy but still concise syntax, and non-strict semantics that allow for high-level optimization. Note that fml is not: meant for serious use always faster than systems languages like C/C++/etc. always more expressive than general-purpose languages like Python, Javascript, etc. suitable for cryptography, real-time, or low-level applications that require fine control of time and space complexity



pad = x flip[stitch] 0, stitch 0, flip[cat] 0, cat 0
life = pad, neighborhoods[3 3], [ravel, [sum in?: [x @ 4, + 3; 3]]]/2

[0 1 0 1
 0 1 1 0
 0 0 1 0
 0 0 0 0] replicate[life]-times[5]
###
[0 1 0 1
 0 1 1 0
 0 0 1 0
 0 0 0 0

 0 1 0 0
 0 1 0 1
 0 1 1 0
 0 0 0 0

 0 0 1 0
 1 1 0 0
 0 1 1 0
 0 0 0 0

 0 1 0 0
 1 0 0 0
 1 1 1 0
 0 0 0 0

 0 0 0 0
 1 0 1 0
 1 1 0 0
 0 1 0 0]
###
FOAF (xmlFormat, appeared 2007)
Origin: http://rdfweb.org/mailman/listinfo/rdfweb-dev
Country: Various




@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

<#JW>
    a foaf:Person ;
    foaf:name "James Wales" ;
    foaf:mbox <mailto:jwales@bomis.com> ;
    foaf:homepage <http://www.jameswales.com> ;
    foaf:nick "Jimbo" ;
    foaf:depiction <http://www.jameswales.com/aus_img_small.jpg> ;
    foaf:interest <http://www.wikimedia.org> ;
    foaf:knows [
        a foaf:Person ;
        foaf:name "Angela Beesley"
    ] .

<http://www.wikimedia.org>
    rdfs:label "Wikimedia" .
Formulating On-Line Calculations in Algebraic Language (pl, appeared 1968)
Stands for: Formulating On-Line Calculations in Algebraic Language
Creators: Richard Merrill
Origin: Digital Equipment Corporation
Country: United States


FOCAL is an interpreted programming language resembling JOSS. The name is an acronym for Formulating On-Line Calculations in Algebraic Language. Largely the creation of Richard Merrill, FOCAL was initially written for and had its largest impact on the Digital Equipment Corporation's (DEC's) PDP-8 computers. Merrill wrote the original (1968) and classic FOCAL-69 interpreters for the PDP-8.  Digital itself described FOCAL as "a JOSS-like language." Like early versions of BASIC, FOCAL was a complete programming environment in itself, requiring no operating system. As in MUMPS, most commands could be, and in practice were, abbreviated to a single letter of the alphabet. Creative choices of words were used to make each command uniquely defined by its leading character. Digital made available several European-language versions in which the command words were translated into the target language.
FOCUS (pl, appeared 1997)
Origin: Information Builders Inc
Country: United States


FOCUS is a fourth-generation programming language (4GL) computer programming language and development environment that is used to build database queries. Produced by Information Builders Inc., it was originally developed for data handling and analysis on the IBM mainframe. Subsequently versions for minicomputers and such as the VAX and other platforms were implemented. FOCUS was later extended to personal computers and (in 1997) to the World Wide Web: the WebFOCUS product.
forest-database (application, appeared 2011)
Origin: Princeton University
Country: United States

A filestore is a structured collection of data files housed in a conventional hierarchical file system. Many applications use filestores as a poor-man’s database, and the correct execution of these applications requires that the collection of files, directories, and symbolic links stored on disk satisfy a variety of precise invariants. Moreover, all of these structures must have acceptable ownership, permission, and timestamp attributes. Unfortunately, current programming languages do not provide support for documenting assumptions about filestores, detecting errors, or safely loading from and storing to them. This paper describes the design, implementation, and semantics of Forest, a novel domain-specific language for describing filestores. The language uses a type-based metaphor to specify the expected structure, attributes, and invariants of filestores. Forest generates loading and storing functions that make it easy to connect data on disk to an isomorphic representation in memory that can be manipulated as if it were any other data structure. Forest also generates metadata that describes the degree to which the structures on the disk conform to the specification, making error detection easy. Hence, in a nutshell, Forest extends the rigorous discipline of typed programming languages and many of their benefits to the untyped world of file systems. We have implemented Forest as an embedded domain-specific language in Haskell. In addition to generating infrastructure for reading, writing and checking file systems, our implementation generates a type class instances that make it easy to build generic tools that operate over arbitrary filestores. We illustrate the utility of this infrastructure by building a file system visualizer, a file access checker, a generic query interface, description-directed variants of several standard UNIX shell tools and (circularly) a simple Forest description inference engine. Finally, we formalize a core fragment of Forest in a semantics inspired by classical tree logics and prove round-tripping laws showing that the loading and storing functions behave sensibly.
Formatted Table (dataNotation, appeared 1990)

A simple plain text format for storing tabular data.



Weekly SST data starts week centered on 3Jan1990

               Nino1+2      Nino3        Nino34        Nino4
Week          SST SSTA     SST SSTA     SST SSTA     SST SSTA
03JAN1990     23.4-0.4     25.1-0.3     26.6 0.0     28.6 0.3
10JAN1990     23.4-0.8     25.2-0.3     26.6 0.1     28.6 0.3
17JAN1990     24.2-0.3     25.3-0.3     26.5-0.1     28.6 0.3
24JAN1990     24.4-0.5     25.5-0.4     26.5-0.1     28.4 0.2
ACCEPTABLE LEFT PRIMERS
                                  1-based     #                self   self hair-  qual-
   # sequence                       start ln  N   GC%     Tm any_th end_th   pin   lity
   0 tgctagctaggcgatgctag             411 20  0 55.00 60.028 23.16 23.16 38.59  0.028
   1 actgatacgcgatgctagct             476 20  0 50.00 59.957 17.69  1.35  0.00  0.043
   2 gatcgatgctagctaggcga             405 20  0 55.00 60.100 16.30 16.30  0.00  0.100
   3 tcgatcgatgctagctaggc             403 20  0 55.00 60.100 18.63  8.45  0.00  0.100
   4 tagctgatcgatcgtagcgg             565 20  0 55.00 60.101 25.02 17.36  0.00  0.101
   5 gctgactgatcgatcgatgc             113 20  0 55.00 59.826 24.08 17.09 35.21  0.174
   6 tatcatctctgcgcgatcga             361 20  0 50.00 59.747 22.07  1.72 38.48  0.253
   7 agctaggcgatgctagctag             415 20  0 55.00 59.742 17.46 17.46 41.54  0.258
   8 ctagctaggcgatgctagct             413 20  0 55.00 59.742 18.68 17.35 43.53  0.258
   9 ggcgatctagctagctgact             583 20  0 55.00 59.671 17.44  7.44 37.58  0.329
  10 tcgatgctagctaggcgatg             407 20  0 55.00 60.382 14.03  0.00  0.00  0.382
  11 gctgatcgatcgatgctagc             398 20  0 55.00 59.618 25.97 24.79 35.21  0.382
  12 gctagctgatcgatcgatgc             394 20  0 55.00 59.618 24.08 21.09 35.21  0.382
  13 atcatctctgcgcgatcgat             362 20  0 50.00 60.382 22.07  5.02 38.48  0.382
  14 gactgatacgcgatgctagc             475 20  0 55.00 59.551  8.61  8.61  0.00  0.449
  15 atcgatgctagctaggcgat             406 20  0 50.00 59.452 18.43 18.43  0.00  0.548
  16 gctagctgactgatacgcga             468 20  0 55.00 60.589 16.29  0.00  0.00  0.589
  17 agctagctgactgatacgcg             467 20  0 55.00 60.590 17.99  3.89  0.00  0.590
  18 atgctagctaggcgatgcta             410 20  0 50.00 59.375 10.59  8.91  0.00  0.625
  19 ctatcatctctgcgcgatcg             360 20  0 55.00 59.347 12.19 12.19 39.07  0.653
  20 gatgctagctaggcgatgct             409 20  0 55.00 60.668  7.01  7.53  0.00
Forml (pl, appeared 2011)
Creators: Andrew Stein
Origin: https://github.com/texodus
Country: United States
Website: http://texodus.github.io/forml/

A contemporary programming language for the discriminating programmer, intended to approximate the safety of Haskell and the expressiveness of Ruby. Should such an approximation turn out to exist.


GitHub description: A programming language

    hello_world = do
        `console.log("Hello World")` -- Calls to Javascript always return type `JS a`
        x <- `Math.sqrt(9)`          -- `x` is inferred to be the unrestricted type `a`
        let z = x + 1                -- `x` is now restricted to type `Num`
        return (z + 1)                  -- type of `hello_world` is inferred to be `JS Num`
    8 == do! hello_world >>= λx = `x + 3`
Formula language (pl, appeared 1989)
Origin: IBM
Country: United States
Website: https://www.ibm.com/support/knowledgecenter/en/SSVRGU_9.0.1/basic/H_NOTES_FORMULA_LANGUAGE.html

Formula language is a simple, easy-to-use programming language that can be found in many Lotus products -- such as Lotus 1-2-3 and Lotus Notes. Formula language has been integrated into Lotus Notes since its inception in 1989 and has included numerous enhancements over the years.

The Formula language is a scripting language used by Lotus Notes. It is often referred to as @Formula language (pronounced at-formula) because many language elements start with the @-character. Here is an example of a selection formula:  SELECT @NoteId = "NT0050D26"  It was created by Ray Ozzie during the early development of Lotus Notes. He borrowed the compiler and decompiler from the Lotus 1-2-3 spreadsheet, but unlike the spreadsheet language Formula Language was designed primarily for string and list processing, not numerical processing.  It was originally a Functional programming language with unique text list-handling features inspired by Ray Ozzie's prior use of Icon and Lisp. The Formula language engine was rewritten by Damien Katz for Notes and Domino 6. New features were added to the language, such as looping and dynamic execution, and performance was improved.The Formula language has two parts:  @Functions for calculations and simple logic @Commands for performing actions in the user interface@Functions can be used in several places throughout Lotus Notes. The most important uses are:  to select documents to show to the user in a view (a kind of index) or to select documents for further processing. In this case, the formula will evaluate to a 'true' (selected) or 'false' value (not selected) for each document. to provide default values for fields, to transform the data entered by the user (like stripping off redundant spaces) and to validate this data. to get a list of values from a Notes database or even from a relational database (using ODBC). This may be used to provide a user with a list of values to choose from. to process a set of documents. The formula is placed in an agent, a program or macro that can be started by a user or by the Notes server according to a schedule. When the agent is triggered, the formula executes for each selected document (this a very limited form of a loop). This is an efficient way of changing lots of documents, if the logic is not too complicated. In case of complicated changes, LotusScript is used.@Commands are like menu commands: they perform actions in the Lotus Notes client. Examples of actions are:  opening a Notes database creating an e-mail putting the cursor in a specific data-entry field closing a window starting an agent@Commands are primarily used in formulas that are triggered by user action, such as in button formulas. It is possible to combine them with @Functions, for example by making execution of an @command conditional on a field value.


FIELD NewDate:=@Today
FIELD OldDate:=@DeleteField;
Forth (pl, appeared 1970)
Creators: Charles H. Moore
Origin: National Radio Astronomy Observatory
Country: United States


Forth is an imperative stack-based computer programming language and environment originally designed by Charles "Chuck" Moore. Language features include structured programming, reflection (the ability to modify the program structure during program execution), concatenative programming (functions are composed with juxtaposition) and extensibility (the programmer can create new commands). Although not an acronym, the language's name is sometimes spelled with all capital letters as FORTH, following the customary usage during its earlier years. A procedural programming language without type checking, Forth features both interactive execution of commands (making it suitable as a shell for systems that lack a more formal operating system) and the ability to compile sequences of commands for later execution. Some Forth implementations (usually early versions or those written to be extremely portable) compile threaded code, but many implementations today generate optimized machine code like other language compilers. Forth is used in the Open Firmware boot loader, in space applications, such as the Philae spacecraft and other embedded systems which involve interaction with hardware. The bestselling 1986 DOS game Starflight, from Electronic Arts, was written with a custom Forth. The free software Gforth implementation is actively maintained, as are several commercially supported systems.