pldb/PLDB huggingface dataset:
Ease (pl, appeared 1991)
Creators: Steven Ericsson-Zenith
Origin: Yale University
École des Mines de Paris - Université PSL
Pierre
Marie Curie University
The Sorbonne
Country: United States and France


Ease is a general purpose parallel programming language. It is designed by Steven Ericsson-Zenith, a researcher at Yale University, the Institute for Advanced Science & Engineering in Silicon Valley, California, the Ecole Nationale Supérieure des Mines de Paris, and the Pierre and Marie Curie University, the science department of the Sorbonne.The book Process Interaction Models is the Ease language specification. Ease combines the process constructs of communicating sequential processes (CSP) with logically shared data structures called contexts. Contexts are parallel data types that are constructed by processes and provide a way for processes to interact. The language includes two process constructors. A cooperation includes an explicit barrier synchronization and is written:                         ∥         P         (         )         ∥         Q         (         )         ;                 {\displaystyle \parallel P()\parallel Q();}   If one process finishes before the other, then it will wait until the other processes are finished. A subordination creates a process that shares the contexts that are in scope when created and finishes when complete (it does not wait for other processes) and is written:                                                 /                                                          /                  P         (         )         ;                 {\displaystyle {\big /}\!\!/P();}   Subordinate processes stop if they attempt to interact with a context that  has completed because the parent process has stopped. This enables speculative processes to be created that will finish if their result is not needed. Powerful replication syntax allows multiple processes to be created. For example,                         ∥                    i                                      f           o           r                                      n                  :         P         (         i         )         ;                 {\displaystyle \parallel {i}\;{for}\;{n}:P(i);}   creates n synchronized processes each with a local constant i. Processes cannot share local variables and cooperate in the construction of shared contexts. Certain context types, called resources, ensure call-reply semantics. There are four functions upon contexts:  read (context, variable) – copies a value from the shared context to the variable. write (context, expression) – copies the value of expression to the shared context. put (context, name) – moves the value bound to name to the shared context. The value of name is subsequently undefined. get (context, name) – moves a value from context and binds it to name. The value is removed from the context.Context types are Singletons, Bags or Streams and can be subscripted arrays. Ease has a semiotic definition. This means that it accounts for the effect the language has on the programmer and how they develop algorithms. The language was designed to ease the developing of parallel programs.
Easybuild (application, appeared 2014)
Creators: Kenneth Hoste
Origin: https://github.com/easybuilders/
Country: Various
Website: http://easybuilders.github.io/easybuild/

EasyBuild is a software build and installation framework that allows you to manage (scientific) software on High Performance Computing (HPC) systems in an efficient way.


GitHub description: EasyBuild - building software with ease
EasyLanguage (pl, appeared 1995)
Origin: TradeStation Group, Inc
Country: United States


EasyLanguage is a proprietary programming language that was developed by TradeStation and built into its electronic trading platform. It is used to create custom indicators for financial charts and also to create algorithmic trading strategies for the markets. External DLL's can be referenced using EasyLanguage which greatly extends its functionality.  The language was intended to allow creation of custom trading strategies by traders without specialized computer training. Commands consist mostly of regular English words, which makes EasyLanguage easier to learn than more complex programming languages.Example:  Plain English: "If the close is greater than the high of 1 day ago, then buy 100 shares at market." EasyLanguage: "if the Close > the High of 1 day ago then Buy 100 shares next bar at market;"
EBNF (grammarLanguage, appeared 1977)
Stands for: extended Backus-Naur form
Creators: Niklaus Wirth


In computer science, extended Backus-Naur form (EBNF) is a family of metasyntax notations, any of which can be used to express a context-free grammar. EBNF is used to make a formal description of a formal language which can be a computer programming language. They are extensions of the basic Backus–Naur form (BNF) metasyntax notation. The earliest EBNF was originally developed by Niklaus Wirth incorporating some of the concepts (with a different syntax and notation) from Wirth syntax notation. However, many variants of EBNF are in use. The International Organization for Standardization has adopted an EBNF standard (ISO/IEC 14977). This article uses EBNF as specified by the ISO for examples applying to all EBNFs. Other EBNF variants use somewhat different syntactic conventions.
eC (pl, appeared 2004)
Stands for: Ecere C
Creators: Jérôme Jacovella-St-Louis
Origin: Ecere Corporation
Country: Canada
Website: http://ec-lang.org/


