pldb/PLDB huggingface dataset:
Fortran (pl, appeared 1957)
Creators: John Backus
Origin: IBM
Country: United States
File extensions: f
for
f90
f95
f03
f08
f15
Keywords: ACCESS
ACTION
ADVANCE
ALLOCATABLE
ALLOCATE
ASSIGN
ASSIGNMENT
BACKSPACE
BLANK
BLOCK
CALL
CASE
CHARACTER
CLOSE
COMMON
COMPLEX
CONTAINS
CONTINUE
CYCLE
DATA
DEALLOCATE
DEFAULT
DELIM
DIMENSION
DIRECT
DO
DOUBLE
ELSE
ELSEWHERE
END
ENDFILE
ENTRY
EOR
EQUIVALENCE
ERR
EXIST
EXIT
EXTERNAL
FILE
FMT
FORM
FORMAT
FORMATTED
FUNCTION
GO
IF
IMPLICIT
IN
INOUT
INQUIRE
INTEGER
INTENT
INTERFACE
INTRINSIC
IOLENGTH
10STAT
KIND
LEN
LOGICAL
MODULE
NAME
NAMED
NAMELIST
NEXTREC
NML
NONE
NULLIFY
NUMBER
ONLY
OPEN
OPENED
OPERATOR
OPTIONAL
OUT
PAD
PARAMETER
PAUSE
POINTER
POSITION
PRECISION
PRINT
PRIVATE
PROCEDURE
PROGRAM
PUBLIC
READ
READWRITE
REAL
REC
RECl
RECURSIVE
RESULT
RETURN
REWIND
SAVE
SELECT
SEQUENCE
SEQUENTIAL
SIZE
STAT
STATUS
STOP
SUBROUTINE
TARGET
THEN
TO
TYPE
UNFORMATTED
UNIT
USE
WHERE
WHILE
WRITE


Fortran (; formerly FORTRAN, derived from Formula Translation) is a general-purpose, imperative programming language that is especially suited to numeric computation and scientific computing. Originally developed by IBM in the 1950s for scientific and engineering applications, Fortran came to dominate this area of programming early on and has been in continuous use for over half a century in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics, computational physics, crystallography and computational chemistry. It is a popular language for high-performance computing and is used for programs that benchmark and rank the world's fastest supercomputers. Fortran encompasses a lineage of versions, each of which evolved to add extensions to the language while usually retaining compatibility with prior versions. Successive versions have added support for structured programming and processing of character-based data (FORTRAN 77), array programming, modular programming and generic programming (Fortran 90), high performance Fortran (Fortran 95), object-oriented programming (Fortran 2003) and concurrent programming (Fortran 2008).
FoxPRO (pl, appeared 1992)
Origin: Fox Software
Country: United States


FoxPro was a text-based procedurally oriented programming language and database management system (DBMS), and it is also an object-oriented programming language, originally published by Fox Software and later by Microsoft, for MS-DOS, Windows, Macintosh, and UNIX. The final published release of FoxPro was 2.6.  Development continued under the Visual FoxPro label, which in turn was discontinued in 2007. FoxPro was derived from FoxBase (Fox Software, Perrysburg, Ohio), which was in turn derived from dBase III (Ashton-Tate) and dBase II.  dBase II was the first commercial version of a database program written by Wayne Ratliff, called Vulcan, running on CP/M. FoxPro is both a DBMS and a relational database management system (RDBMS), since it extensively supports multiple relationships between multiple DBF files (tables).  However it lacks transactional processing. After they acquired Fox Software in its entirety in 1992, FoxPro was sold and supported by Microsoft.  At that time there was an active worldwide community of FoxPro users and programmers. FoxPro 2.6 for UNIX (FPU26) has even been successfully installed on Linux and FreeBSD using the Intel Binary Compatibility Standard (ibcs2) support library.
FP (pl, appeared 1977)
Stands for: Functional Programming
Creators: John Backus
Origin: IBM
Country: United States


FP (short for function programming) is a programming language created by John Backus to support the function-level programming paradigm. This allows eliminating named variables. The language was introduced in Backus's 1977 Turing Award lecture, "Can Programming Be Liberated from the von Neumann Style?", subtitled "a functional style and its algebra of programs." The paper sparked interest in functional programming research, eventually leading to modern functional languages, and not the function-level paradigm Backus had hoped. FP itself never found much use outside of academia. In the 1980s Backus created a successor language, FL, which remained a research project.
FpgaC (pl, appeared 1996)
Origin: University of Toronto
Country: Canada


