pldb/PLDB huggingface dataset:
Farcaster (protocol, appeared 2021)
Creators: Dan Romero
Varun Srinivasan
Origin: https://github.com/farcasterxyz
Country: United States

Farcaster is a decentralized social network built on top of Ethereum. The Layer 1 blockchain manages user identities, while a Layer 2 network propagates updates between users. It offers: Secure, memorable, and human-readable user identifiers like @alice. Real-time settlement and propagation of changes between users. Decentralized access to all data on the network at reasonable costs.


GitHub description: Specification of the Farcaster Protocol
Fardlang (esolang, appeared 2022)
Creators: CompilingCoder
JustCoding123
zplusfour
Hg0428
Origin: https://github.com/Sarang0218
Country: South Korea and United States
Website: https://github.com/Sarang0218/ResearchAndDevFor_Fardlang




# hehe fard dis is a fardy comment
math = 3
fards? math == 3
  fard "equals"
farded
FASTA (textDataFormat, appeared 2004)
Origin: National Center for Biotechnology Information
University of Virginia
Country: United States


In bioinformatics, FASTA format is a text-based format for representing either nucleotide sequences or peptide sequences, in which nucleotides or amino acids are represented using single-letter codes. The format also allows for sequence names and comments to precede the sequences. The format originates from the FASTA software package, but has now become a standard in the field of bioinformatics.The simplicity of FASTA format makes it easy to manipulate and parse sequences using text-processing tools and scripting languages like the R programming language, Python, Ruby, and Perl.
FASTQ (textDataFormat, appeared 2000)
Origin: Wellcome Trust Sanger Institute
Country: United Kingdom


FASTQ format is a text-based format for storing both a biological sequence (usually nucleotide sequence) and its corresponding quality scores. Both the sequence letter and quality score are each encoded with a single ASCII character for brevity. It was originally developed at the Wellcome Trust Sanger Institute to bundle a FASTA formatted sequence and its quality data, but has recently become the de facto standard for storing the output of high-throughput sequencing instruments such as the Illumina Genome Analyzer.


@SEQ_ID
GATTTGGGGTTCAAAGCAGTATCGATCAAATAGTAAATCCATTTGTTCAACTCACAGTTT
+
!''*((((***+))%%%++)(%%%%).1***-+*''))**55CCF>>>>>>CCCCCCC65
FastTrack Scripting Host (pl, appeared 2006)
Origin: FastTrack Software
Country: Denmark


FastTrack Automation Studio (formerly known as FastTrack Scripting Host) – often referred to as just FastTrack – is a scripting language for Windows IT System Administrators.  The product’s goal is to handle any kind of scripting that might be required to automate processes with Microsoft Windows networks. The web site of the product is located at www.fasttrackscript.com.
FAT (filesystem, appeared 1977)
Also known as: FAT32 FAT16 FAT12
Stands for: File Allocation Table
Origin: Microsoft
IBM
NCR Corporation
Seattle Computer Products
Compaq Computer Corporation
Digital Research, Inc
Novell, Inc
Caldera, Inc
Country: United States


File Allocation Table (FAT) is a computer file system architecture and a family of industry-standard file systems utilizing it. The FAT file system is a continuing standard which borrows source code from the original, legacy file system and proves to be simple and robust. It offers useful performance even in lightweight implementations, but cannot deliver the same performance, reliability and scalability as some modern file systems. It is, however, supported for compatibility reasons by nearly all currently developed operating systems for personal computers and many mobile devices and embedded systems, and thus is a well-suited format for data exchange between computers and devices of almost any type and age from 1981 up to the present. Originally designed in 1977 for use on floppy disks, FAT was soon adapted and used almost universally on hard disks throughout the DOS and Windows 9x eras for two decades. As disk drives evolved, the capabilities of the file system have been extended accordingly, resulting in three major file system variants: FAT12, FAT16 and FAT32. The FAT standard has also been expanded in other ways while generally preserving backward compatibility with existing software. With the introduction of more powerful computers and operating systems, as well as the development of more complex file systems for them, FAT is no longer the default file system for usage on Microsoft Windows computers.FAT file systems are still commonly found on floppy disks, flash and other solid-state memory cards and modules (including USB flash drives), as well as many portable and embedded devices. FAT is the standard file system for digital cameras per the DCF specification.
FAUST (pl, appeared 2002)
Origin: Centre national de création musicale
Country: France
Website: http://faust.grame.fr


