pldb/PLDB huggingface dataset:
lambda-obliv (pl, appeared 2020)
Origin: University of Vermont
University of Maryland
Citadel Securities
Country: United States

A Language for Probabilistically Oblivious Computation. An oblivious computation is one that is free of direct and indirect information leaks, e.g., due to observable differences in timing and memory access patterns. This paper presents λobliv, a core language whose type system enforces obliviousness. Prior work on type-enforced oblivious computation has focused on deterministic programs. λobliv is new in its consideration of programs that implement probabilistic algorithms, such as those involved in cryptography. λobliv employs a substructural type system and a novel notion of probability region to ensure that information is not leaked via the observed distribution of visible events. Probability regions support reasoning about probabilistic correlation and independence between values, and our use of probability regions is motivated by a source of unsoundness that we discovered in the type system of ObliVM, a language for implementing state of the art oblivious algorithms.
ΛProlog (pl, appeared 1986)
Origin: École polytechnique
Country: France


λProlog, also written lambda Prolog, is a logic programming language featuring polymorphic typing, modular programming, and higher-order programming.  These extensions to Prolog are derived from the higher-order hereditary Harrop formulas used to justify the foundations of λProlog.  Higher-order quantification, simply typed λ-terms, and higher-order unification gives λProlog the basic supports needed to capture the λ-tree syntax approach to higher-order abstract syntax, an approach to representing syntax that maps object-level bindings to programming language bindings.  Programmers in λProlog need not deal with bound variable names: instead various declarative devices are available to deal with binder scopes and their instantiations.  Since 1986, λProlog has received numerous implementations.  As of 2013, the language and its implementations are still actively being developed. The Abella theorem prover has been designed to provide an interactive environment for proving theorems about the declarative core of λProlog.
Large-scale Atomic/Molecular Massively Parallel Simulator Format (application, appeared 1995)
Stands for: Large-scale Atomic/Molecular Massively Parallel Simulator Format
Origin: Sandia National Laboratories
Temple University
Country: United States




# 2d LJ crack simulation

dimension 2
boundary  s s p

atom_style  atomic
neighbor  0.3 bin
neigh_modify  delay 5

# create geometry

lattice   hex 0.93
region    box block 0 100 0 40 -0.25 0.25
create_box  5 box
create_atoms  1 box

mass    1 1.0
mass    2 1.0
mass    3 1.0
mass    4 1.0
mass    5 1.0

# LJ potentials

pair_style  lj/cut 2.5
pair_coeff  * * 1.0 1.0 2.5

# define groups

region          1 block INF INF INF 1.25 INF INF
group   lower region 1
region    2 block INF INF 38.75 INF INF INF
group   upper region 2
group   boundary union lower upper
group   mobile subtract all boundary

region    leftupper block INF 20 20 INF INF INF
region    leftlower block INF 20 INF 20 INF INF
group   leftupper region leftupper
group   leftlower region leftlower

set   group leftupper type 2
set   group leftlower type 3
set   group lower type 4
set   group upper type 5

# initial velocities

compute     new mobile temp
velocity  mobile create 0.01 887723 temp new
velocity  upper set 0.0 0.3 0.0
velocity  mobile ramp vy 0.0 0.3 y 1.25 38.75 sum yes

# fixes

fix   1 all nve
fix   2 boundary setforce NULL 0.0 0.0

# run

timestep  0.003
thermo    200
thermo_modify temp new

neigh_modify  exclude type 2 3

#dump   1 all atom 500 dump.crack

#dump   2 all image 250 image.*.jpg type type &
#   zoom 1.6 adiam 1.5
#dump_modify  2 pad 4

#dump   3 all movie 250 movie.mpg type type &
#   zoom 1.6 adiam 1.5
#dump_modify  3 pad 4

run   5000
Laning and Zierler system (pl, appeared 1953)
Origin: Massachusetts Institute of Technology
Country: United States


The Laning and Zierler system (sometimes called "George" by its users) was one of the first operating algebraic compilers, that is, a system capable of accepting mathematical formulae in algebraic notation and producing equivalent machine code (the term compiler had not yet been invented and the system was referred to as "an interpretive program"). It was implemented in 1952 for the MIT WHIRLWIND by J. Halcombe Laning and Neal Zierler. It is preceded by the UNIVAC A-2, IBM Speedcoding and a number of systems that were proposed but never implemented.
Laravel (framework, appeared 2011)
Origin: Laravel LLC
Country: Various


