pldb/PLDB huggingface dataset:
LOLCODE (esolang, appeared 2007)
Creators: Adam Lindsay
Origin: Lancaster University
Country: England
Website: http://lolcode.org/


LOLCODE is an esoteric programming language inspired by lolspeak, the language expressed in examples of the lolcat Internet meme. The language was created in 2007 by Adam Lindsay, researcher at the Computing Department of Lancaster University. The language is not clearly defined in terms of operator priorities and correct syntax, but several functioning interpreters and compilers exist. One interpretation of the language has been proven Turing-complete.


HAI 1.3
    OBTW
      Author: Logan Kelly (logan.kelly@gmail.com)
      Github: https://github.com/LoganKelly/LOLTracer
    TLDR

    OBTW prev is the number used in the randin function.
         I had to declare it in global scope so that it
         would retain its value between calls to randin.
    TLDR
    I HAS A prev ITZ 0
    I HAS A rand_max ITZ 104729


    OBTW Equivalent to C's rand() function, except returns
        a number in the range of 0 to rand_max.
    TLDR
    HOW IZ I randin
        I HAS A a ITZ 33083
        I HAS A c ITZ 67607
        prev R MOD OF SUM OF PRODUKT OF prev AN a AN c AN rand_max
        FOUND YR prev
    IF U SAY SO


    BTW Returns a random number within the range of 0-1.
    HOW IZ I rand_onein
        I HAS A rand_num ITZ I IZ randin MKAY
        rand_num IS NOW A NUMBAR
        I HAS A rand_max_float ITZ MAEK rand_max A NUMBAR
        FOUND YR  QUOSHUNT OF rand_num AN rand_max_float
    IF U SAY SO


    OBTW Equivalent to C ceil() function. Returns the next
        largest integer for the given number.
    TLDR
    HOW IZ I ceilin YR num
        I HAS A int_num ITZ num
        int_num IS NOW A NUMBR
        BOTH SAEM int_num AN num, O RLY?
            YA RLY, FOUND YR num
        OIC
        DIFFRINT num AN SMALLR OF num AN 0, O RLY?
            YA RLY
                int_num R SUM OF int_num AN 1
                FOUND YR MAEK int_num A NUMBAR
        OIC
        DIFFRINT num AN BIGGR OF num AN 0, O RLY?
            YA RLY
                FOUND YR MAEK int_num A NUMBAR
        OIC
    IF U SAY SO


    OBTW Convert a number to hexadecimal. This
         is returned as a string.
    TLDR
    HOW IZ I decimal_to_hex YR num
        I HAS A i ITZ 0
        I HAS A rem
        I HAS A hex_num ITZ A BUKKIT
        I HAS A decimal_num ITZ num
        IM IN YR num_loop
            rem R MOD OF decimal_num AN 16
            I HAS A hex_digit
            rem, WTF?
                OMG 10, hex_digit R "A", GTFO
                OMG 1
LookML (pl, appeared 2012)
Origin: Looker
Website: https://docs.looker.com/data-modeling/learning-lookml/what-is-lookml




######################################
# FILE: ecommercestore.model.lkml    #
# Define the explores and join logic #
######################################
connection: order_database
include: "*.view.lkml"
explore: orders {
  join: customers {
    sql_on: ${orders.customer_id} = ${customers.id} ;;
  }
}

##########################################################
# FILE: orders.view.lkml                                 #
# Define the dimensions and measures for the ORDERS view #
##########################################################
view: orders {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: customer_id {      # field: orders.customer_id
    sql: ${TABLE}.customer_id ;;
  }
  dimension: amount {           # field: orders.amount
    type: number
    value_format: "0.00"
    sql: ${TABLE}.amount ;;
  }
  dimension_group: created {                # generates fields:
    type: time                              # orders.created_time, orders.created_date
    timeframes: [time, date, week, month]   # orders.created_week, orders.created_month
    sql: ${TABLE}.created_at ;;
  }
  measure: count {             # field: orders.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # list of fields to show when someone clicks 'ORDERS Count'
  }
  measure: total_amount {
    type: sum
    sql: ${amount} ;;
  }
  set: drill_set {
    fields: [id, created_time, customers.name, amount]
  }
}

