pldb/PLDB huggingface dataset:
Less (stylesheetLanguage, appeared 2009)
Creators: Alexis Sellier
Origin: https://github.com/less
Country: Various
Website: http://lesscss.org


Less (sometimes stylized as LESS) is a dynamic style sheet language that can be compiled into Cascading Style Sheets (CSS) and run on the client side or server side. Designed by Alexis Sellier, Less is influenced by Sass and has influenced the newer "SCSS" syntax of Sass, which adapted its CSS-like block formatting syntax. Less is open source. Its first version was written in Ruby; however, in the later versions, use of Ruby has been deprecated and replaced by JavaScript. The indented syntax of Less is a nested metalanguage, as valid CSS is valid Less code with the same semantics. Less provides the following mechanisms: variables, nesting, mixins, operators and functions; the main difference between Less and other CSS precompilers being that Less allows real-time compilation via less.js by the browser.
Lex (grammarLanguage, appeared 1975)
Origin: https://github.com/babyraging/yash/issues
Country: United States


Lex is a computer program that generates lexical analyzers ("scanners" or "lexers"). Lex is commonly used with the yacc parser generator. Lex, originally written by Mike Lesk and Eric Schmidt and described in 1975, is the standard lexical analyzer generator on many Unix systems, and an equivalent tool is specified as part of the POSIX standard. Lex reads an input stream specifying the lexical analyzer and outputs source code implementing the lexer in the C programming language.


/*** Definition section ***/

%{
/* C code to be copied verbatim */
#include <stdio.h>
%}

%%
    /*** Rules section ***/

    /* [0-9]+ matches a string of one or more digits */
[0-9]+  {
            /* yytext is a string containing the matched text. */
            printf("Saw an integer: %s\n", yytext);
        }

.|\n    {   /* Ignore all other characters. */   }

%%
/*** C Code section ***/

int main(void)
{
    /* Call the lexer, then quit. */
    yylex();
    return 0;
}
Lexon (contractLanguage, appeared 2018)
Origin: https://gitlab.com/lexon-foundation
Country: Uruguay
Website: http://lexon.tech/
Keywords: lexon
lex
clause
terms
contracts
may
pay
pays
appoints
into
to




LEX Escrow.

Chapter: Pay In.
A Payer pays an Amount into Escrow and appoints the Payee and the Arbiter.

Chapter: Pay Out.
The Arbiter or the Payer may pay the Escrow to the Payee.

Chapter: Pay Back.
The Arbiter or the Payee may pay the Escrow to the Payer.
LEXX (editor, appeared 1985)
Origin: IBM
Country: United States


