pldb/PLDB huggingface dataset:
Elliott ALGOL (pl, appeared 1962)
Origin: Elliott Brothers (London) Ltd
Country: United Kingdom


Elliott ALGOL  was an ALGOL 60 compiler for the Elliott 803 computer. It was implemented by Tony Hoare and others. It differed slightly from the reference version of Algol, particularly in the supported character set. First released in February 1962, it is believed to be the first implementation of an ALGOL 60 compiler in a commercial context and was an unexpectedly popular product for the company.
Elm (pl, appeared 2012)
Creators: Evan Czaplicki
Origin: https://github.com/elm
Country: United States and France
Website: http://elm-lang.org
File extensions: elm


Elm is a domain-specific programming language for declaratively creating web browser-based graphical user interfaces. Elm is purely functional, and is developed with emphasis on usability, performance, and robustness. It advertises "no runtime exceptions in practice," made possible by the Elm compiler's static type checking.

GitHub description: Compiler for Elm, a functional language for reliable webapps.
Elvish (pl, appeared 2013)
Creators: Qi Xiao
Origin: https://github.com/elves
Country: Unknown
Website: https://elv.sh/

Elvish is an expressive programming language and a versatile interactive shell, combined into one seamless package. It runs on Linux, BSDs, macOS and Windows.


GitHub description: Elvish = Expressive Programming Language + Versatile Interactive Shell

if $true { echo good } else { echo bad }
Em (textMarkup, appeared 2020)
Stands for: Easy Markup
Origin: https://github.com/peter-fa
Country: Unknown



GitHub description: Easy Markup is a lightweight markup language.

This is an optional HTML title.

.p
This is a paragraph.

.p
This is a paragraph. It ends
here.

.p
This is a    paragraph. It
ends
here.

.l
This is a list item.

This is a list item.

This is a list item.


.p
This is a paragraph. #This word
is italic.

.p
This is a paragraph. @This word
is bold.

.p
This is a paragraph. #{These words}
are italic.

.p
This is a paragraph. @{These words}
are bold.
Emacs (editor, appeared 1976)
Creators: Richard Stallman
Guy Steele
Dave Moon
Origin: Free Software Foundation, Inc.
Country: Various


Emacs  is a family of text editors that are characterized by their extensibility. The manual for the most widely used variant, GNU Emacs, describes it as "the extensible, customizable, self-documenting, real-time display editor".  Development of the first Emacs began in the mid-1970s, and work on its direct descendant, GNU Emacs, continues actively as of  2018. Emacs has over 10,000 built-in commands (many of which are macros themselves) and its user interface allows the user to combine these commands into macros to automate work. Implementations of Emacs typically feature a dialect of the Lisp programming language that provides a deep extension capability, allowing users and developers to write new commands and applications for the editor. Extensions have been written to manage email, files, outlines, and RSS feeds, as well as clones of ELIZA, Pong, Conway's Life, Snake and Tetris.The original EMACS was written in 1976 by Carl Mikkelsen, David A. Moon and Guy L. Steele Jr. as a set of Editor MACroS for the TECO editor. It was inspired by the ideas of the TECO-macro editors TECMAC and TMACS.The most popular, and most ported, version of Emacs is GNU Emacs, which was created by Richard Stallman for the GNU Project. XEmacs is a variant that branched from GNU Emacs in 1991. GNU Emacs and XEmacs use similar Lisp dialects and are for the most part compatible with each other. Emacs is, along with vi, one of the two main contenders in the traditional editor wars of Unix culture. Emacs is among the oldest free & open source projects still under development.
Emacs Lisp (pl, appeared 1985)
Also known as: emacslisp
Creators: Richard Stallman
Origin: GNU Project
Country: United States