Laravel is a free, open-source PHP web framework, created by Taylor Otwell and intended for the development of web applications following the model–view–controller (MVC) architectural pattern and based on Symfony.  Some of the features of Laravel are a modular packaging system with a dedicated dependency manager, different ways for accessing relational databases, utilities that aid in application deployment and maintenance, and its orientation toward syntactic sugar.The source code of Laravel is hosted on GitHub and licensed under the terms of MIT License.
Larceny Scheme implementation (pl, appeared 2017)
Origin: University of Oregon
Country: United States


Larceny is an implementation of the Scheme programming language built around the Twobit optimizing compiler. Larceny offers several back-ends able to target native x86 and ARMv7 code.  Petit Larceny is also available and emits C source code, which can then be further compiled to native code with an ordinary C compiler.Older versions (<0.98) included support for the SPARC architecture in Larceny, and for Microsoft's Common Language Runtime via Common Larceny.Larceny supports all major Scheme standards (R5RS, IEEE/ANSI, R6RS, and R7RS.  The Larceny software is open source and available online.
LARP (pl, appeared 2003)
Creators: Marco Lavoie
Origin: https://web.archive.org/web/20200220111251/http://larp.marcolavoie.ca/en/techsupport/bugs_suggestions.htm
Country: Canada
Website: http://www.marcolavoie.ca/larp/en/default.htm

LARP is an educational software for teaching algorithmic in structured programming using pseudo code and flowcharts. LARP's main advantage over traditional programming languages is its flexible and semi natural syntax, allowing one to formulate algorithms without the impediments of cryptic languages such as C++, Pascal or Java.



\\ Simple pseudo code
START
   WRITE "Enter a number"
   READ N

   IF N < 0 THEN
       WRITE "Negative number"
   ELSE
       WRITE "Positive number"
   ENDIF
END
Lasso (pl, appeared 1995)
Creators: Kyle Jessup
Origin: LassoSoft Inc
Country: Canada
Website: http://www.lassosoft.com
File extensions: lasso
LassoApp


Lasso is an application server and server management interface used to develop internet applications and is a general-purpose, high-level programming language. Originally a web datasource connection tool, for Filemaker and later included in Apple Computer's FileMaker 4.0 and Claris Homepage as CDML, it has since evolved into a complex language used to develop and serve large-scale internet applications and web pages. Lasso includes a simple template system allowing code to control generation of HTML and other content types. Lasso is object-oriented and every value is an object. It also supports procedural programming through unbound methods. The language uses traits and multiple dispatch extensively. Lasso has a dynamic type system, where objects can be loaded and augmented at runtime, automatic memory management, a comprehensive standard library, and three compiling methodologies: dynamic (comparable to PHP-Python), just-in-time compilation (comparable to Java or .NET Framework), and pre-compiled (comparable to C). Lasso also supports Query Expressions, allowing elements within arrays and other types of sequences to be iterated, filtered, and manipulated using a natural language syntax similar to SQL. Lasso includes full Unicode character support in the standard string object, allowing it to serve and support multi-byte characters such as Japanese and Swedish, and supports transparent UTF-8 conversion when writing string data to the network or file system. Lasso is often used as a scripting language, and also used in a wide range of non-scripting contexts. Lasso code can be packaged into standalone executable programs called "LassoApps", in which folder structures are compiled into single files. The Lasso Server application server runs as a system service and receives requests from the web server through FastCGI. It then hands the request off to the appropriate Lasso Instance, which formulates the response. Multiple individual instances are supported, allowing one server to handle multiple sites, each as separate processes. The server uses a high performance IO-based green threading system designed for multi-core systems. Lasso can be compared to the server-side scripting languages PHP and Python, ColdFusion, Ruby, etc. Free for development, Lasso allows partial access to its source code, allowing developers to add or change major components of the language (for example, Ke Carlton's DS implementation of the Lasso Inline). Licensing comes in both SAS and stand-alone versions.
LaTeX (textMarkup, appeared 1985)
Origin: https://www.latex-project.org/about/team/
Country: United States
Website: http://latex-project.org/