#############################################################
# FILE: customers.view.lkml                                 #
# Define the dimensions and measures for the CUSTOMERS view #
#############################################################
view: customers {
  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
  dimension: city {                    # field: customers.city
    sql: ${TABLE}.city ;;
  }
  dimension: state {                   # field: customers.state
    sql: ${TABLE}.state ;;
  }
  dimension: name {
    sql: CONCAT(${TABLE}.firstname, " ", ${TABLE}.lastname) ;;
  }
  measure: count {             # field: customers.count
    type: count                # creates a sql COUNT(*)
    drill_fields: [drill_set*] # fields to show when someone clicks 'CUSTOMERS Count'
  }
  set: drill_set {                     # set: customers.drill_set
    fields: [id, state, orders.count]  # list of fields to show when someone clicks 'CUSTOMERS Count'
  }
}
Loom (knowledgeBase, appeared 1987)
Origin: Information Sciences Institute
Country: United States
Website: https://www.isi.edu/isd/LOOM/LOOM-HOME.html

Loom is a language and environment for constructing intelligent applications. The heart of Loom is a knowledge representation system that is used to provide deductive support for the declarative portion of the Loom language. Declarative knowledge in Loom consists of definitions, rules, facts, and default rules. A deductive engine called a classifier utilizes forward-chaining, semantic unification and object-oriented truth maintainance technologies in order to compile the declarative knowledge into a network designed to efficiently support on-line deductive query processing.



(defconcept air-base
             :is-primitive
                     (and military-installation
                     (exactly 1 name)
                     (at-least 1 runway-length)))
Lorel (queryLanguage, appeared 1996)
Creators: Serge Abiteboul
Dallan Quass
Jason McHugh
Jennifer Widom
Janet L. Wiener
Origin: Stanford University
Country: United States

Lorel Query Language for Semistructured Data



select Guide.restaurant.name,
   Guide.restaurant(.address)?.zipcode
 where Guide.restaurant.% grep "cheap"
LotusScript (pl, appeared 1996)
Origin: Lotus Development Corporation
Country: United States


LotusScript is an object oriented programming language used by Lotus Notes (since version 4.0) and other IBM Lotus Software products. LotusScript is similar to Visual Basic. Developers familiar with one can easily understand the syntax and structure of code in the other. The major differences between the two are in their respective Integrated Development Environments and in the product-specific object classes provided in each language that are included. VB includes a richer set of classes for UI manipulation, whereas LotusScript includes a richer set of application-specific classes for Lotus Notes, Lotus Word Pro and Lotus 1-2-3. In the case of Lotus Notes, there are classes to work with Notes databases, documents (records) in those databases, etc. These classes can also be used as OLE Automation objects outside of the Lotus Notes environment, from Visual Basic. LotusScript also allows the definition of user-defined types and classes, although it is not possible to inherit from the product-specific classes.
Low* (pl, appeared 2008)
Also known as: low-star
Origin: Microsoft Research
Institut national de recherche en sciences et technologies du numérique
Country: United States and France
Website: https://fstarlang.github.io/lowstar/html/LowStar.html




let chacha20
 (len: uint32{len ≤ blocklen})
 (output: bytes{len = output.length})
 (key: keyBytes)
 (nonce: nonceBytes{disjoint [output; key; nonce]})
 (counter: uint32) : Stack unit
 (requires (λ m0 → output ∈ m0 ∧ key ∈ m0 ∧ nonce ∈ m0))
 (ensures (λ m0 _m1 → modifies1 output m0 m1 ∧
 m1.[output] ==
  Seq.prefix len (Spec.chacha20 m0.[key] m0.[nonce]) counter))) =
  push_frame ();
  let state = Buffer.create 0ul 32ul in
  let block = Buffer.sub state 16ul 16ul in
  chacha20_init block key nonce counter;
  chacha20_update output state len;
  pop_frame ()
LPC (pl, appeared 1995)
Stands for: Lars Pensjö C
Creators: Lars Pensjö
Origin: Chalmers Datorförening
Country: Sweden
Website: http://lpmuds.net


LPC (short for Lars Pensjö C) is an object-oriented programming language derived from C and developed originally by Lars Pensjö to facilitate MUD building on LPMuds. Though designed for game development, its flexibility has led to it being used for a variety of purposes, and to its evolution into the language Pike. LPC syntax places it in the family of C-like languages, with C and C++ its strongest influences.
Langage Sans Espoir (pl, appeared 1971)
Stands for: Langage Sans Espoir
Origin: École supérieure d'électricité and Télémécanique
Country: France


