pldb/PLDB huggingface dataset:
basic calculator (pl, appeared 1975)
Stands for: basic calculator
Origin: Bell Labs
Country: United States


bc, for basic calculator (often referred to as bench calculator), is "an arbitrary-precision calculator language" with syntax similar to the C programming language. bc is typically used as either a mathematical scripting language or as an interactive mathematical shell. A typical interactive usage is typing the command bc on a Unix command prompt and entering a mathematical expression, such as (1 + 3) * 2, whereupon 8 will be output. While bc can work with arbitrary precision, it actually defaults to zero digits after the decimal point, so the expression 2/3 yields 0. This can surprise new bc users unaware of this fact. The -l option to bc sets the default scale (digits after the decimal point) to 20 and adds several additional mathematical functions to the language. bc first appeared in Version 6 Unix in 1975 and was written by Robert Morris and Lorinda Cherry of Bell Labs. bc was preceded by dc, an earlier arbitrary-precision calculator written by the same authors. dc could do arbitrary-precision calculations, but its reverse Polish notation (RPN) syntax was inconvenient for users, and therefore bc was written as a front-end to dc. bc was a very simple compiler (a single yacc source file with a few hundred lines), which converted the new, C-like, bc syntax into dc's postfix notation and piped the results through dc. In 1991, POSIX rigorously defined and standardized bc. Two implementations of this standard survive today: The first is the traditional Unix implementation, a front-end to dc, which survives in Unix and Plan 9 systems. The second is the free software GNU bc, first released in 1991 by Philip A. Nelson. The GNU implementation has numerous extensions beyond the POSIX standard and is no longer a front-end to dc (it is a bytecode interpreter).
BCPL (pl, appeared 1966)
Stands for: Basic Combined Programming Language
Creators: Martin Richards
Origin: University of Cambridge
Country: United Kingdom


BCPL ("Basic Combined Programming Language"; or 'Before C Programming Language' (a common humorous backronym) ) is a procedural, imperative, and structured computer programming language. Originally intended for writing compilers for other languages, BCPL is no longer in common use. However, its influence is still felt because a stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. BCPL introduced several features of modern programming languages, including using curly braces to delimit code blocks; compilation via virtual machine byte code; and the world's first 'hello world' demonstrator program.


GET "LIBHDR"

LET START() = VALOF $(
        FOR I = 1 TO 5 DO
                WRITEF("%N! = %I4*N", I, FACT(I))
        RESULTIS 0
$)

AND FACT(N) = N = 0 -> 1, N * FACT(N - 1)
BCX (pl, appeared 1999)
Creators: Kevin Diggins
Robert Wishlaw
Origin: https://sourceforge.net/p/bcx-basic/discussion
Country: Unknown


BCX is a free software programming development application originally created in 1999 by Kevin Diggins.  BCX converts BASIC source code to C/C++ source code which can then be compiled using any one of a number of available Microsoft Win32 C/C++ compilers. For many years, most implementations of BASIC shared a nagging drawback - the programs that users created performed slower than similar programs that were created using C/C++.  BCX changed that by giving users the friendliness and ease of use of the BASIC language and coupled it with the high performance and flexibility of C/C++. BCX is written in the BCX BASIC language, making BCX a self-translating translator. BCX was made an open source project in 2004. Since then, several members of the BCX community have led the continued development and maintenance of BCX. Recent project forks have resulted in variants of BCX that can produce native-code applications that run on Linux and Apple operating systems. BCX contains verbs that simplify the creation of Windows UI desktop applications. Unlike many BASIC implementations that rely on run-time engines, the combination of BCX and most C/C++ compilers produce efficient and performant native code applications. BCX can be used to create GUI, DLL, console mode, and web server applications. BCX can use the Standard C Library.
BEAM Erlang virtual machine (vm, appeared 2011)
Stands for: Bogdan's Erlang Abstract Machine
Creators: Bogumil Hausman
Origin: Ericsson
Country: Sweden


BEAM is the virtual machine at the core of the Erlang Open Telecom Platform (OTP). BEAM is part of the Erlang Run-Time System (ERTS), which compiles Erlang and Elixir source code into bytecode, which is then executed on the BEAM. BEAM bytecode files have the .beam file extension.Originally BEAM was short for Bogdan's Erlang Abstract Machine, named after Bogumil "Bogdan" Hausman, who wrote the original version, but the name may also be referred to as Björn's Erlang Abstract Machine, after Björn Gustavsson, who wrote and maintains the current version. Both developers worked on the system while at Ericsson.
beautiful-report-language (pl, appeared 2003)
Also known as: BRL
Website: http://brl.sourceforge.net/