FpgaC is a compiler for a subset of the C programming language, which produces digital circuits that will execute the compiled programs. The circuits may use FPGAs or CPLDs as the target processor for reconfigurable computing, or even ASICs for dedicated applications.  FpgaC's goal is to be an efficient High Level Language (HLL) for reconfigurable computing, rather than a Hardware Description Language (HDL) for building efficient custom hardware circuits.
Functional PHP Preprocessor (pl, appeared 2018)
Also known as: fpp
Creators: Sascha-Oliver Prolic
Origin: https://www.sasaprolic.com/
Country: Paraguay
Website: https://github.com/prolic/fpp
File extensions: fpp
Keywords: namespace
use
data
bool
string
float
int
enum
uuid
guid
event
command



GitHub description: Functional PHP Preprocessor - Generate Immutable Data Types
Free Pascal (pl, appeared 1997)
Origin: https://www.delorie.com/bin/cvsweb.cgi/djgpp/
Country: Various


Free Pascal Compiler (FPC) is a compiler for the closely related programming language dialects, Pascal and Object Pascal. It is free software released under the GNU General Public License, with exception clauses that allow for static linking against its runtime libraries and packages for any purpose in combination with any other software license. It supports its own Object Pascal dialect as well as the dialects of several other Pascal family compilers to a certain extent, including those of Turbo Pascal, Delphi, and some historical Macintosh compilers. The dialect is selected on a per-unit (module) basis, and more than one dialect can be used per program. It follows a write once, compile anywhere philosophy, and is available for many CPU architectures and operating systems (see Targets). It supports inline assembly language and includes an internal assembler capable of parsing several dialects such as AT&T and Intel style. Separate projects exist to facilitate developing cross-platform graphical user interface (GUI) applications, the most prominent one being the Lazarus integrated development environment (IDE).
FreeBASIC (pl, appeared 2004)
Creators: Andre Victor
Origin: The FreeBASIC Development Team
Country: Various


FreeBASIC  is a multiplatform, free/open source (GPL) BASIC compiler for Microsoft Windows, protected-mode MS-DOS (DOS extender), Linux, FreeBSD and Xbox.  The Xbox version is no longer maintained.According to its official Web site, FreeBASIC provides syntax compatibility with programs originally written in Microsoft QuickBASIC (QB).  Unlike QuickBASIC, however, FreeBASIC is a command line only compiler, unless users manually install an external integrated development environment (IDE) of their choice.   IDEs specifically made for FreeBASIC include FBide and FbEdit.
Freefem (pl, appeared 2000)
Origin: Université Pierre et Marie Curie
Université Paris City
Country: France
Website: https://freefem.org/
Keywords: nuEdge
N
rfind
endl
ARGV
bordermeasure
BoundaryEdge
precision
fixed
mpiBAND
ndof
mpiLAND
mpiBXOR
mpiLOR
showbase
qf1pE
nt
z
qfnbpE
InternalEdge
P
qf1pTlump
n
false
m
imax
nuTriangle
version
qfV2
true
length
qf1pElump
adj
nv
ndofK
volume
x
mpiMIN
UMFPACK
qfV5
sum
binary
showpos
qf4pE
searchMethod
mpiCommWorld
area
qf2pT4P1
lenEdge
quantile
CG
min
default
noshowpos
qf2pE
y
Crout
notaregion
find
nTonEdge
max
tellp
whoinElement
re
FILE
qf5pT
measure
qf5pE
scientific
mpisize
qf9pT
cout
im
qfV1
qf3pE
mpirank
imin
label
hTriangle
pi
qf2pT
diag
qf1pT
l1
mpiPROD
LU
qf7pT
unused
flush
edgeOrientation
mpiSUM
good
mpiLXOR
linfty
mpiMAX
sparsesolver
ffind
l2
region
mpiUndefined
mpiAnySource
be
append
qfV1lump
verbosity
Cholesky
LINE
GMRES
setw
noshowbase
cin
nbe
FreeMarker (template, appeared 2000)
Also known as: FreeMarker2
Origin: https://freemarker.apache.org/mailing-lists.html
Country: Various


FreeMarker is a free Java-based template engine, originally focusing on dynamic web page generation with MVC software architecture. However, it is a general purpose template engine, with no dependency on servlets or HTTP or HTML, and is thus often used for generating source code, configuration files or e-mails.
Frege (pl, appeared 2011)
Origin: https://github.com/Frege
Country: Switzerland and Germany and United States
Website: https://github.com/Frege/frege