Emacs Lisp is a dialect of the Lisp programming language used as a scripting language by Emacs (a text editor family most commonly associated with GNU Emacs and XEmacs). It is used for implementing most of the editing functionality built into Emacs, the remainder being written in C (as is the Lisp interpreter itself). Emacs Lisp is also referred to as Elisp, although there is also an older, unrelated Lisp dialect with that name. Users of Emacs commonly write Emacs Lisp code to customize and extend Emacs. Other options include the "Customize" feature that's been in GNU Emacs since version 20. Itself written in Emacs Lisp, Customize provides a set of preferences pages allowing the user to set options and preview their effect in the running Emacs session. When the user saves their changes, Customize simply writes the necessary Emacs Lisp code to the user's config file, which can be set to a special file that only Customize uses, to avoid the possibility of messing up the users own file. Emacs Lisp can also function as a scripting language, much like the Unix Bourne shell or Perl, by calling Emacs in "batch mode". In this way it may be called from the command line or via an executable file, and its editing functions, such as buffers and movement commands are available to the program just as in the normal mode. No user interface is presented when Emacs is started in batch mode; it simply executes the passed-in script and exits, displaying any output from the script.
emfatic (pl, appeared 2004)
Origin: Eclipse Foundation, Inc
Country: Canada
Website: https://www.eclipse.org/epsilon/doc/articles/emfatic/

Emfatic is a language designed to represent EMF Ecore models in a textual form.



package test;

datatype D1 : int;

package P {
  datatype D2 : int;
}

class C {
  attr D1 d1;
  attr P.D2 d2;
  attr ecore.EString s1;
  attr String s2;
}
Energy Systems Language (notation, appeared 1950)
Origin: United States Atomic Energy Commission
Country: United States


The Energy Systems Language, also referred to as Energese, Energy Circuit Language, or Generic Systems Symbols, was developed by the ecologist Howard T. Odum and colleagues in the 1950s during studies of the tropical forests funded by the United States Atomic Energy Commission. They are used to compose energy flow diagrams in the field of systems ecology.
Enterprise Mashup Markup Language (pl, appeared 2001)
Origin: JackBe Corporation
Country: United States


EMML, or Enterprise Mashup Markup Language, is an XML markup language for creating enterprise mashups, which are software applications that consume and mash data from variety of sources, often performing logical or mathematical operations as well as presenting data. Mashed data produced by enterprise mashups are presented in graphical user interfaces as mashlets, widgets, or gadgets. EMML can also be considered a declarative mashup domain-specific language (DSL). A mashup DSL eliminates the need for complex, time-consuming, and repeatable procedural programming logic to create enterprise mashups. EMML also provides a declarative language for creating visual tools for enterprise mashups.   The primary benefits of EMML are mashup design portability and interoperability of mashup solutions. These benefits are expected to accelerate the adoption of enterprise mashups by creating transferable skills for software developers and reducing vendor lock-in. The introduction of EMML is expected to help accelerate the trend toward the integration of Web-based applications and service-oriented architecture (SOA) technologies. Bank of America was a high-profile early supporter of EMML. Other prominent early supporters included Hewlett-Packard, Capgemini, Adobe Systems, and Intel.
Epigram (pl, appeared 2004)
Creators: Conor McBride
Origin: University of London
Country: United Kingdom


Epigram is a functional programming language with dependent types. Epigram also refers to the IDE usually packaged with the language. Epigram's type system is strong enough to express program specifications. The goal is to support a smooth transition from ordinary programming to integrated programs and proofs whose correctness can be checked and certified by the compiler. Epigram exploits the propositions as types principle, and is based on intuitionistic type theory. The Epigram prototype was implemented by Conor McBride based on joint work with James McKinna. Its development is continued by the Epigram group in Nottingham, Durham, St Andrews and Royal Holloway in the UK. The current experimental implementation of the Epigram system is freely available together with a user manual, a tutorial and some background material. The system has been used under Linux, Windows and Mac OS X. It is currently unmaintained, and version 2, which was intended to implement Observational Type Theory, was never officially released, however there exists a GitHub mirror, last updated in 2012. The design of Epigram and Epigram 2 have inspired the development of other systems such as Agda, Idris and Coq.
epsilon (pl, appeared 1967)
Origin: Eclipse Foundation, Inc
Country: Canada
Website: https://www.eclipse.org/epsilon/doc/eol/
File extensions: eol