eC (Ecere C) is an object-oriented programming language, defined as a super-set of the C language. eC was initially developed as part of the Ecere Cross-platform Software Development Kit project. The goals of the language are to provide object-oriented constructs, reflection, properties and dynamic modules on top of the C language while maintaining C compatibility and optimal native performance.eC currently relies on GCC or Clang to perform the final steps of compilation, using C as an intermediate language. There are, however, plans to integrate directly with LLVM to skip the intermediate C files.eC is available as part of the ecere-sdk package in Debian/Ubuntu and other derived Linux distributions. A Windows installer also bundling MinGW-w64 is available from the main website. The free and open-source SDK including the eC compiler can also be built for a number of other platforms, including OS X, FreeBSD and Android.It is also possible to deploy eC applications to the web by compiling them to JavaScript through Emscripten, or to WebAssembly through Binaryen.

GitHub description: Ecere SDK (eC Language, Ecere IDE, Cross platform GUI, graphics, and more) — http://ec-lang.org —
ECL (pl, appeared 2000)
Origin: LexisNexis Risk Solutions Group
Country: United States
Website: http://hpccsystems.com/


ECL is a declarative, data centric programming language designed in 2000 to allow a team of programmers to process big data across a high performance computing cluster without the programmer being involved in many of the lower level, imperative decisions.

GitHub description: HPCC Systems (High Performance Computing Cluster) is an open source, massive parallel-processing computing platform for big data processing and analytics.
Eclipse Command Language (pl, appeared 2008)
Also known as: ecl
Origin: Eclipse Foundation
Country: Canada
Keywords: __compressed__
after
all
and
any
as
atmost
before
beginc
best
between
case
cluster
compressed
compression
const
counter
csv
default
descend
embed
encoding
encrypt
end
endc
endembed
endmacro
enum
escape
except
exclusive
expire
export
extend
fail
few
fileposition
first
flat
forward
from
full
function
functionmacro
group
grouped
heading
hole
ifblock
import
in
inner
interface
internal
joined
keep
keyed
last
left
limit
linkcounted
literal
little_endian
load
local
locale
lookup
lzw
macro
many
maxcount
maxlength
min
skew
module
mofn
multiple
named
namespace
nocase
noroot
noscan
nosort
not
noxpath
of
onfail
only
opt
or
outer
overwrite
packed
partition
penalty
physicallength
pipe
prefetch
quote
record
repeat
retry
return
right
right1
right2
rows
rowset
scan
scope
self
separator
service
shared
skew
skip
smart
soapaction
sql
stable
store
terminator
thor
threshold
timelimit
timeout
token
transform
trim
type
unicodeorder
unordered
unsorted
unstable
update
use
validate
virtual
whole
width
wild
within
wnotrim
xml
xpath
Eclipse (editor, appeared 2001)
Origin: The Eclipse Foundation
Country: Canada


Eclipse is an integrated development environment (IDE) used in computer programming, and is the most widely used Java IDE. It contains a base workspace and an extensible plug-in system for customizing the environment. Eclipse is written mostly in Java and its primary use is for developing Java applications, but it may also be used to develop applications in other programming languages via plug-ins, including Ada, ABAP, C, C++, C#, COBOL, D, Fortran, Haskell, JavaScript, Julia, Lasso, Lua,  NATURAL, Perl, PHP, Prolog, Python, R, Ruby (including Ruby on Rails framework), Rust, Scala, Clojure, Groovy, Scheme, and Erlang. It can also be used to develop documents with LaTeX (via a TeXlipse plug-in) and packages for the software Mathematica. Development environments include the Eclipse Java development tools (JDT) for Java and Scala, Eclipse CDT for C/C++, and Eclipse PDT for PHP, among others. The initial codebase originated from IBM VisualAge. The Eclipse software development kit (SDK), which includes the Java development tools, is meant for Java developers. Users can extend its abilities by installing plug-ins written for the Eclipse Platform, such as development toolkits for other programming languages, and can write and contribute their own plug-in modules. Since the introduction of the OSGi implementation (Equinox) in version 3 of Eclipse, plug-ins can be plugged-stopped dynamically and are termed (OSGI) bundlesEclipse software development kit (SDK) is free and open-source software, released under the terms of the Eclipse Public License, although it is incompatible with the GNU General Public License. It was one of the first IDEs to run under GNU Classpath and it runs without problems under IcedTea.
ECMAScript (pl, appeared 1997)
Creators: Brendan Eich
Origin: Ecma International
Country: Switzerland