Frege is a non-strict, purely functional programming language for the Java virtual machine in the spirit of Haskell. It is considered a Haskell dialect or simply "a" Haskell for the Java virtual machine. Frege has a strong static type system with type inference. Higher rank types are supported, though type annotations are required for that. Frege programs are compiled to Java bytecode and run in a Java virtual machine. Existing Java classes and methods can be used seamlessly from Frege after their types have been properly declared. The language was designed by Ingo Wechsung, who named it after the German mathematician, logician and philosopher Gottlob Frege. (This language is unrelated to the Frege Program Prover.)

GitHub description: Frege is a Haskell for the JVM. It brings purely functional programing to the Java platform.
Frink (pl, appeared 2001)
Origin: https://futureboy.us/
Country: United States
Website: https://frinklang.org/


Frink is a computer programming language. It is, according to creator of the language, "designed to make physical calculations simple, to help ensure that answers come out right, and to make a tool that's really useful in the real world. It tracks units of measure (feet, meters, kilograms, watts, etc.) through all calculations, allowing you to mix units of measure transparently, and helps you easily verify that your answers make sense."
Frost (pl, appeared 2017)
Creators: Ethan Nicholas
Origin: https://github.com/ethannicholas/Frost/issues
Country: Unknown
Website: https://www.frostlang.org/



GitHub description: Frost is a powerful, general purpose, multi-paradigm programming language

========================================================
Simple version of the Unix `head` utility. Reads a file
and outputs the first `count` lines from it to the
standard output stream.

@param path the file to read
@param count the number of lines to display
========================================================
method head(path:File, count:Int) {
    try {
        path.lines()[..count].apply(Console.printLine)
    }
    fail(error) {
        abort(error.message)
    }
}

method abort(msg:String) {
    Console.printLine(msg)
    System.exit(1)
}

method main(args:ListView<String>) {
    if args.count != 3 {
        abort("usage: head <path> <count>")
    }
    def count := args[2].asInt
    if count == null {
        abort("error: '\{args[2]}' is not an integer")
    }
    head(File(args[1]), count)
}
Finite State Language (pl, appeared 2016)
Origin: https://github.com/StoneCypher/jssm/issues
Country: Various

Finite State Language, or FSL (pronounced "fossil,") is a programming language to make complex Finite State Machines easy to create and maintain. Finite State Machines can help make your code simpler, easier to test, more provable, and easier to reason about.



machine_name: "Traffic light";

flow: down;

arrange [Green Yellow];

Off 'Enable' -> Red;
  Red 'Next' => Green 'Next' => Yellow 'Next' => Red;

[Red Yellow Green] ~> Off;

// visual styling

state Red    : { background-color: pink;        corners: rounded; };
state Yellow : { background-color: lightyellow; corners: rounded; };
state Green  : { background-color: lightgreen;  corners: rounded; };

state Off : {
  background-color : steelblue;
  text-color       : white;
  shape            : octagon;
  linestyle        : dashed;
};
F* (pl, appeared 2014)
Origin: Microsoft Research
Country: Unknown
Website: https://www.fstar-lang.org/
Keywords: abstract
attributes
noeq
unopteq
andbegin
by
default
effect
else
end
ensures
exception
exists
false
forall
fun
function
if
in
include
inline
inline_for_extraction
irreducible
logic
match
module
mutable
new
new_effect
noextract
of
open
opaque
private
range_of
reifiable
reify
reflectable
requires
set_range_of
sub_effect
synth
then
total
true
try
type
unfold
unfoldable
val
when
with
not

F* is a dependently typed programming language and proof assistant. In practice, rather than a single language, the F* ecosystem is also a collection of domain-specific languages (DSLs). A common use of F* is to embed within it programming languages at different levels of abstraction or for specific programming tasks, and for the embedded language to be engineered with domain-specific reasoning, proof automation, and compilation backends.

F* (pronounced F star) is a functional programming language inspired by ML and aimed at program verification. Its type system includes dependent types, monadic effects, and refinement types. This allows expressing precise specifications for programs, including functional correctness and security properties. The F* type-checker aims to prove that programs meet their specifications using a combination of SMT solving and manual proofs. Programs written in F* can be translated to OCaml, F#, and C for execution. Previous versions of F* could also be translated to JavaScript. The latest version of F* is written entirely in a common subset of F* and F#, and bootstraps in OCaml and F#. It is open source (under the Apache 2.0 License) and is under active development on GitHub.

GitHub description: A Proof-oriented Programming Language
FTP (protocol, appeared 1971)
Stands for: File Transfer Protocol
Origin: Massachusetts Institute of Technology
Country: United States