EOL is an imperative programming language for creating, querying and modifying EMF models. You can think of it as a mixture of Javascript and OCL, combining the best of both worlds. As such, it provides all the usual imperative features found in Javascript (e.g. statement sequencing, variables, for and while loops, if branches etc.) and all the nice features of OCL such as those handy collection querying functions.



var m : new Model;

m.name = "m";

// Create five packages
for (i in 1.to(5)){
  var package : Package = new Package;
  package.name = "p" + i;
  package.package = m;

  // Create three classes in each package
  for (j in 1.to(3)) {
    
    var class : Class = new Class;
    class.name = "c" + i + "" + j;
    class.isAbstract = false;
    class.package = package;
    
  }
  
}

// Assign random supertypes to the classes created
for (c in Class.allInstances) {
  c.extends = Class.allInstances.random();
}
ERB (template, appeared 2004)
Origin: https://github.com/ruby
Country: Various

eRuby (Embedded Ruby) is a templating system that embeds Ruby into a text document.

eRuby (Embedded Ruby) is a templating system that embeds Ruby into a text document. It is often used to embed Ruby code in an HTML document, similar to ASP, JSP and PHP. The templating system of eRuby combines the ruby code and the plain text to provide flow control and variable substitution, thus making it easy to maintain.The View module of the rails is responsible to display the response or output on a browser. In its simplest form, a view can be a piece of HTML code which has some static content. For most applications, just having static content may not be enough. Many Rails applications will require dynamic content created by the controller (action method) to be displayed in their view. This is made possible by using Embedded Ruby to generate templates which can contain dynamic content. Embedded Ruby allows ruby code to be embedded in a view document. This code gets replaced with proper value resulted from the execution of the code at run time. But, by having the ability to embed code in a view document, we risk bridging the clear separation present in the MVC frame. It is thus the responsibility of the developer to make sure that there is a clear separation of responsibility among the model, view and controller modules of his/her application.


<ul>
<% 4.times do %>

  <li>list item</li>

<% end %>
</ul>
Erlang (pl, appeared 1986)
Creators: Joe Armstrong
Robert Virding
Mike Williams
Origin: Ericsson
Country: Sweden
Website: https://www.erlang.org
File extensions: erl
hrl
Keywords: after
and
andalso
begin
bnot
bor
bsl
bsr
bxor
case
catch
cond
div
end
fun
if
let
not
of
or
orelse
receive
rem
try
when
xor


Erlang ( ER-lang) is a general-purpose, concurrent, functional programming language, as well as a garbage-collected runtime system. The term Erlang is used interchangeably with Erlang/OTP, or OTP, which consists of the Erlang runtime system, a number of ready-to-use components mainly written in Erlang, and a set of design principles for Erlang programs. The Erlang runtime system is known for its designs that are well suited for systems with the following characteristics: Distributed Fault-tolerant Soft real-time, Highly available, non-stop applications Hot swapping, where code can be changed without stopping a system. The Erlang programming language is known for the following properties: Immutable data Pattern matching Functional programming The sequential subset of the Erlang language supports eager evaluation, single assignment, and dynamic typing. It was originally a proprietary language within Ericsson, developed by Joe Armstrong, Robert Virding and Mike Williams in 1986, but was released as open source in 1998. Erlang/OTP is supported and maintained by the OTP product unit at Ericsson.
ESC/P (pl, appeared 1992)
Origin: Seiko Epson Corporation
Country: Japan


ESC/P, short for Epson Standard Code for Printers and sometimes styled Escape/P, is a printer control language developed by Epson to control computer printers. It was mainly used in dot matrix printers and some inkjet printers, and is still widely used in many receipt printers. During the era of dot matrix printers, it was also used by other manufacturers (e.g., NEC), sometimes in modified form. At the time, it was a popular mechanism to add formatting to printed text, and was widely supported in software.
Esoteric Reaction (esolang, appeared 2020)
Origin: https://bigyihsuan.github.io
Country: Unknown



GitHub description: Esolang using chemical "formulas" as code

 <code>	   ::= <equation> | <equation> <code>
 <equation> ::= <reagent> <rhs> | <COMMENT> | <reagent> <rhs> <COMMENT>
Executive Systems Problem Oriented Language (pl, appeared 1967)
Stands for: Executive Systems Problem Oriented Language
Origin: Burroughs Corporation
Country: United States