LEXX is a text editor which was possibly the first to use live parsing and colour syntax highlighting. It was written by Mike Cowlishaw of IBM around 1985. The name was chosen because he wrote it as a tool for lexicographers, during an assignment for Oxford University Press's second edition of the Oxford English Dictionary. The program ran (and still, in 2018, runs) on mainframes under VM/CMS. LEXX's design was based on several other editors written by the same author (such as STET) augmented by the ability to dynamically parse text and display colour on the new colour terminals that had recently became available (PC-based, and stand-alone such as the IBM 3279). LEXX uses dynamically-loaded parsers which assign classes of elements (tokens formed from character strings) to fonts and colors. It allows indention to be used to format and show the structure of the file being edited, and other formatting options allow (for example) the hiding of selected classes of text, such as tags.  A collection of screenshots is available.LPEX ('Live Parsing Editor") is a reimplemented derivative of the LEXX concept, originally produced for OS/2 and AIX.  It now also runs on Windows, Linux, and the Java JVM.
LFE (pl, appeared 2008)
Stands for: Lisp Flavored Erlang
Creators: Robert Virding
Origin: https://github.com/lfe
Country: United States


Lisp Flavored Erlang (LFE) is a functional, concurrent, general-purpose programming language and Lisp dialect built on top of Core Erlang and the Erlang Virtual Machine (BEAM). LFE builds on top of Erlang in order to provide a Lisp syntax for writing distributed, fault-tolerant, soft real-time, non-stop applications. LFE also extends Erlang to support meta-programming with Lisp macros and an improved developer experience with a feature-rich REPL. LFE is actively supported on all recent releases of Erlang; the oldest version of Erlang supported is R14.
Li-Chen Wang (pl, appeared 1976)
Origin: Homebrew Computer Club
Country: United States


Dr. Li-Chen Wang (born 1935) is an American computer engineer, best known for his Palo Alto Tiny BASIC for Intel 8080-based microcomputers. He was a member of the Homebrew Computer Club and made significant contributions to the software for early microcomputer systems from Tandy Corporation and Cromemco.
Ligo (contractLanguage, appeared 2019)
Also known as: jsligo
cameligo
pascaligo
reasonligo
Origin: https://www.marigold.dev/projects
Country: France
Website: https://ligolang.org/
Keywords: abs
assert
block
Bytes
case
Crypto
Current
else
failwith
false
for
fun
if
in
let
let%entry
let%init
List
list
Map
map
match
match%nat
mod
not
operation
Operation
of
record
Set
set
sender
skip
source
String
then
to
true
type
with
Lil (pl, appeared 2022)
Origin: https://github.com/JohnEarnest/Decker/issues
Country: United States
Website: https://beyondloom.com/decker/lil.html

Lil is part of the technology that powers Decker, a multimedia creative tool inspired by HyperCard. Decker uses Lil for adding custom behavior to decks and the widgets within. Lil is designed to be learned in layers, but it is a richly multi-paradigm language which incorporates ideas from imperative, functional, declarative, and vector-oriented languages.


GitHub description: A multimedia sketchpad

on mode a do   # line comment
    r:()
    each x in a
        r[x]:1+r[x]
    end
    extract first key orderby value desc from r
end

mode[1,2,2,3,4,2,1]
Little Implementation Language (pl, appeared 1974)
Stands for: Little Implementation Language
Creators: P. J. Plauger
Origin: Bell Labs
Country: United States
Website: http://www.ultimate.com/phil/lil/lil.html


LIL, the Little Implementation Language, was a system programming language during the early days of Unix history on PDP-11 machines. It was written by P. J. Plauger of Bell Labs. LIL attempted to fill the gap between assemblers and machine-independent system implementation languages (such as the C programming language), by basically adding structured programming to the PDP-11 assembly language. LIL resembled PL360 with C-like flow control syntax. The LIL compiler "lc" was part of Fifth Edition Unix (1974), but was dropped by Sixth Edition Unix (1975). Plauger left Bell Labs in the same year. Plauger explains why LIL was abandoned in Bell Labs in favor of C: [1] ... LIL is, however, a failure. Its stiffest competition at Bell Labs is the language C, which is higher level, and machine independent. Every time it looked like C was too expensive to use for a particular project, LIL was considered. But almost every time, it proved easier (and more rewarding) to improve C, or its runtime support, or the hardware, than to invest time in yet another language. ... A machine independent language is always superior -- even for writing machine dependent code (it's easier to find trained programmers) -- so long as the overhead can be endured. It is clear now that writing straightforward code and then measuring it is the formula for the best end product. At worst there will be 5-15 per cent overhead, which is seldom critical. Once system writers become mature enough to recognize this basic truth, they gravitate naturally toward machine independent SILs. ... it looks like the little implementation language is an idea whose time as come -- and gone.
lila-lang (pl, appeared 2019)
Origin: https://github.com/codr7/lila/issues
Country: Unknown



GitHub description: a cleaner language based on Common Lisp

fun fib(n:Int) (Int) {
  if {n.< 2} n {
    fib {n.- 1}
    fib {n.- 2}
    $.+ $
  }
}
Lily (pl, appeared 2011)
Origin: https://gitlab.com/FascinatedBox/lily/-/issues
Country: Unknown
Website: http://lily-lang.org

An interpreted language with a focus on expressiveness and type safety


GitHub description: Interpreted language focused on expressiveness and type safety.

scoped enum Color { Black, Blue, Cyan, Green, Magenta, Red, White, Yellow }

class Terminal(public var @foreground: Color, width_str: String)
{
    public var @width = width_str.parse_i().unwrap_or(80)

    public define set_fg(new_color: Color) {
        @foreground = new_color
    }
}

var terms = [Terminal(Color.White, "A"), Terminal(Color.Red, "40")]

terms.each(|e| e.width += 20 )
     |> print
LilyPond (pl, appeared 1996)
Origin: https://gitlab.com/lilypond
Country: Various
Website: http://lilypond.org


LilyPond is a computer program and file format for music engraving. One of LilyPond's major goals is to produce scores that are engraved with traditional layout rules, reflecting the era when scores were engraved by hand. LilyPond is cross-platform, and is available for several common operating systems; released under the terms of the GNU General Public License, LilyPond is free software.
Limbo (pl, appeared 1995)
Creators: Rob Pike
Origin: https://groups.google.com/g/inferno-os
Country: United States
Website: http://www.vitanuova.com/inferno/limbo.html


Limbo is a programming language for writing distributed systems and is the language used to write applications for the Inferno operating system. It was designed at Bell Labs by Sean Dorward, Phil Winterbottom, and Rob Pike. The Limbo compiler generates architecture-independent object code which is then interpreted by the Dis virtual machine or compiled just before runtime to improve performance. Therefore all Limbo applications are completely portable across all Inferno platforms. Limbo's approach to concurrency was inspired by Hoare's communicating sequential processes (CSP), as implemented and amended in Pike's earlier Newsqueak language and Winterbottom's Alef.


Lock: module
{
	PATH:	con "/dis/lib/lock.dis";

	Semaphore: adt {
		c: chan of int;
		obtain:	fn(nil: self ref Semaphore);
		release: fn(nil: self ref Semaphore);
		new: fn(): ref Semaphore;
	};
	
	init: fn();
};
LIMDEP (pl, appeared 1980)
Origin: Econometric Software, Inc.
Country: United States


LIMDEP is an econometric and statistical software package with a variety of estimation tools. In addition to the core econometric tools for analysis of cross sections and time series, LIMDEP supports methods for panel data analysis, frontier and efficiency estimation and discrete choice modeling.  The package also provides a programming language to allow the user to specify, estimate and analyze models that are not contained in the built in menus of model forms.
Linda (pl, appeared 1986)
Creators: David Gelernter
Origin: Scientific Computing Associates
Country: United States


In computer science, Linda is a model of coordination and communication among several parallel processes operating upon objects stored in and retrieved from shared, virtual, associative memory. It was developed by Sudhir Ahuja at AT&T Bell Laboratories in collaboration with David Gelernter and Nicholas Carriero at Yale University in 1986.
Linden Scripting Language (pl, appeared 2003)
Origin: Linden Research, Inc
Country: United States


Second Life is an online virtual world, developed and owned by the San Francisco-based  firm Linden Lab and launched on June 23, 2003. By 2013, Second Life had approximately one million regular users. In many ways, Second Life is similar to massively multiplayer online role-playing games; however, Linden Lab is emphatic that their creation is not a game: "There is no manufactured conflict, no set objective".The virtual world can be accessed freely via Linden Lab's own client programs or via alternative third-party viewers. Second Life users, also called residents, create virtual representations of themselves, called avatars, and are able to interact with places, objects and other avatars. They can explore the world (known as the grid), meet other residents, socialize, participate in both individual and group activities, build, create, shop, and trade virtual property and services with one another. The platform principally features 3D-based user-generated content. Second Life also has its own virtual currency, the Linden Dollar, which is exchangeable with real world currency.Second Life is intended for people aged 16 and over, with the exception of 13–15-year-old users, who are restricted to the Second Life region of a sponsoring institution (e.g., a school).Built into the software is a 3D modeling tool based on simple geometric shapes that allows residents to build virtual objects. There is also a procedural scripting language, Linden Scripting Language, which can be used to add interactivity to objects.  Sculpted prims (sculpties), mesh, textures for clothing or other objects, animations, and gestures can be created using external software and imported. The Second Life terms of service provide that users retain copyright for any content they create, and the server and client provide simple digital rights management (DRM) functions. However, Linden Lab changed their terms of service in August 2013 to be able to use user-generated content for any purpose. The new terms of service prevent users from using textures from third-party texture services, as some of them pointed out explicitly.
Lingo (pl, appeared 1988)
Origin: MacroMind
Country: United States


Lingo is a verbose object-oriented (OO) scripting language developed by John H. Thompson for use in Adobe Director (formerly Macromedia Director). Lingo is used to develop desktop application software, interactive kiosks, CD-ROMs and Adobe Shockwave content. Lingo is the primary programming language on the Adobe Shockwave platform, which dominated the interactive multimedia product market during the 1990s. Various graphic adventure games were developed with Lingo during the 1990s, including The Journeyman Project, Total Distortion, Mia's Language Adventure, Mia's Science Adventure, and the Didi & Ditto series. Hundreds of free online video games were developed using Lingo, and published on websites such as Miniclip and Shockwave.com. Lingo can be used to build user interfaces, to manipulate raster graphics, vector graphics and 3D computer graphics, and other data processing tasks. Lingo supports specialized syntax for image processing and 3D object manipulation. 3D meshes can also be created on the fly using Lingo.
Linked Markdown (textMarkup, appeared 2022)
Creators: Luis Cuende
Origin: https://nation3.org
Country: Nation3
Website: https://linked.md/

The main intended use is writing legal agreements and law. A Linked Markdown file has a first sections containing definitions, and a second section containing Markdown. They are separated by three lines.



Definition Name
: Definition content.

---

# Markdown content
Any Markdown _text_.
Linker Script (application, appeared 1991)
Origin: Red Hat Inc
Free Software Foundation, Inc
Country: United States

ld combines a number of object and archive files, relocates their data and ties up symbol references. Usually the last step in compiling a program is to run ld. ld accepts Linker Command Language files written in a superset of AT&T’s Link Editor Command Language syntax, to provide explicit and total control over the linking process.



/*
*  link.ld
*/
OUTPUT_FORMAT(elf32-i386)
ENTRY(start)
SECTIONS
 {
   . = 0x100000;
   .text : { *(.text) }
   .data : { *(.data) }
   .bss  : { *(.bss)  }
 }
Linotte (pl, appeared 2005)
Creators: cpc6128
Origin: https://github.com/cpc6128/LangageLinotte/issues
Country: France
Website: http://langagelinotte.free.fr/


Linotte is an interpreted 4th generation programming language. Linotte's syntax is in French. The language's goal is to allow French-speaking children and other francophones with little computer science experience to easily learn programming, with the slogan (in French) "you know how to read a book, so you can write a computer program".

GitHub description: Code source officiel du langage de programmation Linotte - Langage de programmation en français simple créé dans le but de permettre aux enfants et aux personnes n'ayant pas une connaissance approfondie de l’informatique d’apprendre la programmation facilement.
LINQ (queryLanguage, appeared 2007)
Origin: Microsoft


Language Integrated Query (LINQ, pronounced "link") is a Microsoft .NET Framework component that adds native data querying capabilities to .NET languages, although ports exist for PHP (PHPLinq), JavaScript (linq.js), TypeScript (linq.ts), and ActionScript (ActionLinq) - but none of these ports are strictly equivalent to LINQ in C# for example (where it is a part of the language, not an external library, and where it often addresses a wider range of needs). LINQ extends the language by the addition of query expressions, which are akin to SQL statements, and can be used to conveniently extract and process data from arrays, enumerable classes, XML documents, relational databases, and third-party data sources. Other uses, which utilize query expressions as a general framework for readably composing arbitrary computations, include the construction of event handlers or monadic parsers. LINQ also defines a set of method names (called standard query operators, or standard sequence operators), along with translation rules used by the compiler to translate fluent-style query expressions into expressions using these method names, lambda expressions and anonymous types. Many of the concepts that LINQ has introduced were originally tested in Microsoft's Cω research project. LINQ was released as a major part of .NET Framework 3.5 on November 19, 2007.
Linux Kernel Module (application, appeared 1996)
Origin: Linux Kernel Organization, Inc
Country: United States
File extensions: ko

As of Linux kernel version 2.6, KO files are used in place of .O files and contain additional information that the kernel uses to load modules. The Linux program modpost can be used to convert O files into KO files.



/*
 * hello−1.c − The simplest kernel module.
 */
#include <linux/module.h> /* Needed by all modules */
#include <linux/kernel.h> /* Needed for KERN_INFO */
int init_module(void)
{
 printk(KERN_INFO "Hello world 1.\n");
 /*
 * A non 0 return means init_module failed; module can't be loaded.
 */
 return 0;
}
void cleanup_module(void)
{
 printk(KERN_INFO "Goodbye world 1.\n");
}
fs/mbcache.ko
fs/mbcache.o
Langage Implementation Systeme (pl, appeared 1980)
Stands for: Langage Implementation Systeme
Origin: Groupe Bull
Country: France


LIS (Language d'Implementation de Systèmes) was a system implementation programming language designed by Jean Ichbiah, who later designed Ada. LIS was used to implement the compiler for the Ada-0 subset of Ada at Karlsruhe on the BS2000 Siemens operating system. Later on the Karlsruhe Ada compilation system got rewritten in Ada-0 itself, which was easy, because LIS and Ada-0 are very close.
Liso (dataNotation, appeared 2014)
Also known as: o-expressions
Creators: Olivier Breuleux
Origin: https://github.com/breuleux/liso/issues
Country: Canada
Website: http://breuleux.net/blog/liso.html

Implemention of O-Expressions idea in Racket.



@varsrec
      odd?[n] =
         @if n == 0:
            #f
            even?[n - 1]
      even?[n] =
         @if n == 0:
            #t
            odd?[n - 1]:
   even?[30]
LISP 2 (pl, appeared 1963)
Origin: System Development Corporation and Information International, Inc
Country: United States


For Lisp-2, Lisp systems with separate function namespaces, see Lisp-1 vs. Lisp-2LISP 2 was a programming language proposed in the 1960s as the successor to Lisp. It had largely Lisp-like semantics and Algol 60-like syntax. Today it is mostly remembered for its syntax, but in fact it had many features beyond those of early Lisps. Early Lisps had many limitations, including limited data types and slow numerics. Its use of fully parenthesized notation was also considered a problem. The inventor of Lisp, John McCarthy, expected these issues to be addressed in a later version, called notionally Lisp 2. Hence the name Lisp 1.5 for the successor to the earliest Lisp.Lisp 2 was a joint project of the System Development Corporation and Information International, Inc., and was intended for  the IBM built AN/FSQ-32 military computer. Development later shifted to the IBM 360/67 and the Digital Equipment Corporation PDP-6. The project was eventually abandoned.
Lisp Machine Lisp (pl, appeared 1974)
Creators: David A. Moon
Richard Stallman
Daniel Weinreb
Origin: Massachusetts Institute of Technology
Symbolics, Inc
Lisp Machines, Inc
Texas Instruments Incorporated
Country: United States


Lisp Machine Lisp is a programming language, a dialect of the language Lisp. A direct descendant of Maclisp, it was initially developed in the mid to late 1970s as the system programming language for the Massachusetts Institute of Technology (MIT) Lisp machines. Lisp Machine Lisp was also the Lisp dialect with the most influence on the design of Common Lisp. Lisp Machine Lisp branched into three dialects. Symbolics named their variant ZetaLisp. Lisp Machines, Inc. and later Texas Instruments (with the TI Explorer) would share a common code base, but their dialect of Lisp Machine Lisp would differ from the version maintained at the MIT AI Lab by Richard Stallman and others.
Lisp (pl, appeared 1958)
Creators: John McCarthy
Origin: Massachusetts Institute of Technology
Country: United States


Lisp (historically, LISP) is a family of computer programming languages with a long history and a distinctive, fully parenthesized prefix notation. Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today. Only Fortran is older, by one year. Lisp has changed since its early days, and many dialects have existed over its history. Today, the best known general-purpose Lisp dialects are Common Lisp and Scheme. Lisp was originally created as a practical mathematical notation for computer programs, influenced by the notation of Alonzo Church's lambda calculus. It quickly became the favored programming language for artificial intelligence (AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, conditionals, higher-order functions, recursion, the self-hosting compiler, and the read–eval–print loop. The name LISP derives from "LISt Processor". Linked lists are one of Lisp's major data structures, and Lisp source code is made of lists. Thus, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or new domain-specific languages embedded in Lisp. The interchangeability of code and data gives Lisp its instantly recognizable syntax. All program code is written as s-expressions, or parenthesized lists. A function call or syntactic form is written as a list with the function or operator's name first, and the arguments following; for instance, a function f that takes three arguments would be called as (f arg1 arg2 arg3).
LispMe (pl, appeared 2008)
Origin: http://www.lispme.de/lispme/index_en.html
Country: Germany


LispMe is an interpreter for the Scheme programming language developed by Fred Bayer for Palm OS PDAs.  It is free software released under the GNU General Public License.  It is reasonably close to standard Scheme but is not fully R5RS compliant.  Scheme source programs can be stored in Palm OS memopad format while Scheme sessions,  are stored in Palm OS PDB database files and can be interrupted and restarted. There is some support for Palm OS user interface primitives.  LispMe also provides some database support. LispMe sessions can be given a "starter icon", which appears in the Applications menu, enabling the session to be run as a Palm Pilot application. The product ended development in August 2008, but is fairly complete and quite robust.