The File Transfer Protocol (FTP) is the standard network protocol used for the transfer of computer files between a client and server on a computer network. FTP is built on a client-server model architecture and uses separate control and data connections between the client and the server. FTP users may authenticate themselves with a clear-text sign-in protocol, normally in the form of a username and password, but can connect anonymously if the server is configured to allow it. For secure transmission that protects the username and password, and encrypts the content, FTP is often secured with SSL/TLS (FTPS). SSH File Transfer Protocol (SFTP) is sometimes also used instead; it is technologically different. The first FTP client applications were command-line programs developed before operating systems had graphical user interfaces, and are still shipped with most Windows, Unix, and Linux operating systems. Many FTP clients and automation utilities have since been developed for desktops, servers, mobile devices, and hardware, and FTP has been incorporated into productivity applications, such as web page editors.
Fun (pl, appeared 2010)
Creators: Marcus Westin
Origin: http://marcuswest.in/
Country: United States
Website: http://marcuswest.in/essays/fun-intro/

A programming language for the realtime web.


GitHub description: A programming language for the realtime web.

// Fun code
let user = Session.User
let myTasks = Query({ type: "task", owner: user.id })
<h1>"Hello " user.name ", these are your tasks matey:"</h1>
for (task in myTasks) {
    <div class="task" + (task.urgent ? " urgent")>
        <input data=task.title />
        if (task.completed) {
            <span class="status">"Completed!"</span>
        } else {
            <button clickHandler=markComplete(task)/>"Mark as completed"</button>
        }
    </div>
}
let markComplete = handler(task) {
    task.completed = true
}
<h3>"Create a new task"</h3>
<input data=Local.newTaskTitle />
<button clickHandler=createNewTask />
let createNewTask = handler() {
    let title = Local.newTaskTitle
    Local.newTaskTitle = ""
    Global.create({ owner: user.id, type: "task", title: title })
}
Function block diagram (pl, appeared 2001)


The Function Block Diagram  (FBD) is a graphical language for programmable logic controller design, that can describe the function between input variables and output variables. A function is described as a set of elementary blocks. Input and output variables are connected to blocks by connection lines. Inputs and outputs of the blocks are wired together with connection lines, or links. Single lines may be used to connect two logical points of the diagram:  An input variable and an input of a block An output of a block and an input of another block An output of a block and an output variableThe connection is oriented, meaning that the line carries associated data from the left end to the right end.  The left and right ends of the connection line must be of the same type. Multiple right connection, also called divergence can be used to broadcast information from its left end to each of its right ends.  All ends of the connection must be of the same type. Function Block Diagram is one of five languages for logic or control configuration supported by standard IEC 61131-3 for a control system such as a Programmable Logic Controller (PLC) or a Distributed Control System (DCS).  The other supported languages are ladder logic, sequential function chart, structured text, and instruction list.
Futhark (pl, appeared 2013)
Creators: Troels Henriksen
Cosmin Oancea
Martin Elsman
Origin: University of Copenhagen
Country: Denmark
Website: https://futhark-lang.org
File extensions: fut

<a href='https://futhark-lang.org'>Futhark</a>, a high-performance parallel functional array language targeting GPUs.


GitHub description: :boom::computer::boom: A data-parallel functional programming language
FutureBASIC (pl, appeared 1992)
Origin: Brilor Software
Country: United States


FutureBasic is a free BASIC compiler for Apple Inc.'s Macintosh. It consists of an integrated development environment (IDE), editor, project manager, etc. for both PowerPC and Intel microprocessors. Since 1 January 2008, the package contains a translator, FBtoC, that converts the FutureBasic syntax to C and automatically calls Apple's GNU Compiler Collection (gcc). No knowledge of C is required. FutureBasic supports access to Mac OS library calls.
Fuzuli (pl, appeared 2012)
Creators: Mehmet Hakan Satman
Origin: Istanbul University
Country: Turkey
Website: https://web.archive.org/web/20170121211733/http://fuzuliproject.org/

Fuzuli has a syntax similar to Lisp but it is not intended to be an other Lisp clone. It has got several properties inhereted from Algol family and others. For example; syntax of while and foreach statements were directly derived from C++ and R, respectively. Some string manipulation functions share the same names and definitions from Visual Basic. Math and IO libraries are like C++ standard library and MySql library uses libmysql directly.


GitHub description: stdioe.blogspot.com/search/label/fuzuli