ECMAScript (or ES) is a trademarked scripting-language specification standardized by Ecma International in ECMA-262 and ISO/IEC 16262. It was created to standardize JavaScript, so as to foster multiple independent implementations.  JavaScript has remained the best-known implementation of ECMAScript since the standard was first published, with other well-known implementations including JScript and ActionScript. ECMAScript is commonly used for client-side scripting on the World Wide Web, and it is increasingly being used for writing server applications and services using Node.js.
Ecological Metadata Language (xmlFormat, appeared 1997)
Also known as: eml
Origin: Ecological Society of America
Knowledge Network for Biocomplexity
Country: United States


Ecological Metadata Language (EML) is a metadata standard developed by and for the ecology discipline. It is based on prior work done by the Ecological Society of America and others, including the Knowledge Network for Biocomplexity. EML is a set of XML schema documents that allow for the structural expression of metadata.  It was developed specifically to allow researchers to document a typical data set in the ecological sciences. EML is largely designed to describe digital resources, however, it may also be used to describe non-digital resources such as paper maps and other non-digital media. The Knowledge Network for Biocomplexity project has developed a software client specifically to address this need. Morpho is data management software intended for generating metadata in EML format. Morpho is part of the DataONE Investigator Toolkit, and therefore intended to facilitate data sharing and reuse among ecologists and environmental scientists.
Embedded Crystal (template, appeared 2016)
Origin: Manas Technology Solutions
Country: Argentina
Website: https://manas.tech

Embedded Crystal (ECR) is a template language for embedding Crystal code into other text, that includes but is not limited to HTML. The template is read and transformed at compile time and then embedded into the binary.


GitHub description: The Crystal Programming Language

# greeting.ecr
<%- if @name -%>
Greeting, <%= @name %>!
<%- else -%>
Greeting!
<%- end -%>

Greeting.new(nil).to_s #=> Greeting!
Edge Side Includes (pl, appeared 2001)
Origin: Akamai Technologies, Inc
Art Technology Group
BEA Systems, Inc
Digital Island
FatWire Software
Vignette Corporation
Country: United States and New Zealand


Edge Side Includes or ESI is a small markup language for edge level dynamic web content assembly. The purpose of ESI is to tackle the problem of web infrastructure scaling. It is an application of edge computing. It is fairly common for websites to have generated content. It could be because of changing content like catalogs or forums, or because of personalization. This creates a problem for caching systems. To overcome this problem a group of companies (Akamai, Art Technology Group, BEA Systems, Circadence Corporation, Digital Island, Inc., Interwoven, Inc., Open Market, whose ESI-related technology is now owned by FatWire Software, Oracle Corporation and Vignette Corporation) developed the ESI specification and submitted it to the W3C for approval. The proposal editor was Mark Nottingham. ESI Language Specification 1.0 was submitted to the World Wide Web Consortium (W3C) for approval in August 2001. The W3C has acknowledged receipt, but has not accepted the proposal.ESI is implemented by some content delivery networks, such as Akamai, and by some caching proxy servers such as Varnish, Squid and Mongrel ESI, although many do not implement the complete specification. Akamai also adds additional features to the version they support.
Đ (pl, appeared 2019)
Also known as: edh
Creators: Compl Yue
Origin: https://github.com/e-wrks
Country: China
Website: https://github.com/e-wrks/edh

Edh is a dynamically & strongly typed, procedural (thus imperative), value-oriented (i.e. immutable first, yet with non-traditional Object constructs), interpreted programming language, that parasitic on GHC and heavily relying on the Haskell implementation of Software Transactional Memory for unified intuition of concurrency and data-consistency.