LaTeX (IPA: , LAH-tekh, also pronounced as , LAY-tekh, a shortening of Lamport TeX) is a document preparation system. When writing, the writer uses plain text as opposed to the formatted text found in WYSIWYG word processors like Microsoft Word, LibreOffice Writer and Apple Pages. The writer uses markup tagging conventions to define the general structure of a document (such as article, book, and letter), to stylise text throughout a document (such as bold and italics), and to add citations and cross-references. A TeX distribution such as TeX Live or MikTeX is used to produce an output file (such as PDF or DVI) suitable for printing or digital distribution. Within the typesetting system, its name is stylised as LaTeX. LaTeX is widely used in academia for the communication and publication of scientific documents in many fields, including mathematics, statistics, computer science, engineering, chemistry, physics, economics, linguistics, quantitative psychology, philosophy, and political science. It also has a prominent role in the preparation and publication of books and articles that contain complex multilingual materials, such as Tamil, Sanskrit and Greek. LaTeX uses the TeX typesetting program for formatting its output, and is itself written in the TeX macro language. LaTeX can be used as a standalone document preparation system or as an intermediate format. In the latter role, for example, it is sometimes used as part of a pipeline for translating DocBook and other XML-based formats to PDF. The typesetting system offers programmable desktop publishing features and extensive facilities for automating most aspects of typesetting and desktop publishing, including numbering and cross-referencing of tables and figures, chapter and section headings, the inclusion of graphics, page layout, indexing and bibliographies. Like TeX, LaTeX started as a writing tool for mathematicians and computer scientists, but from early in its development it has also been taken up by scholars who needed to write documents that include complex math expressions or non-Latin scripts, such as Arabic, Sanskrit and Chinese. LaTeX is intended to provide a high-level language that accesses the power of TeX in an easier way for writers. In short, TeX handles the layout side, while LaTeX handles the content side for document processing. LaTeX comprises a collection of TeX macros and a program to process LaTeX documents. Because the plain TeX formatting commands are elementary, it provides authors with ready-made commands for formatting and layout requirements such as chapter headings, footnotes, cross-references and bibliographies. LaTeX was originally written in the early 1980s by Leslie Lamport at SRI International. The current version is LaTeX2e (stylised as LaTeX2ε). LaTeX is free software and is distributed under the LaTeX Project Public License (LPPL).
lav-format (textDataFormat, appeared 2004)
Origin: The Pennsylvania State University
Country: United States
Website: http://www.bx.psu.edu/miller_lab/dist/lav_format.html

LAV is a plain-text file format for alignments of two DNA sequences. It is the only output format produced by the BLASTZ alignment program (though often converted to AXT format by post-processing programs), and is the default output format for BLASTZ's successor, LASTZ.



#:lav
   d {
     "lastz.v0.3 malus.fa aurantium.fa C=2 W=8 T=0 
        A    C    G    T
       91 -114  -31 -123
     -114  100 -125  -31
      -31 -125  100 -114
     -123  -31 -114   91
     O = 400, E = 30, K = 3000, L = 3000, M = 0"
   }
   #:lav
   s {
     "malus.fa" 1 191411218 0 1
     "aurantium.fa" 1 90634903 0 1
   }
   h {
     "> apple"
     "> orange"
   }
   a {
     s 20643
     b 46566766 2083211
     e 46567353 2083795
     l 46566766 2083211 46566796 2083241 61
     l 46566797 2083245 46566814 2083262 78
     l 46566821 2083263 46567353 2083795 65
   }
   a {
     s 4233
     b 47246530 10635696
     e 47246660 10635826
     l 47246530 10635696 47246660 10635826 63
   }
Lava (pl, appeared 2001)
Origin: Institute for Secure Telecooperation
Country: Germany