FAUST (Functional AUdio STream) is a domain-specific purely functional programming language for implementing signal processing algorithms in the form of libraries, audio plug-ins, or standalone applications. A FAUST program denotes a signal processor: a mathematical function that is applied to some input signal and then fed out.
fay (pl, appeared 2012)
Creators: Chris Done
Origin: https://github.com/faylang/
Country: Australia and Sweden and United States
Website: https://github.com/faylang/fay/wiki



GitHub description: A proper subset of Haskell that compiles to JavaScript

{-# LANGUAGE EmptyDataDecls #-}
module Hello where

import FFI

data Event

alert :: String -> Fay ()
alert = ffi "alert(%1)"

setBodyHtml :: String -> Fay ()
setBodyHtml = ffi "document.body.innerHTML = %1"

addWindowEvent :: String -> (Event -> Fay ()) -> Fay ()
addWindowEvent = ffi "window.addEventListener(%1, %2)"

greet :: Event -> Fay ()
greet event = do
  putStrLn "The document has loaded"
  setBodyHtml "Hello HTML!"

main :: Fay ()
main = do
  putStrLn "Hello Console!"
  alert "Hello Alert!"
  addWindowEvent "load" greet
FCL (pl, appeared 1989)
Stands for: Flow chart language
Origin: Copenhagen University
Technical University of Denmark
DIKU
Computer Resources International A/S
Country: Denmark




(n)
(init)

init: x1 = 1
      x2 = 1

fib:  x1 = x1 + x2

      t = x1
      x1 = x2
      x2 = t

      n = -(n 1)

      if >(n 2) then fib else exit
exit: return x2
Felix (pl, appeared 2001)
Creators: John Skaller
Origin: felix-language@googlegroups.com
Country: Australia
Website: http://felix-lang.github.io/felix/
Keywords: _
_deref
all
as
assert
attempt
call
callback
case
caseno
cclass
code
compound
ctypes
do
done
downto
elif
else
endattempt
endcase
endif
endmatch
enum
except
exceptions
expect
finally
for
forall
forget
fork
functor
goto
ident
if
incomplete
inherit
instance
interface
jump
lambda
loop
match
module
namespace
new
noexpand
nonterm
obj
of
open
parse
raise
regexp
reglex
regmatch
rename
return
the
then
to
type
typecase
typedef
typematch
typeof
upto
when
whilst
with
yield



GitHub description: The Felix Programming Language

#import <flx.flxh>
fun abs_div(a:int, b:int when b!=0)
  expect result >=0
=>
  abs(a/b)
;
print (abs_div(2,4)); print "\n";
Forsyth-Edwards Notation (notation, appeared 1883)


Forsyth–Edwards Notation (FEN) is a standard notation for describing a particular board position of a chess game. The purpose of FEN is to provide all the necessary information to restart a game from a particular position. FEN is based on a system developed by Scottish newspaper journalist David Forsyth. Forsyth's system became popular in the 19th century; Steven J. Edwards extended it to support use by computers. FEN is an integral part of the Portable Game Notation for chess games, since FEN is used to define initial positions other than the standard one. FEN does not represent sufficient information to decide whether a draw by threefold repetition may be legally claimed or a draw offer may be accepted; for that, a different format such as Extended Position Description is needed.


rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
Fennel (pl, appeared 2016)
Creators: Calvin Rose
Origin: https://lists.sr.ht/%7Etechnomancy/fennel
Country: Various
Website: https://fennel-lang.org/



GitHub description: Lua Lisp Language

;; Sample: read the state of the keyboard and move the player accordingly
(local dirs {:up [0 -1] :down [0 1] :left [-1 0] :right [1 0]})
(each [key delta (pairs dirs)]
  (when (love.keyboard.isDown key)
    (let [[dx dy] delta
          [px py] player
          x (+ px (* dx player.speed dt))
          y (+ py (* dy player.speed dt))]
      (: world :move player x y))))
ferret (pl, appeared 2017)
Creators: Nurullah Akkaya
Origin: Near East University
Country: North Cyprus
Website: http://ferret-lang.org



GitHub description: Ferret is a free software lisp implementation for real time embedded control systems.

;;; lazy-sum.clj
(defn positive-numbers
  ([]
   (positive-numbers 1))
  ([n]
   (cons n (lazy-seq (positive-numbers (inc n))))))

(println (->> (positive-numbers)
              (take 5)
              (apply +)))
Fast Healthcare Interoperability Resources (standard, appeared 2011)
Origin: Health Level Seven International
Country: United States

FHIR builds on previous data format standards from HL7, like HL7 version 2.x and HL7 version 3.x. But it is easier to implement because it uses a modern web-based suite of API technology, including a HTTP-based RESTful protocol, HTML and Cascading Style Sheets for user interface integration, a choice of JSON, XML or RDF for data representation, and Atom for results.

Fast Healthcare Interoperability Resources (FHIR, pronounced "fire") is a draft standard describing data formats and elements (known as "resources") and an application programming interface (API) for exchanging electronic health records. The standard was created by the Health Level Seven International (HL7) health-care standards organization. FHIR builds on previous data format standards from HL7, like HL7 version 2.x and HL7 version 3.x.  But it is easier to implement because it uses a modern web-based suite of API technology, including a HTTP-based RESTful  protocol, HTML and Cascading Style Sheets for user interface integration, a choice of JSON, XML or RDF for data representation, and Atom for results. One of its goals is to facilitate interoperation between legacy health care systems, to make it easy to provide health care information to health care providers and individuals on a wide variety of devices from computers to tablets to cell phones, and to allow third-party application developers to provide medical applications which can be easily integrated into existing systems. FHIR provides an alternative to document-centric approaches by directly exposing discrete data elements as services.   For example, basic elements of healthcare like patients, admissions, diagnostic reports and medications can each be retrieved and manipulated via their own resource URLs.  FHIR was supported at an American Medical Informatics Association meeting by many EHR vendors which value its open and extensible nature.
Fibonacci (pl, appeared 1991)
Creators: Antonio Albano
Giorgio Ghelli
and Renzo Orsini
Origin: Università di Pisa
Country: Italy

Fibonacci is an object-oriented database programming language characterized by static and strong typing, and by new mechanisms for modeling databases in terms of objects with roles, classes, and associations.



let john = role Person
 private
  let address = var ("Darwin road, 123 - London") ;5
 methods
  Name = "John Daniels";
  BirthYear = 1967;
  Age = currentYear() - me.BirthYear;
  Address = at (address);
  modAddress (newAddress: String) =
      if stringLength(newAddress) <= 0
      then failwith "incorrect address"
      else address := newAddress
  Introduce = "My name is " & me.Name &
       "and I was born in " ~ intToString(me.BirthYear);
end;
Filebench WML (pl, appeared 2011)
Creators: Vasily Tarasov
Origin: https://github.com/filebench
Country: United States
Website: https://github.com/filebench/filebench/wiki

Filebench is a file system and storage benchmark that can generate a large variety of workloads. Unlike typical benchmarks it is extremely flexible and allows to specify application's I/O behavior using its extensive Workload Model Language (WML).


GitHub description: File system and storage benchmark that uses a custom language to generate a large variety of workloads.

#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#

set $dir=/tmp
set $nfiles=1000
set $meandirwidth=20
set $meanfilesize=16k
set $iosize=1m
set $nthreads=1

set mode quit firstdone

define fileset name=bigfileset,path=$dir,size=$meanfilesize,entries=$nfiles,dirwidth=$meandirwidth,prealloc=100,paralloc
define fileset name=destfiles,path=$dir,size=$meanfilesize,entries=$nfiles,dirwidth=$meandirwidth

define process name=filereader,instances=1
{
  thread name=filereaderthread,memsize=10m,instances=$nthreads
  {
    flowop openfile name=openfile1,filesetname=bigfileset,fd=1
    flowop readwholefile name=readfile1,fd=1,iosize=$iosize
    flowop createfile name=createfile2,filesetname=destfiles,fd=2
    flowop writewholefile name=writefile2,fd=2,srcfd=1,iosize=$iosize
    flowop closefile name=closefile1,fd=1
    flowop closefile name=closefile2,fd=2
  }
}

echo  "Copyfiles Version 3.0 personality successfully loaded"
Filterscript (pl, appeared 2012)

A subset of RenderScript



#pragma version(1)
#pragma rs java_package_name(foo)

int __attribute__((kernel)) root(uint32_t ain) {
  return 0;
}

void __attribute__((kernel)) in_only(uint32_t ain) {
}

int __attribute__((kernel)) out_only() {
  return 0;
}

int __attribute__((kernel)) everything(uint32_t ain, uint32_t x, uint32_t y) {
  return 0;
}
fish (pl, appeared 2005)
Stands for: friendly interactive shell
Origin: https://github.com/fish-shell
Country: Various
Website: http://fishshell.com/


The friendly interactive shell (fish) is a Unix shell that attempts to be more interactive and user-friendly than those with a longer history (i.e. most other Unix shells) or those formulated as function-compatible replacements for the aforementioned (e.g. zsh, the Falstad shell). The design goal of fish is to give the user a rich set of powerful features in a way that is easy to discover, remember, and use. fish is considered an "exotic shell", in that its syntax derives from neither the Bourne shell (ksh, bash, zsh) nor the C shell (csh, tcsh). Also unlike previous shells, which disable certain features by default to save system resources, fish enables all features by default.

GitHub description: The user-friendly command line shell.
fizz (pl, appeared 2017)
Origin: https://f1zz.org
Country: United States
Website: https://f1zz.org/

fizz is an experimental language and runtime environment for the exploration of cognitive architectures and combined Machine Learning (ML) and Machine Reasoning (MR) solutions. It is based primarily on symbolic programming and fuzzy formal logic and it features a distributed (as in heterogeneous computer cluster), concurrent, asynchronous and responsive inference engine.



// Code ----------------------------------------------------------------------------------------------------------------------------------

is.tree { // test if a term is a valid binary tree

    (nil)^          :-  true;
    (n(_,_,:l,:r))^ :-  #is.tree(:l), #is.tree(:r);
    (_)             :-  false;

}

btr.length { // how many nodes is there on a binary tree

    (nil,0)^            :-  true;
    (n(_,_,:l,:r),:n)   :-  #btr.length(:l,:l.n),
                            #btr.length(:r,:r.n),
                            sum(:l.n,:r.n,1,:n);

}
Fjölnir (pl, appeared 1986)
Creators: Snorri Agnarsson
Origin: University of Iceland
Country: Iceland


Fjölnir (also Fjolnir or Fjoelnir) is a programming language developed by professor Snorri Agnarsson of computer science at Háskóli Íslands (University of Iceland) that was mostly used in the 1980s. The source files usually have the extension fjo or sma.
FL (pl, appeared 1989)
Stands for: Function Level
Creators: John Backus
Origin: IBM
Country: United States


FL (short for Function Level) is a functional programming language created at the IBM Almaden Research Center by John Backus, John Williams, and Edward Wimmers in the 1980s and documented in a report from 1989. FL was designed as a successor of Backus' earlier FP language, providing specific support for what Backus termed function-level programming. FL is a dynamically typed strict functional programming language with throw and catch exception semantics much like in ML. Each function has an implicit history argument which is used for doing things like strictly functional input/output (I/O), but is also used for linking to C code. For doing optimization, there exists a type-system which is an extension of Hindley–Milner type inference. Many of the language’s innovative ideas have since been implemented in Kenneth E. Iverson’s J language.
FLACC (pl, appeared 1977)
Origin: Chion Corporation
Country: United States


FLACC is an implementation of the ALGOL 68 programming language. Chris Thomson and Colin Broughton founded Chion Corporation which developed and marketed FLACC (Full Language Algol 68 Checkout Compiler). This compiler and run-time system conformed exactly to the Revised Report, ran on IBM 370 and compatible mainframes, and included debugging features derived from WATFIV. It was released in 1977. Chris was a student of Barry J. Mailloux. Barry studied at Amsterdam's Mathematisch Centrum from 1966 under Adriaan van Wijngaarden. Barry's work on the Algol 68 language established the University of Alberta as a center for Algol 68-related activity. According to Thomson decade later:  You know, we only ever got 22 copies installed, and less than 5 of those in North America.  Even though it ran on 370's under MVS, CMS and MTS, and was cheap and reliable.  Talk about a marketing disaster.
flagship (pl, appeared 1986)
Origin: multisoft Datentechnik
Country: Germany
Website: http://www.flagship.de/




** File: hello1.prg         // your first program
? "Hello world!"            // similar to printf("\nHello world!")
wait                        // wait for user prompt before closing the application

** File: hello2.prg         // your second application
set color to "W+/B"         // set color white on blue
@ 5,10 TO 9,30              // draw box
@ 7,12 SAY "hello world"    // print text on given coordinates
key = inkey(5)              // wait for key press within 5 seconds

** File: dbf1.prg           // handles available/creates new database
#include "fspreset.fh"      // converts all file names to lower case
PARAMETER par1              // accepts command-line parameters 
dbname := IF(EMPTY(par1), "mydbf1", par1)       // set default if required 
IF .NOT. FILE(dbname + ".dbf")                  // database available?
  DBCREATE(dbname, {{"Name",    "C", 25, 0}, ;  //  not yet, so
                    {"Address", "C", 30, 0}, ;  //  create a new
                    {"Born",    "D",  8, 0}, ;  //  database, here
                    {"Note",    "M", 10, 0}} )  //  with 4 fields
ENDIF
USE (dbname) SHARED         // open the given database or mydbf1.dbf
IF !USED()                  // check the success
   ? "sorry, cannot open", dbname
   QUIT                     // abort the execution
ENDIF
BROWSE ()                   // browse/edit
QUIT                        // exit back to command line
flame-ir (ir, appeared 2015)
Origin: McGill University
Country: Canada
Website: https://github.com/jonathanvdc/flame

An intermediate representation (IR) in static single assignment (SSA) form. This type of IR is favored by state-of-the-art optimizing compilers such as LLVM and GCC. Flame IR is designed from the ground up with the express intent of making it as suitable as possible for a wide range of optimizations and analyses. Flame is a collection of C# libraries for building tools that read, analyze, optimize and write managed languages.


GitHub description: A compiler framework for managed code.
Flapjax (pl, appeared 2006)
Origin: Brown University
Country: United States
Website: http://www.flapjax-lang.org/


Flapjax is a programming language built on JavaScript. It provides a spreadsheet-like reactive programming, dataflow computing style, termed functional reactive programming, making it easy to create reactive web pages without the burden of callbacks and potentially inconsistent mutation. Flapjax can be viewed in two ways: either as a library, for use in regular JavaScript programs, or as a new language that the compiler converts into generic JavaScript. In either case, the resulting programs can be run in a regular web browser. Flapjax comes with persistent storage and a simple application programming interface (API) that masks the complexity of using Ajax, and sharing and access control (AC) for server data.It is free and open-source software released under a 3-clause BSD license. The Flapjax compiler is written in the language Haskell.
Flare (pl, appeared 2001)
Creators: Dmitriy Myshkin
Eliezer Yudkowsky
Mike Li
Michael Baj
Richard Walker
Origin: Singularity Institute for Artificial Intelligence
Website: https://flarelang.sourceforge.net

Flare is a proposal for the first "annotative" programming language.  In dialects of LISP, both the program and the program data are represented as lists.  In Flare, the program, program data, and ideally the program state, are all represented as well-formed XML.  Because XML is annotative (additional sub-elements can be easily added to any parent element without destroying the structural integrity of existing data) and extensible (new sub-element types can be easily created), these properties are shared by Flare objects and Flare programs.  This fundamental idiom enables a wide variety of new patterns, and should enable significantly greater modularity, cleanness, ease of adaptation, and so on.



<human>
 <name>Bob</name>
 <hands>2</hands>
 <legs>2</legs>
 <age>35.23</age>
</human>
Flatline (pl, appeared 2013)
Origin: BigML Inc
Country: United States
Website: http://bigmlcom.github.io/flatline

Flatline is a lispy language for the specification of values to be extracted or generated from an input dataset, using a finite sliding window of input rows.


GitHub description: Documentation, examples and utilities for Flatlline, BigML's dataset transformation and generation language

(if (missing? "00000") (random-value "000000") (f "000000"))
Flavors (pl, appeared 1980)
Origin: Massachusetts Institute of Technology
Country: United States


Flavors, an early object-oriented extension to Lisp developed by Howard Cannon at the MIT Artificial Intelligence Laboratory for the Lisp machine and its programming language Lisp Machine Lisp, was the first programming language to include mixins. Symbolics used it for its Lisp machines, and eventually developed it into New Flavors; both the original and new Flavors were message passing OO models. It was hugely influential in the development of the Common Lisp Object System (CLOS).Implementations of Flavors are also available for Common Lisp.New Flavors replaced message sending with calling generic functions. Flavors offers :before and :after daemons with the default method combination (called :daemon).