GitHub description: Đ (Edh) - The next-big-things ought to happen with Haskell not C/C++

method satExample() or ({generator _ ()
  for x1 from [true, false] do
  for x2 from [true, false] do
  # ...
  for xN from [true, false] do
  yield formula (
    x1, x2,
    # ...,
    xn
  )
})
Edinburgh IMP (pl, appeared 2002)
Origin: University of Edinburgh
Country: United Kingdom


Edinburgh IMP is a development of ATLAS Autocode, initially developed around 1966-1969 at Edinburgh University, Scotland.  IMP was a general-purpose programming language which was used heavily for systems programming. Expressively, IMP is extremely similar to Algol and includes all the Algol-style block structure, reserved keywords, and datatypes such as arrays and records.  It adds to Algol-style languages a string type (akin to a flex array of char) and built-in operators for string manipulation and character handling. IMP provides significant control over the storage mapping of data, plus commands for addressing within parts of words.  Most IMP compilers offer compiler-generated run-time checks and a backtrace facility by default, even in production code. IMP allows the programmer to inline machine language instructions in the IMP source code. Early IMP compilers were developed for the English Electric KDF9,  ICL System 4, UNIVAC 1108, IBM 360, DEC PDP-9, DEC PDP-15 and CTL Modular One computers. IMP was used to implement the EMAS operating system.  In later years a version of IMP called IMP77 was developed by Peter Robertson within the Computer Science department at Edinburgh which was a portable compiler that brought IMP to even more platforms.  In 2002 the IMP77 language was resurrected by the Edinburgh Computer History Project for Intel x86 hardware running DOS, Windows and Linux and is once again in use by Edinburgh graduates and ex-pats. The diverged IMP and IMP77 were later consolidated into a single language with the introduction of the IMP80 standard supported by implementations from the Edinburgh Regional Computer Centre.  IMP80 has also been ported to several platforms including Intel and was actively in use into the 1990s. Edinburgh IMP is unrelated to the later IMP extensible syntax programming language developed by Irons for the CDC 6600, which was the main language used by the NSA for many years.
Egison (pl, appeared 2013)
Creators: Satoshi Egi
Origin: University of Tokyo
Country: Japan
Website: https://www.egison.org/
File extensions: egi
Keywords: as
integer
list
matchAll
multiset
set
with



GitHub description: The Egison Programming Language

-- Extract all twin primes from the infinite list of prime numbers with pattern matching!
def twinPrimes :=
  matchAll primes as list integer with
    | _ ++ $p :: #(p + 2) :: _ -> (p, p + 2)
EGL (pl, appeared 2008)
Stands for: Enterprise Generation Language
Origin: IBM


EGL (Enterprise Generation Language), originally developed by IBM and now available as the EDT (EGL Development Tools) Open Source project under the Eclipse Public License (EPL), is a programming technology designed to meet the challenges of modern, multi-platform application development by providing a common language and programming model across languages, frameworks, and runtime platforms. The language borrows concepts familiar to anyone using statically typed languages like Java, COBOL, C, etc. However, it borrows the concept of stereotype from Unified Modeling Language (UML) that is not typically found in statically typed programming languages. In a nutshell, EGL is a higher-level, universal application development language. EGL is similar in syntax to other common languages so it can be learned by application developers with similar previous programming background. EGL application development abstractions shield programmers from the technical interfaces of systems and middleware allowing them to focus on building business functionality. EGL applications and services are written, tested and debugged at the EGL source level, and once they are satisfactorily functionally tested they can be compiled into COBOL, Java, or JavaScript code to support deployment of business applications that can run in any of the following environments: Platforms with a Java virtual machine, such as Microsoft Windows, Linux, and UNIX, for example in the context of a Java EE servlet container (IBM WebSphere Application Server, Apache Tomcat, GlassFish) IBM System z: CICS Transaction Server, IMS, z/OS Batch, UNIX System Services, WebSphere Application Server, z/VSE, Linux IBM System i: IBM i5/OS, IBM WebSphere Application Server, Apache Tomcat, Integrated Web Application Server for i Web browsers supporting JavaScript, such as Internet Explorer, Firefox, and Safari, for Ajax rich web applications
Eiffel (pl, appeared 1986)
Creators: Bertrand Meyer
Origin: Eiffel Software
Country: Various
Website: https://dev.eiffel.com/Main_Page
File extensions: e