Lava is an experimental, visual object-oriented, interpreter-based programming language with an associated programming environment (Lava Programming Environment or LavaPE) that uses structure editors instead of text editors. Only comments, constants, and new identifiers may be entered as text. Declarations are represented in LavaPE as tree structures whose subtrees may be collapsed or expanded. The properties of the declared Lava entities can be edited through pop-up dialogs. Although executable code has a traditional text representation in LavaPE, it can be edited only as complete syntactic units, rather than character by character. If you insert a new syntactic construct, it will typically contain "placeholders" (syntactic variables) that can then be replaced by concrete constructs; the latter may in turn contain syntactic variables, etc. LavaPE provides a tool button for every type of syntactic construct, and a button is enabled only if it is syntactically correct to insert the associated construct at the selected place. Further characteristic properties of Lava and LavaPE include the following:  It provides strict syntactic separation of interface (public) and implementation (private) sections of a Lava class. It distinguishes variable "state objects" from constant "value objects"; the latter cannot be modified any longer after creation/initialization. It supports "virtual types": type parameters of classes and packages (families of related classes). As a consequence, undermining of strong type checks by "type casts" is no longer required. It uses recursion and logical quantifiers instead of traditional loop constructs. It uses single assignment; i.e., a value can be assigned to a variable only once within the same branch of a function. It supports refactoring extensively via the LavaPE structure editors. It distinguishes between constituents (sub-objects) and object acquaintances (pointers to independent objects). Copying and deletion of complex objects is largely facilitated in this way. Since release 0.9.0, LavaPE completely prevents inadvertent access to uninitialized variables and null objects already at programming time by complete static initialization checks.Lava is open source software using the GPL license (see also Lava at the Free Software Foundation and at KDE-Apps.org). It currently runs on Microsoft Windows, Linux and Mac OS X platforms.
Lazy K (esolang, appeared 2002)
Also known as: lazyk
Origin: https://tromp.github.io/
Country: The Netherlands
Website: https://tromp.github.io/cl/lazy-k.html

Lazy K is a garbage-collected, referentially transparent functional programming language, with a simple stream-based I/O system. What distinguishes Lazy K from other such languages is its almost total lack of other features.
Lazy ML (pl, appeared 1980)
Origin: Chalmers University of Technology
Country: Sweden


Lazy ML (LML) is a functional programming language developed in the early 1980s by Lennart Augustsson and Thomas Johnsson at Chalmers University of Technology, prior to Miranda and Haskell. LML is a strongly typed, statically scoped implementation of ML, with lazy evaluation. The key innovation of LML was to demonstrate how to compile a lazy functional language. Until then, lazy languages had been implemented via interpreted graph reduction. LML compiled to G-machine code. LML is also notable as the language in which HBC, the Haskell B Compiler, was implemented.
LC-3 (pl, appeared 2003)
Origin: University of Texas at Austin
University of Illinois at Urbana–Champaign
Country: United States


Little Computer 3, or LC-3, is a type of computer educational programming language, an assembly language, which is a type of low-level programming language. It features a relatively simple instruction set, but can be used to write moderately complex assembly programs, and is a theoretically viable target for a C compiler. The language is less complex than x86 assembly but has many features similar to those in more complex languages. These features make it useful for beginning instruction, so it is most often used to teach fundamentals of programming and computer architecture to computer science and computer engineering students. The LC-3 was developed by Yale N. Patt at the University of Texas at Austin and Sanjay J. Patel at the University of Illinois at Urbana–Champaign. Their specification of the instruction set, the overall architecture of the LC-3, and a hardware implementation can be found in the second edition of their textbook. Courses based on the LC-3 and Patt and Patel's book are offered in many computer engineering and computer science departments.
JSON Lines (dataNotation, appeared 2013)
Also known as: newline-delimited JSON
Creators: Ian Ward
Origin: https://github.com/wardi/jsonlines/issues
Country: Canada
Website: http://jsonlines.org/
File extensions: ldj
jsonl

JSON Lines is a convenient format for storing structured data that may be processed one record at a time. It works well with unix-style text processing tools and shell pipelines. It's a great format for log files. It's also a flexible format for passing messages between cooperating processes.


GitHub description: Documentation for the JSON Lines text file format

["Name", "Session", "Score", "Completed"]
["Gilbert", "2013", 24, true]
["Alexa", "2013", 29, true]
["May", "2012B", 14, false]
["Deloise", "2012A", 19, true]
Lightweight Directory Access Protocol (protocol, appeared 1997)
Origin: University of Michigan
Isode Limited
Performance Systems International
Country: United States