(require "/usr/lib/fuzuli/nfl/math.nfl")
(function euclidean (params x y)
    (block
        (def dist FLOAT)(let dist 0.0)
        (def i INTEGER)
        (for (let i 0) (< i (length x)) (inc i)
            (let dist (+ dist (pow (- (nth x i) (nth y i)) 2)))
        )
    (return dist)
    )
)
(def x LIST)
(def y LIST)
(let x (list 1 2 3 4 5 6 7 8 9 10))
(let y (list 1 2 3 4 5 6 7 8 9 11))
(let dist (euclidean x y))
(print dist "\n")
FuzzyCLIPS (knowledgeBase, appeared 1995)
Origin: National Research Council of Canada
Country: Canada

 The modifications made to CLIPS contain the capability of handling fuzzy concepts and reasoning. It enables domain experts to express rules using their own fuzzy terms. It allows any mix of fuzzy and normal terms, numeric-comparison logic controls, and uncertainties in the rules and facts. Fuzzy sets and relations deal with fuzziness in approximate reasoning, while certainty factors for rules and facts manipulate the uncertainty.

FuzzyCLIPS is a fuzzy logic extension of the CLIPS (C Language Integrated Production System) expert system shell from NASA. It was developed by the Integrated Reasoning Group of the Institute for Information Technology of the National Research Council of Canada and has been widely distributed for a number of years. It enhances CLIPS by providing a fuzzy reasoning capability that is fully integrated with CLIPS facts and inference engine allowing one to represent and manipulate fuzzy facts and rules. FuzzyCLIPS can deal with exact, fuzzy (or inexact), and combined reasoning, allowing fuzzy and normal terms to be freely mixed in the rules and facts of an expert system. The system uses two basic inexact concepts, fuzziness and uncertainty. It has provided a useful environment for developing fuzzy applications but it does require significant effort to update and maintain as new versions of CLIPS are released.
FX-87 (pl, appeared 1987)
Origin: Massachusetts Institute of Technology
Country: United States


FX-87 is a polymorphic typed functional language based on a system for static program analysis in which every expression has two static properties: a type and an effect. In a study done by MIT, FX-87 yields similar performance results as functional languages on programs that do not contain side effects (Fibonacci, Factorial). FX-87 did yield a great performance increase when matching DNA sequences.KFX is the kernel language of FX-87. It was described in 'Polymorphic Effect Systems', J.M. Lucassen et al., Proceedings of the 15th Annual ACM Conference POPL, ACM 1988, pp. 47–57.
FXML (xmlFormat, appeared 2011)
Origin: Oracle Corporation
Country: United States


FXML is an XML-based user interface markup language created by Oracle Corporation for defining the user interface of a JavaFX application.It provides a convenient alternative to constructing such graphs in procedural code, and is ideally suited to defining the user interface of a JavaFX application, since the hierarchical structure of an XML document closely parallels the structure of the JavaFX scene graph. However anything that is created or implemented in FXML can be expressed using JavaFX directly.
FXScript (pl, appeared 2002)
Origin: Apple
Country: United States


FXScript is a scripting language for Final Cut Pro and Final Cut Express.  FXBuilder is the scripting utility in which users are able to modify existing FCP FXScripts or program completely new ones. For example, to scale an image, only two lines are necessary to scale an image from its full size to half size:  scale(Region, CenterOfScale, 0.5, 0.5); blitrect(ImageBuffer, OrigRegion, Destination-Buffer, Region);  First the region, which might be a rectangle, is scaled by the statement scale and its parameters.  Then the statement blitrect copies a region of an image into a changed region. When the OrigRegion and the new Region have different sizes, Final Cut Pro scales the image to fit into the new region. A Statement is a command that accomplishes a single action. In our example, the statements are scale and blitrect.   In FXBuilder users can create and test FXScripts, optionally in multiple windows.
G-code (pl, appeared 1950)
Origin: Massachusetts Institute of Technology
Country: United States


G-code (also RS-274), which has many variants, is the common name for the most widely used numerical control (NC) programming language. It is used mainly in computer-aided manufacturing to control automated machine tools. G-code is sometimes called G programming language, not to be confused with LabVIEW's G programming language. G-code is a language in which people tell computerized machine tools how to make something. The "how" is defined by g-code instructions provided to a machine controller (industrial computer) that tells the motors where to move, how fast to move, and what path to follow. The most common situation is that, within a machine tool, a cutting tool is moved according to these instructions through a toolpath and cuts away material to leave only the finished workpiece. The same concept also extends to noncutting tools such as forming or burnishing tools, photoplotting, additive methods such as 3D printing, and measuring instruments.