LSE (French: Langage symbolique d'enseignement) is a programming language developed at Supélec in the late 1970s/early 1980s. It is similar to BASIC, except with French-language instead of English-language keywords. It was derived from an earlier language called LSD, also developed at Supélec. It is most commonly said to be an acronym for Langage Symbolique d'Enseignement (Symbolic Teaching Language), but other expansions are also known (e.g. Langage de Sup-Élec, or the more cynical Langage Sans Espoir (hopeless language)). It originally flourished due to support from the French Ministry of National Education, but declined as the ministry lost interest. It went through a number of revisions; earlier versions of LSE lacked full support for structured programming, which later version added, along with exception handling.
Language Server Index Format (jsonFormat, appeared 2019)
Stands for: Language Server Index Format
Creators: Dan Adler
Origin: Sourcegraph
Country: United States
Website: https://lsif.dev/



GitHub description: https://lsif.dev

// a vertex representing the document
{ id: 1, type: "vertex", label: "document", uri: "file:///Users/username/sample.ts", languageId: "typescript" }
// a vertex representing the range for the identifier bar
{ id: 4, type: "vertex", label: "range", start: { line: 0, character: 9}, end: { line: 0, character: 12 } }
// an edge saying that the document with id 1 contains the range with id 4
{ id: 5, type: "edge", label: "contains", outV: 1, inV: 4}
// a vertex representing the actual hover result
{ id: 6, type: "vertex", label: "hoverResult",
  result: {
    contents: [
      { language: "typescript", value: "function bar(): void" }
    ]
  }
}
// an edge linking the hover result to the range.
{ id: 7, type: "edge", label: "textDocument/hover", outV: 4, inV: 6 }
Lua (pl, appeared 1993)
Creators: Roberto Ierusalimschy
Origin: Tecgraf
Country: Brazil
Website: https://www.lua.org/
Keywords: and
break
do
else
elseif
end
false
for
function
if
in
local
nil
not
or
repeat
return
then
true
until
while


Lua ( LOO-ə, from Portuguese: lua [ˈlu.(w)ɐ] meaning moon) is a lightweight, multi-paradigm programming language designed primarily for embedded systems and clients. Lua is cross-platform, since the interpreter is written in ANSI C, and has a relatively simple C API. Lua was originally designed in 1993 as a language for extending software applications to meet the increasing demand for customization at the time. It provided the basic facilities of most procedural programming languages, but more complicated or domain-specific features were not included; rather, it included mechanisms for extending the language, allowing programmers to implement such features. As Lua was intended to be a general embeddable extension language, the designers of Lua focused on improving its speed, portability, extensibility, and ease-of-use in development.
luau (pl, appeared 2020)
Origin: https://github.com/Roblox/luau/issues
Country: United States
Website: https://roblox.github.io/luau/

Luau is a fast, small, safe, gradually typed embeddable scripting language derived from Lua. It is used by Roblox game developers to write game code, as well as by Roblox engineers to implement large parts of the user-facing application code as well as portions of the editor (Roblox Studio) as plugins.



type Point = { x: number, y: number }

local p = { x = 1, y = 2 }

print(p.x, p.y)
-- print(p.z) results in a type error
Lucidchart (application, appeared 2008)
Origin: Lucid Software Inc
Country: United States
Website: https://www.lucidchart.com/


Lucidchart is a web-based proprietary platform that is used to allow users to collaborate on drawing, revising and sharing charts and diagrams.Lucidchart runs on browsers that support HTML5.  This means it does not require updates of third party software like flash. In 2010, the firm announced they had integrated into the Google Apps Marketplace.The company raised $1 million in "angel funding" in 2011.On 17 October 2018, the firm announced it had raised an additional $72 million from Meritech Capital and ICONIQ Capital.
Lucid (template, appeared 2014)
Creators: Chris Done
Origin: https://github.com/chrisdone/lucid/issues
Country: England



GitHub description: Clear to write, read and edit DSL for writing HTML

table_ [rows_ "2"]
       (tr_ (do td_ [class_ "top",colspan_ "2",style_ "color:red"]
                    (p_ "Hello, attributes!")
                td_ "yay!"))
LUCID (pl, appeared 1976)
Creators: Edward A. Ashcroft
William W. Wadge
Origin: University of Victoria
SRI International
Country: Canada and United States


Lucid is a dataflow programming language designed to experiment with non-von Neumann programming models. It was designed by Bill Wadge and Ed Ashcroft and described in the 1985 book Lucid, the Dataflow Programming Language. pLucid was the first interpreter for Lucid.
Luna (pl, appeared 2011)
Creators: TJ Holowaychuk
Origin: https://github.com/tj/luna/issues
Country: United Kingdom
Website: https://github.com/tj/luna

Luna is an expressive, minimalistic, elegant programming language implemented in C. With cooperative thread concurrency at its core, async I/O, and influences derived from languages such as Lua, io, Rust, Ruby, and C. Luna favours unification and minimalism over minor obscure conveniences, providing the true convenience of a simple effective language. This includes omitting features which facilitate magic such as getters/setters, method_missing-style delegation etc. This project is very much a work in progress, as I explore the wonderful world of VMs! feel free to join.


GitHub description: luna programming language - a small, elegant VM implemented in C

def greet(name:string)
  return "Hello " + name
end
Lush (pl, appeared 2002)
Stands for: Lisp Universal Shell
Creators: Leon Bottou
Yann Le Cun
Website: https://lush.sourceforge.net/index.html

Lush is an object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. Lush is designed to be used in situations where one would want to combine the flexibility of a high-level, weakly-typed interpreted language, with the efficiency of a strongly-typed, natively-compiled language



(for (i 1 100)
     (for (j 1 100)
        (if (= i j) (print (* i j))))))