The Lightweight Directory Access Protocol  (LDAP ) is an open, vendor-neutral, industry standard application protocol for accessing and maintaining distributed directory information services over an Internet Protocol (IP) network.  Directory services play an important role in developing intranet and Internet applications by allowing the sharing of information about users, systems, networks, services, and applications throughout the network.  As examples, directory services may provide any organized set of records, often with a hierarchical structure, such as a corporate email directory.  Similarly, a telephone directory is a list of subscribers with an address and a phone number. LDAP is specified in a series of Internet Engineering Task Force (IETF) Standard Track publications called Request for Comments (RFCs), using the description language ASN.1. The latest specification is Version 3, published as RFC 4511 (a road map to the technical specifications is provided by RFC4510). A common use of LDAP is to provide a central place to store usernames and passwords. This allows many different applications and services to connect to the LDAP server to validate users.LDAP is based on a simpler subset of the standards contained within the X.500 standard.  Because of this relationship, LDAP is sometimes called X.500-lite.
ldpl (pl, appeared 2019)
Creators: Martín del Río
Origin: https://github.com/Lartu/ldpl/issues
Country: Unknown
Website: https://www.ldpl-lang.org



GitHub description: Compiled programming language for Unix systems, inspired by COBOL and designed to be expressive, fast, readable and easy to learn.

# Hello There Example
data: 
  name is number

procedure: 
  display "Hello there, what's your name?"
  accept name
  display "你好, " name "!" crlf
Le-Lisp (pl, appeared 1984)
Origin: Institut national de recherche en sciences et technologies du numérique
Centre de Mathmatiques Appliques
Country: France


Le Lisp (also Le_Lisp and Le-Lisp) is a programming language, a dialect of the language Lisp.It was developed at the French Institute for Research in Computer Science and Automation (INRIA), to be an implementation language for a very large scale integration (VLSI) workstation being designed under the direction of Jean Vuillemin. Le Lisp also had to run on various incompatible platforms (mostly running Unix operating systems) that were used by the project. The main goals for the language were to be a powerful post-Maclisp version of Lisp that would be portable, compatible, extensible, and efficient.Jérôme Chailloux led the Le Lisp team, working with Emmanuel St. James, Matthieu Devin, and Jean-Marie Hullot in 1980. The dialect is historically noteworthy as one of the first Lisp implementations to be available on both the Apple II and the IBM PC.
LEAP (pl, appeared 1969)
Origin: University of California, Berkeley
Massachusetts Institute of Technology
Country: United States

An ALGOL-based associative language. A high level programming language for large, complex associative structures has been designed and implemented. The underlying data structure has been implemented using a hash-coding technique. The discussion includes a comparison with other work and examples of applications of the language.

LEAP is an extension to the ALGOL 60 programming language which provides an associative memory of triples. The three items in a triple denote the association that an Attribute of an Object has a specific Value.  LEAP was created by Jerome Feldman (University of California Berkeley) and Paul Rovner (MIT Lincoln Lab) in 1967.  LEAP was also implemented in SAIL.
Leda (pl, appeared 1995)
Origin: Oregon State University
Country: United States


Leda is a multiparadigm programming language whose goal is to successfully mix imperative, object-oriented, functional, and logic-based programming features into one language. It is described in the book Multiparadigm Programming in Leda written by the principal designer Dr. Timothy Budd at Oregon State University.

GitHub description: Leda: Multiparadigm Programming Language
LES (grammarLanguage, appeared 2012)
Stands for: Loyc Expression Syntax
Creators: David Piepgrass
Origin: https://github.com/qwertie/loyc.net/issues
Country: Canada
Website: http://loyc.net/les/

LES is an interchange format for syntax trees, comparable to s-expressions but designed for languages in the Algol family such as C, C++, C#, Java, EcmaScript, Rust and Python. It can be described as “JSON for code”: just as XML/YAML/JSON are tree structures that assign no particular meaning to the data inside, likewise LES represents syntax trees without assigning any particular meaning to them.



@[#static]
fn factorial(x::int)::int {
  var result = 1;
  for (; x > 1; x--) {
    result *= x;
  };
  return result;
};