[(define myname "Bruce")
(define my "Bruce's")]

<pre>
This is [my] web page.
[myname myname
 myname myname]

[my] favorite person is [[your name here].
[my] favorite number is [(brl-random 2)].
</pre>
BeBasic (pl, appeared 2009)
Creators: BBK
Origin: polymer-china
Country: China
Website: https://github.com/wenerme/bbvm



GitHub description: BeBasic Virtual Machine

; ____________________
; \______   \______   \___  _______
;  |    |  _/|    |  _/\  \/ /     \
;  |    |   \|    |   \ \   /  Y Y  \
;  |______  /|______  /  \_/|__|_|  /
;         \/        \/            \/

JMP CODE
DATA STR CHAR "Hello, BBvm",0
CODE:

OUT 1, STR
EXIT
Browser Extensible Data Format (textDataFormat, appeared 2004)
Stands for: Browser Extensible Data
Origin: University of California Santa Cruz
Country: United States

BED (Browser Extensible Data) format provides a flexible way to define the data lines that are displayed in an annotation track. BED lines have three required fields and nine additional optional fields. The number of fields per line must be consistent throughout any single set of data in an annotation track. The order of the optional fields is binding: lower-numbered fields must always be populated if higher-numbered fields are used.



track name=pairedReads description="Clone Paired Reads" useScore=1
chr22 1000 5000 cloneA 960 + 1000 5000 0 2 567,488, 0,3512
chr22 2000 6000 cloneB 900 - 2000 6000 0 2 433,399, 0,3601
BEFLIX (pl, appeared 1963)
Origin: Bell Labs
Country: United States


BEFLIX is the name of the first embedded domain-specific language for computer animation, invented by Ken Knowlton at Bell Labs in 1963. The name derives from a combination of Bell Flicks. Ken Knowlton used BEFLIX to create animated films for educational and engineering purposes. He also collaborated with the artist Stan Vanderbeek at Bell Labs to create a series of computer-animated films called Poemfields between 1966 and 1969. BEFLIX was developed on the IBM 7090 mainframe computer using a Stromberg-Carlson SC2040 microfilm recorder for output. The programming environment targeted by BEFLIX consisted of a FORTRAN II implementation with FORTRAN II Assembly Program (FAP) macros.  The first version of BEFLIX was implemented through the FAP macro facility.  A later version targeting FORTRAN IV resembled a more traditional subroutine library and lost some of the unique flavor to the language. Pixels are produced by writing characters to the screen of the microfilm recorder with a defocused electron beam. The SC2040 used a charactron tube to expose microfilm.  In BEFLIX, the electron beam is defocused to draw pixels as blurred character shapes.  Characters are selected to create a range of grayscale values for pixels. The microfilm recorder is not connected directly to the 7090, but communicates through magnetic tape.  BEFLIX writes the magnetic tape output on the 7090 and the film recorder reads the tape to create the film output.  BEFLIX also supports a preview mode where selected frames of the output are written to the line printer.
Befunge (esolang, appeared 1993)
Creators: Chris Pressey
Origin: Cat's Eye Technologies
Country: United States


Befunge is a stack-based, reflective, esoteric programming language. It differs from conventional languages in that programs are arranged on a two-dimensional grid. "Arrow" instructions direct the control flow to the left, right, up or down, and loops are constructed by sending the control flow in a cycle. It has been described as "a cross between Forth and Lemmings."  A worthy companion to INTERCAL; a computer language family which escapes the quotidian limitation of linear control flow and embraces program counters flying through multiple dimensions with exotic topologies.
BML (xmlFormat, appeared 2007)
Stands for: Behavior Markup Language
Origin: Communicative Machines
Country: Various
Website: http://www.mindmakers.org/projects/bml-1-0/wiki




<bml>
 <speech id=”s1” type=”application/ssml+xml”>
  <text>This is an <mark name=”wb3”> example</text>
 </speech>
 <head id=”h1” type=”NOD” stroke=”s1:start”/>
 <gesture id=”g1” stroke=”s1:wb3” relax=”s1:end” type=”BEAT”>
  <description level=”1” type=”MURML”>...
  </description>
 </gesture>
  <gaze id=”z1” target=”PERSON1” stroke=”g1:stroke-0.1”/>
  <body id=”p1” posture=”RELAXED” start=”after(s1:end)”/>
  <cadia:operate target=”SWITCH1” stroke=”p1:ready”/>
</bml>
Bel (pl, appeared 2019)
Creators: Paul Graham
Country: United States
Website: http://paulgraham.com/bel.html




; Bel in Bel. 9 October 2019, 9:14 GMT
(def no (x)
  (id x nil))
(def atom (x)
  (no (id (type x) 'pair)))
(def all (f xs)
  (if (no xs)      t
      (f (car xs)) (all f (cdr xs))
                   nil))
(def some (f xs)
  (if (no xs)      nil
      (f (car xs)) xs
                   (some f (cdr xs))))
(def reduce (f xs)
  (if (no (cdr xs))
      (car xs)
      (f (car xs) (reduce f (cdr xs)))))
(def cons args
  (reduce join args))
(def append args
  (if (no (cdr args)) (car args)
      (no (car args)) (apply append (cdr args))
                      (cons (car (car args))
                            (apply append (cdr (car args))
                                          (cdr args)))))
Berkeley DB (library, appeared 1994)
Origin: Sleepycat Software
Oracle Corporation
Country: United States


Berkeley DB (BDB) is a software library intended to provide a high-performance embedded database for key/value data. Berkeley DB is written in C with API bindings for C++, C#, Java, Perl, PHP, Python, Ruby, Smalltalk, Tcl, and many other programming languages. BDB stores arbitrary key/data pairs as byte arrays, and supports multiple data items for a single key. Berkeley DB is not a relational database.BDB can support thousands of simultaneous threads of control or concurrent processes manipulating databases as large as 256 terabytes, on a wide variety of operating systems including most Unix-like and Windows systems, and real-time operating systems.  BDB was commercially supported and developed by Sleepycat Software from 1996 to 2006.  This company was acquired by Oracle Corporation in February 2006, which continues to develop and sell Berkeley DB.  Under Oracle's stewardship, "Berkeley DB" has become a common brand name for three distinct products: Oracle Berkeley DB, Berkeley DB Java Edition, and Berkeley DB XML.  These three products all share a common ancestry and are currently under active development.
Berkeley DB (library, appeared 1991)
Origin: Sleepycat Software, Inc.
Country: United States

The Berkeley Database (Berkeley DB) is an embedded database system that can be used in applications requiring high-performance concurrent storage and retrieval of key/value pairs. The software is distributed as a library that can be linked directly into an application. It provides a variety of programmatic interfaces, including callable APIs for C, C++, Perl, Tcl and Java. Users may download Berkeley DB from Sleepycat Software’s Web site, at www.sleepycat.com.
Berry (pl, appeared 2018)
Creators: 官文亮
Origin: https://github.com/berry-lang/
Country: China
Website: https://github.com/berry-lang/berry

Berry is a ultra-lightweight dynamically typed embedded scripting language. It is designed for lower-performance embedded devices. The Berry interpreter-core's code size is less than 40KiB and can run on less than 4KiB heap (on ARM Cortex M4 CPU, Thumb ISA and ARMCC compiler).


GitHub description: A ultra-lightweight embedded scripting language optimized for microcontrollers.

def fib(x)
    if (x <= 1)
        return x
    end
    return fib(x - 1) + fib(x - 2)
end
Beta BASIC (pl, appeared 1983)
Origin: BetaSoft
Country: United States


Beta BASIC is a BASIC interpreter for the Sinclair Research ZX Spectrum microcomputer, written by Dr Andy Wright in 1983 and sold by his one-man software house BetaSoft. BetaSoft also produced a regular newsletter/magazine, BetaNews. Originally it started as a BASIC toolkit but over time it grew into a full replacement.
BETA Project (grammarLanguage, appeared 1961)
Origin: USSR Academy of Information Sciences
Country: Russia

The promising 'BETA project'' in Novosibirsk primarily designed by Dr. A. P. Ershov, M. Shvartsman, A. A. Baehrs was intended to produce compilers from language descriptions almost automatically, and it had Algol 68, PL/I and Simula 67 as its first objectives
BETA (pl, appeared 1983)
Creators: Bent Bruun Kristensen
Ole Lehrmann Madsen
Birger Møller-Pedersen
Kristen Nygaard
Origin: Scandinavian School of object- orientation
Country: Norway
Website: http://cs.au.dk/~beta


BETA is a pure object-oriented language originating within the "Scandinavian School" in object-orientation where the first object-oriented language Simula was developed. Among its notable features, it introduced nested classes, and unified classes with procedures into so called patterns.
BibTeX (application, appeared 1985)
Origin: The TeX Users Group
Country: United States
Website: https://www.ctan.org/pkg/bibtex
File extensions: bib


BibTeX is reference management software for formatting lists of references. The BibTeX tool is typically used together with the LaTeX document preparation system. Within the typesetting system, its name is styled as                                                 B                                                                I                   B                                                                       T                                                                               E                                                                       X                                     {\displaystyle {\mathrm {B{\scriptstyle {IB}}\!T\!_{\displaystyle E}\!X} }}   . The name is a portmanteau of the word bibliography and the name of the TeX typesetting software. The purpose of BibTeX is to make it easy to cite sources in a consistent manner, by separating bibliographic information from the presentation of this information, similarly to the separation of content and presentation/style supported by LaTeX itself.


 @inproceedings{Gousi13,
  author = {Gousios, Georgios},
  title = {The GHTorrent dataset and tool suite},
  booktitle = {Proceedings of the 10th Working Conference on Mining Software
    Repositories},
  series = {MSR '13},
  year = {2013},
  isbn = {978-1-4673-2936-1},
  location = {San Francisco, CA, USA},
  pages = {233--236},
  numpages = {4},
  url = {http://dl.acm.org/citation.cfm?id=2487085.2487132},
  acmid = {2487132},
  publisher = {IEEE Press},
  address = {Piscataway, NJ, USA},
 }
Bicep (jsonFormat, appeared 2020)
Creators: Anthony Martin
Origin: Microsoft
Keywords: targetScope
resource
module
param
var
output
for
in
if
existing

Bicep is a Domain Specific Language (DSL) for deploying Azure resources declaratively.


GitHub description: Bicep is a declarative language for describing and deploying Azure resources

@minLength(3)
@maxLength(11)
param storagePrefix string

param storageSKU string = 'Standard_LRS'
param location string = resourceGroup().location

var uniqueStorageName = '${storagePrefix}${uniqueString(resourceGroup().id)}'

resource stg 'Microsoft.Storage/storageAccounts@2019-04-01' = {
  name: uniqueStorageName
  location: location
  sku: {
    name: storageSKU
  }
  kind: 'StorageV2'
  properties: {
    supportsHttpsTrafficOnly: true
  }
}

module webModule './webApp.bicep' = {
  name: 'webDeploy'
  params: {
    skuName: 'S1'
    location: location
  }
}

output storageEndpoint object = stg.properties.primaryEndpoints
bigWig format (binaryDataFormat, appeared 2009)
Origin: University of California, Santa Cruz
Country: United States

The bigWig format is the recommended format for almost all graphing track needs. The bigWig format is useful for dense, continuous data that will be displayed in the Genome Browser as a graph. BigWig files are created from wiggle (wig) type files using the program wigToBigWig. bigWig files are indexed binary files.
Binary notation (notation, appeared 1689)
Creators: Gottfried Leibniz


A binary code represents text, computer processor instructions, or any other data using a two-symbol system. The two-symbol system used is often "0" and "1" from the binary number system. The binary code assigns a pattern of binary digits, also known as bits, to each character, instruction, etc. For example, a binary string of eight bits can represent any of 256 possible values and can, therefore, represent a wide variety of different items. In computing and telecommunications, binary codes are used for various methods of encoding data, such as character strings, into bit strings. Those methods may use fixed-width or variable-width strings. In a fixed-width binary code, each letter, digit, or other character is represented by a bit string of the same length; that bit string, interpreted as a binary number, is usually displayed in code tables in octal, decimal or hexadecimal notation. There are many character sets and many character encodings for them. A bit string, interpreted as a binary number, can be translated into a decimal number. For example, the lower case a, if represented by the bit string 01100001 (as it is in the standard ASCII code), can also be represented as the decimal number "97".
BIND (application, appeared 2000)
Origin: Internet Systems Consortium
Country: United States


BIND (), or named (pronounced name-dee, short for name daemon: ), is the most widely used Domain Name System (DNS) software on the Internet. |  On Unix-like operating systems it is the de facto standard. It performs both of the main DNS server roles - acting as an authoritative name server for one or more specific domains, and acting as a recursive resolver for the DNS system generally. The software was originally designed at the University of California, Berkeley (UCB) in the early 1980s. The name originates as an acronym of Berkeley Internet Name Domain, reflecting the application's use within UCB. The software consists, most prominently, of the DNS server component, called named, a contracted form of name daemon. In addition the suite contains various administration tools, and a DNS resolver interface library. The latest version of BIND is BIND 9, first released in 2000. BIND 9 is actively maintained, with new releases issued several times a year. Starting in 2009, the Internet Software Consortium (ISC) developed a new software suite, initially called BIND10. With release version 1.2.0 the project was renamed Bundy to terminate ISC involvement in the project.
bioscript (pl, appeared 2019)
Origin: University of California, Riverside
Country: United States

This paper introduces BioScript, a domain-specific language (DSL) for programmable biochemistry which executes on emerging microfluidic platforms. The goal of this research is to provide a simple, intuitive, and type-safe DSL that is accessible to life science practitioners. The novel feature of the language is its syntax, which aims to optimize human readability; the technical contributions of the paper include the BioScript type system and relevant portions of its compiler. The type system ensures that certain types of errors, specific to biochemistry, do not occur, including the interaction of chemicals that may be unsafe. The compiler includes novel optimizations that place biochemical operations to execute concurrently on a spatial 2D array platform on the granularity of a control flow graph, as opposed to individual basic blocks. Results are obtained using both a cycle-accurate microfluidic simulator and a software interface to a real-world platform.



/* Initialization Omitted */
2 mixture = mix 10 uL of water with
3 10 uL of blood for 10 s
4 heat mixture at 100 C for 10 s
Bison (grammarLanguage, appeared 1985)
Creators: Robert Corbett
Origin: GNU Project
Country: United States
Website: https://www.gnu.org/software/bison/


GNU bison, commonly known as Bison, is a parser generator that is part of the GNU Project. Bison reads a specification of a context-free language, warns about any parsing ambiguities, and generates a parser (either in C, C++, or Java) which reads sequences of tokens and decides whether the sequence conforms to the syntax specified by the grammar. Bison by default generates LALR parsers but can also create GLR parsers. In POSIX mode, Bison is compatible with yacc, but also has several extensions over this earlier program. flex, an automatic lexical analyser, is often used with Bison, to tokenise input data and provide Bison with tokens. Bison was originally written by Robert Corbett in 1985. Later, in 1989, Robert Corbett released another parser generator named Berkeley Yacc. Bison was made Yacc-compatible by Richard Stallman. Bison is free software and is available under the GNU General Public License, with an exception (discussed below) allowing its generated code to be used without triggering the copyleft requirements of the licence.


/* Reverse Polish Notation calculator. */

%{
  #include <stdio.h>
  #include <math.h>
  int yylex (void);
  void yyerror (char const *);
%}

%define api.value.type {double}
%token NUM

%% /* Grammar rules and actions follow. */
Bistro (pl, appeared 1999)
Creators: Nikolas S. Boyd
Origin: University of California, Berkeley
Country: United States
Website: https://bitbucket.org/nik_boyd/bistro-smalltalk

Bistro is a variation of Smalltalk that integrates the best features of Smalltalk and Java. Bistro Smalltalk is an experimental programming language that runs on the Java Virtual Machine, or JVM.
BitBake (pl, appeared 2004)
Origin: Yocto Project
Country: Various
Website: https://yoctoproject.org/tools-resources/projects/bitbake


BitBake is a make-like  build tool with the special focus of distributions and packages for embedded Linux cross compilation, although it is not limited to that. It is inspired by Portage, which is the package management system used by the Gentoo Linux distribution. BitBake existed for some time in the OpenEmbedded project until it was separated out into a standalone, maintained, distribution-independent tool. BitBake is co-maintained by the Yocto Project and the OpenEmbedded project. BitBake recipes specify how a particular package is built. Recipes consist of the source URL (http, https, ftp, cvs, svn, git, local file system) of the package, dependencies and compile or install options. They also store the metadata for the package in standard variables. During the build process, recipes are used to track dependencies, performing native or cross-compilation of the package and package it so that it is suitable for installation on the local or a target device. It is also possible to create complete images consisting of a root file system and kernel. As a first step in a cross-build setup, the framework will attempt to create a cross-compiler toolchain suited for the target platform.


require qt5-git.inc
require ${PN}.inc

do_install_append() {
    # for modules which are still using syncqt and call qtPrepareTool(QMAKE_SYNCQT, syncqt)
    # e.g. qt3d, qtwayland
    ln -sf syncqt.pl ${D}${OE_QMAKE_PATH_QT_BINS}/syncqt
}

QT_MODULE_BRANCH = "release"
# v5.2.1 + 168 commits
SRCREV = "08cbbde61778276ccdda73d89fd64d02c623779f"