Lustre (pl, appeared 1993)
Origin: Esterel Technologies
Country: France and United States


Lustre is a formally defined, declarative, and synchronous dataflow programming language for programming reactive systems. It began as a research project in the early 1980s. A formal presentation of the language can be found in the 1991 Proceedings of the IEEE. In 1993 it progressed to practical, industrial use in a commercial product as the core language of the industrial environment SCADE, developed by Esterel Technologies. It is now used for critical control software in aircraft, helicopters, and nuclear power plants.
LYaPAS (pl, appeared 1964)
Creators: Arkady D.Zakrevskij
Origin: Siberian Physical-Technical Institute
Country: Union of Soviet Socialist Republics or Russia


Logical Language for the Representation of Synthesis Algorithms (LYaPAS, Russian: ЛЯПАС) is a programming language created in the Soviet Union in 1964, by Arkady D.Zakrevskij of the Laboratory of System Programming and Logical Synthesis, of the Academy of Sciences of the Byelorussian SSR, since renamed the National Academy of Sciences of Belarus.LYaPAS is an extension to the programming language APL, and was initially designed especially for non-numeric programming for the Soviet designed and built line of mainframe computers named Ural-1. An interesting feature of LYaPAS is its use of octal numbers. A further refinement of LYaPAS is LYaPAS-M.
Lynx (pl, appeared 1984)
Origin: University of Wisconsin–Madison
Country: United States


Lynx is a programming language for large distributed networks, using remote procedure calls. It was developed by the University of Wisconsin–Madison in 1984 for the Charlotte multicomputer operating system.  In 1986 at the University of Rochester Lynx was ported to the Chrysalis operating system running on a BBN Butterfly multiprocessor.
LyX (editor, appeared 1995)
Origin: https://www.lyx.org/MailingLists
Country: Various
Website: https://www.lyx.org/


LyX (styled as                                    L                                                                                                          Y                                                                             X                          {\displaystyle \mathbf {L} \!{}_{\mathbf {\displaystyle Y} }\!\mathbf {X} }   ; pronounced [ˈlɪks]) is an open source document processor based on the LaTeX typesetting system. Unlike most word processors, which follow the WYSIWYG ("what you see is what you get") paradigm, LyX has a WYSIWYM ("what you see is what you mean") approach, where what shows up on the screen is only an approximation of what will show up on the page. Since LyX largely functions as a front-end to the LaTeX typesetting system, it has the power and flexibility of LaTeX, and can handle documents including books, notes, theses, to academic papers, letters, etc. Knowledge of the LaTeX markup language is not necessary for basic usage, although a variety of specialized formatting is only possible by adding LaTeX directives directly into the page. LyX is popular among technical authors and scientists for its advanced mathematical modes, though it is increasingly used by non-mathematically-oriented scholars as well for its bibliographic database integration and ability to manage multiple files. LyX has also become popular among self-publishers.LyX is available for various operating systems, including Windows, macOS, Linux, UNIX, OS/2 and Haiku. LyX can be redistributed and modified under the terms of the GNU General Public License and is thus free software.
Meta Expressions (dataNotation, appeared 1960)
Stands for: Meta Expressions
Origin: Massachusetts Institute of Technology
Country: United States