Eiffel is an object-oriented programming language designed by Bertrand Meyer (an object-orientation proponent and author of Object-Oriented Software Construction) and Eiffel Software. Meyer conceived the language in 1985 with the goal of increasing the reliability of commercial software development; the first version becoming available in 1986. In 2005, Eiffel became an ISO-standardized language. The design of the language is closely connected with the Eiffel programming method. Both are based on a set of principles, including design by contract, command–query separation, the uniform-access principle, the single-choice principle, the open–closed principle, and option–operand separation. Many concepts initially introduced by Eiffel later found their way into Java, C#, and other languages. New language design ideas, particularly through the Ecma/ISO standardization process, continue to be incorporated into the Eiffel language.

GitHub description: Public mirror of https://svn.eiffel.com/eiffelstudio-public/trunk, see https://github.com/EiffelSoftware/libraries  for libraries
ELAN (pl, appeared 1974)
Origin: Technical University of Berlin
Country: Germany
Website: http://www.cs.ru.nl/elan/


ELAN is an educational programming language for learning and teaching systematic programming. It was developed in 1974 by C.H.A. Koster and a group at the Technical University of Berlin as an alternative to BASIC in teaching, and approved for use in secondary schools in Germany by the "Arbeitskreis Schulsprache". It is in use in a number of schools in Germany, Belgium, the Netherlands, and Hungary for informatics teaching in secondary education, and used at the Radboud University Nijmegen in the Netherlands for teaching systematic programming to students from various disciplines and in teacher courses. The language design focuses strongly on structured programming, and has a special construction for stepwise refinement, allowing students to focus on top-down design, and bottom-up coding.
Extensible Linking Format (binaryExecutable, appeared 1999)
Stands for: Extensible Linking Format
Origin: Unix System Laboratories
Country: United States


In computing, the Executable and Linkable Format (ELF, formerly named Extensible Linking Format), is a common standard file format for executable files, object code, shared libraries, and core dumps. First published in the specification for the application binary interface (ABI) of the Unix operating system version named System V Release 4 (SVR4), and later in the Tool Interface Standard, it was quickly accepted among different vendors of Unix systems. In 1999, it was chosen as the standard binary file format for Unix and Unix-like systems on x86 processors by the 86open project. By design, ELF is flexible, extensible, and cross-platform, not bound to any given central processing unit (CPU) or instruction set architecture. This has allowed it to be adopted by many different operating systems on many different hardware platforms.
ELFE (pl, appeared 2003)
Creators: Christophe de Dinechin
Origin: https://dinechin.org
Country: France

ELFE is a very simple and small programming language specifcally designed for everyday programming, notably for the Internet of Things.


GitHub description: Extensible Language for Everyday

invoke "sensor.corp.net",
    last_temperature := temperature
    every 1s,
        check_temperature temperature
    check_temperature T:real ->
        writeln "Measuring temperature ", T, " from process ", process_id
        if abs(T - last_temperature) >= 1.0 then
            reply
                temperature_changed T, last_temperature
        last_temperature := T
temperature_changed new_temp, last_temp ->
    writeln "Temperature changed from ", last_temp, " to ", new_temp
Elixir (pl, appeared 2011)
Creators: José Valim
Origin: The Elixir Team
Country: United States
Website: https://elixir-lang.org
File extensions: ex
exs
Keywords: after
and
catch
do
else
end
false
fn
in
nil
not
or
rescue
true
when


Elixir is a functional, concurrent, general-purpose programming language that runs on the Erlang virtual machine (BEAM). Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications. Elixir also provides a productive tooling and an extensible design. The latter is supported by compile-time metaprogramming with macros and polymorphism via protocols. Elixir is used by companies such as E-MetroTel, Pinterest and Moz. Elixir is also used for web development, by companies such as Bleacher Report, Discord, and Inverse, and for building embedded systems. The community organizes yearly events in United States, Europe and Japan as well as minor local events and conferences.

GitHub description: Elixir is a dynamic, functional language designed for building scalable and maintainable applications