This article is about the programming language. For the university, see Escuela Superior Politecnica del Litoral.ESPOL (short for Executive Systems Problem Oriented Language) was a superset of ALGOL 60 that provided capabilities of what would later be known as Mohols, machine oriented high order languages, such as interrupting a processor on a multiprocessor system (the Burroughs large systems were multiprocessor processor systems). ESPOL was used to write the MCP (Master Control Program) on Burroughs computer systems from the B5000 to the B6700. The single-pass compiler for ESPOL could compile over 250 lines per second. ESPOL was superseded by NEWP.
Esterel (pl, appeared 1980)
Origin: Ecole des Mines de Paris
INRIA
Country: France


Esterel is a synchronous programming language for the development of complex reactive systems. The imperative programming style of Esterel allows the simple expression of parallelism and preemption. As a consequence, it is well suited for control-dominated model designs. The development of the language started in the early 1980s, and was mainly carried out by a team of Ecole des Mines de Paris and INRIA led by Gérard Berry. Current compilers take Esterel programs and generate C code or hardware (RTL) implementations (VHDL or Verilog). The language is still under development, with several compilers out. The commercial version of Esterel is the development environment Esterel Studio. The company that commercialize it (Synfora) initiated a normalization process with the IEEE in April 2007 however the working group (P1778) dissolved March 2011. The Esterel v7 Reference Manual Version v7 30 – initial IEEE standardization proposal is publicly available.
Euclid (pl, appeared 1970)
Creators: Butler Lampson
Origin: Xerox PARC
University of Toronto
Country: Canada


Euclid is an imperative programming language for writing verifiable programs. It was designed by Butler Lampson and associates at the Xerox PARC lab in the mid-1970s. The implementation was led by Ric Holt at the University of Toronto and James Cordy was the principal programmer for the first implementation of the compiler. It was originally designed for the Motorola 6809 microprocessor. It was considered innovative for the time; the compiler development team had a $2 million budget over 2 years and was commissioned by the Defense Advanced Research Projects Agency of the U.S. Department of Defense and the Canadian Department of National Defence. It was used for a few years at I. P. Sharp Associates, MITRE Corporation, SRI International and various other international institutes for research in systems programming and secure software systems. Euclid is descended from the Pascal programming language. Functions in Euclid are closed scopes, may not have side effects, and must explicitly declare imports. Euclid also disallows gotos, floating point numbers, global assignments, nested functions and aliases, and none of the actual parameters to a function can refer to the same thing. Euclid implements modules as types. Descendants of Euclid include the Mesa programming language, the Concurrent Euclid programming language and the Turing programming language.
Euclidean geometry (notation, appeared -300)


Euclidean geometry is a mathematical system attributed to Alexandrian Greek mathematician Euclid, which he described in his textbook on geometry: the Elements. Euclid's method consists in assuming a small set of intuitively appealing axioms, and deducing many other propositions (theorems) from these. Although many of Euclid's results had been stated by earlier mathematicians, Euclid was the first to show how these propositions could fit into a comprehensive deductive and logical system. The Elements begins with plane geometry, still taught in secondary school (high school) as the first axiomatic system and the first examples of formal proof. It goes on to the solid geometry of three dimensions. Much of the Elements states results of what are now called algebra and number theory, explained in geometrical language.For more than two thousand years, the adjective "Euclidean" was unnecessary because no other sort of geometry had been conceived. Euclid's axioms seemed so intuitively obvious (with the possible exception of the parallel postulate) that any theorem proved from them was deemed true in an absolute, often metaphysical, sense. Today, however, many other self-consistent non-Euclidean geometries are known, the first ones having been discovered in the early 19th century. An implication of Albert Einstein's theory of general relativity is that physical space itself is not Euclidean, and Euclidean space is a good approximation for it only over short distances (relative to the strength of the  gravitational field).Euclidean geometry is an example of synthetic geometry, in that it proceeds logically from axioms describing basic properties of geometric objects such as points and lines, to propositions about those objects, all without the use of coordinates to specify those objects. This is in contrast to analytic geometry, which uses coordinates to translate geometric propositions into algebraic formulas.
Euler (pl, appeared 1965)
Origin: Stanford University
ETH Zurich
Country: United States and Switzerland