The project of defining M-expressions precisely and compiling them or at least translating them into S-expressions was neither finalized nor explicitly abandoned. It just receded into the indefinite future, and a new generation of programmers appeared who preferred internal notation to any FORTRAN-like or ALGOL-like notation that could be devised.

In computer programming, M-expressions (or meta-expressions) were an early proposed syntax for the Lisp programming language, inspired by contemporary languages such as Fortran  and ALGOL.


 [1;2;3]
 f[x;y]
 label[square;λ[[x];product[x;x]]]
 [lessthan[x;0] → negative[x]; T → x]
M2001 (pl, appeared 2001)
Origin: Trinity University
Country: United States


M2001 is a modular educational mathematical programming language for developing and presenting mathematical algorithms, from the modern discrete to the classical continuous mathematics. M2001 is built on a semantic framework that is based in category theory and has a syntax similar to that of Pascal or Modula-2. It is designed purely for pedagogic use, so efficiency and ease of implementation have been far less important in its development than generality and range of application. It was created to play an important role in forming a formal algorithmic foundation for first-year college math students.
M4 (pl, appeared 1977)
Creators: Brian Kernighan
Dennis Ritchie
Origin: AT&T Bell Laboratories
Country: United States


m4 is a general-purpose macro processor included in all UNIX-like operating systems, and is a component of the POSIX standard. The language was designed by Brian Kernighan and Dennis Ritchie for the original versions of UNIX. It is an extension of an earlier macro processor m3, written by Ritchie for the AP-3 minicomputer. The macro preprocessor operates as a text-replacement tool. It is employed to re-use text templates, typically in computer programming applications, but also in text editing and text-processing applications. Most users require m4 as a dependency of GNU autoconf.
MacBASIC (pl, appeared 1985)
Origin: Apple
Country: United States


Macintosh Basic, or MacBASIC, was both a comprehensive programming language and a fully interactive development environment designed by Apple Inc. for the original Macintosh computer. It was developed by original Macintosh team member Donn Denman, with help from fellow Apple programmers Marianne Hsiung, Larry Kenyon, and Bryan Stearns, as part of the original Macintosh development effort starting in late 1981.MacBASIC was released as beta software in 1985, and was adopted for use in places such as the Dartmouth College computer science department, for use in an introductory programming course. In November 1985, Apple abruptly ended the project as part of a deal with Microsoft to extend the license for BASIC on the Apple II.  Although Apple retracted MacBASIC, unlicensed copies of the software and manual still circulated, but because MacBASIC was no longer supported by Apple and not designed to be 32-bit-clean, interest eventually died out. Benchmarks published in the April 1984 issue of BYTE magazine suggested that MacBASIC had better performance as compared to Microsoft BASIC. The language included modern looping control structures, user-defined functions, graphics, and access to the Macintosh Toolbox. The development environment supported multiple programs running simultaneously with symbolic debugging including breakpoints and single-step execution.
Macchiato (pl, appeared 2019)
Creators: Eddie aka. tamamu
Origin: https://github.com/tamamu/macchiato/issues
Country: Japan
Website: https://github.com/tamamu/macchiato
File extensions: at



GitHub description: An AltJS of a dialect of Lisp

(defn inc (x) (+ 1 x))
(defn fizzbuzz (n)
  (doseq (i (range 1 n#inc))
         (match (list (mod i 3) (mod i 5))
                (0 0) (console:log "FizzBuzz")
                (0 _) (console:log "Fizz")
                (_ 0) (console:log "Buzz")
                _     (console:log i))))
(fizzbuzz 20)
MACRO-11 (pl, appeared 1974)
Origin: Digital Equipment Corporation
Country: United States


MACRO-11 is an assembly language with macro facilities for PDP-11 minicomputers from Digital Equipment Corporation (DEC).  It is the successor to PAL-11 (Program Assembler Loader), an earlier version of the PDP-11 assembly language without macro facilities. The MACRO-11 assembly language was designed for the PDP-11 minicomputer family.  It was supported on all DEC PDP-11 operating systems. PDP-11 Unix systems also include an assembler (called "as"), structurally similar to MACRO-11 but with different syntax and fewer features.
MacroML (pl, appeared 2001)
Origin: Indiana University
Yale University
Country: United States


MacroML is an experimental programming language based on the ML programming language family that seeks to reconcile ML's static typing systems, and the types of macro systems more commonly found in dynamically typed languages like Scheme; this reconciliation is difficult as macro transformations are typically Turing-complete and so can break the type safety guarantees static typing is supposed to provide.