Euler is a programming language created by Niklaus Wirth and Helmut Weber, conceived as an extension and generalization of ALGOL 60. The designers' goal was to create a language:  which was simpler, and yet more flexible, than ALGOL 60 that was a useful programming language processed with reasonable efficiency that can be defined with rigorous formalityAvailable sources indicate that Euler was operational by 1965.
EuLisp (pl, appeared 1985)
Origin: https://henry.github.io
Country: United States


EuLisp is a statically and dynamically scoped Lisp dialect developed by a loose formation of industrial and academic Lisp users and developers from around Europe. The standardizers intended to create a new Lisp "less encumbered by the past" (compared to Common Lisp), and not so minimalist as Scheme. Another objective was to integrate the object-oriented programming paradigm well. It is a third-generation programming language.
EUMEL (pl, appeared 1979)
Origin: Bielefeld University
Country: Germany


EUMEL (pronounced oimel for Extendable Multi User Microprocessor ELAN System and also known as L2 for Liedtke 2) is an operating system which began as a run-time environment for the ELAN programming language. It was created in 1979 by Jochen Liedtke at the University of Bielefeld. EUMEL initially ran on the 8-bit Z80 processor, and was later ported to many different architectures. EUMEL is based on a virtual machine using a bitcode and achieves remarkable performance and functionality. Z80-based EUMEL systems provide full multi-user multi-tasking operation with virtual memory management and complete isolation of one process against all others. These systems usually execute ELAN programs faster than equivalent programs written in languages such as BASIC, Pascal, or Cobol and compiled into Z80 machine language on other operating systems. One of the main features of EUMEL is that it is persistent, using a fixpoint/restart logic.  This means that if the power fails you only lose a couple of minutes of work: upon restart you continue working from the previous fixpoint with all program state fully intact. This is also known as orthogonal persistence.  EUMEL was followed by L3 and later L4.
Euphoria (pl, appeared 1993)
Stands for: End User Programming Hierarchial Objects for Robust Interpreted Applications
Creators: Jeremy Cowgar
Robert Craig
Matt Lewis
Derek Parnell
Origin: Rapid Deployment Software
Country: Canada
Website: http://openeuphoria.org
File extensions: e
ex
exw
edb


Euphoria is a programming language originally created by Robert Craig of Rapid Deployment Software in Toronto, Ontario, Canada. Initially developed (though not publicly released) on the Atari ST, the first commercial release was for the 16-bit DOS platform and was proprietary. In 2006, with the release of version 3, Euphoria became open-source software. The openEuphoria Group continues to administer and develop the project. In December 2010, the openEuphoria Group released version 4 of openEuphoria along with a new identity and mascot for the project. OpenEuphoria is currently available for Windows, Linux, macOS and three flavors of *BSD. Euphoria is a general-purpose high-level imperative-procedural interpreted language. A translator generates C source code and the GNU compiler collection (GCC) and Open Watcom compilers are supported. Alternatively, Euphoria programs may be bound with the interpreter to create stand-alone executables. A number of graphical user interface (GUI) libraries are supported including Win32lib and wrappers for wxWidgets, GTK+ and IUP. Euphoria has a simple built-in database and wrappers for a variety of other databases.

GitHub description: The Euphoria programming language (https://openeuphoria.org/)
Eurisko (pl, appeared 1978)
Origin: Stanford University
Country: United States


Eurisko (Gr., I discover) is a discovery system written by Douglas Lenat in RLL-1, a representation language itself written in the Lisp programming language. A sequel to Automated Mathematician, it consists of heuristics, i.e. rules of thumb, including heuristics describing how to use and change its own heuristics. Lenat was frustrated by Automated Mathematician's constraint to a single domain and so developed Eurisko; his frustration with the effort of encoding domain knowledge for Eurisko led to Lenat's subsequent (and, as of  2014, continuing) development of Cyc. Lenat envisions ultimately coupling the Cyc knowledgebase with the Eurisko discovery engine.