pldb/PLDB huggingface dataset:
Mech (pl, appeared 2018)
Creators: Corey Montella
Origin: Lehigh University
Country: United States
Website: http://mech-lang.org

Mech is a language for developing data-driven, reactive systems like animations, games, and robots. It makes composing, transforming, and distributing data easy, allowing you to focus on the essential complexity of your problem.


GitHub description: 🦾 Main repository for the Mech programming language. Start here! 

# Breakout

## The Game

game setup
  #system/timer = [resolution: 15 tick: 0 hours: 0 minutes: 0 seconds: 0]
  #app/main = [root: "drawing" direction: _ contains: [#game]]

game area
  #game = [|type     class contains    parameters|
            #paddle-control
            "canvas" _     [#elements] [width: 400 height: 400]]

controller slider
  #paddle-control = [type: "slider" class: _ contains: _ parameters:  [min: 0 max: 300 value: 40]]

draw the game area
  pos = #paddle-control{1,4}{1,3}
  start = pos
  end = pos + 100
  #elements = [|shape    parameters|
                "circle" [cx: #ball.x cy: #ball.y radius: 10 fill: "#000000"]
                "line"   [x1: start y1: 350 x2: end y2: 350 stroke: "#000000"]]

## The Ball

block
  #ball = [x: 20 y: 20 vx: 1 vy: 3]

update ball position
  ~ #system/timer.tick
  #ball.x := #ball.x + #ball.vx
  #ball.y := #ball.y + #ball.vy

bounce the ball off the paddle
  ~ #ball.y
  pos = #paddle-control{1,4}{1,3}
  start = pos
  end = pos + 100
  ix = #ball.y > 340 & #ball.x > start & #ball.x < end & #ball.y < 342
  #ball.vy{ix} := -#ball.vy

bounce the ball off the ceiling
  ~ #ball.y
  #ball.vy{#ball.y < 10} := -#ball.vy

bounce the ball off the walls
  ~ #ball.x
  #ball.vx{#ball.x > 390 | #ball.x < 10} := -#ball.vx

reset the ball if it makes it past the paddle
  ~ #ball.y
  ix = #ball.y > 390
  #ball.x{ix} := 20
  #ball.y{ix} := 20
MediaWiki (wikiMarkup, appeared 2002)
Also known as: wikitext
wikicode
wiki markup
Origin: Wikimedia Foundation, Inc
Country: United States
Website: https://en.wikipedia.org/wiki/MediaWiki#Markup

The syntax and keywords used by the MediaWiki software to format a page.

MediaWiki is a free and open-source wiki software. Originally developed by Magnus Manske and improved by Lee Daniel Crocker, it runs on many websites, including Wikipedia, Wiktionary and Wikimedia Commons. It is written in the PHP programming language and stores the contents into a database. Like WordPress, which is based on a similar licensing and architecture, it has become the dominant software in its category. The first version of the software was deployed to serve the needs of the Wikipedia encyclopedia in 2002. Wikipedia and other Wikimedia Foundation projects continue to define a large part of the requirement set for MediaWiki. The software is optimized to efficiently handle large projects, which can have terabytes of content and hundreds of thousands of hits per second. Because Wikipedia is one of the world's largest websites, achieving scalability through multiple layers of caching and database replication has been a major concern for developers. The software has more than 900 configuration settings and more than 1,900 extensions available for enabling various features to be added or changed. On Wikipedia alone, more than 1000 automated and semi-automated bots and other tools have been developed to assist in editing. It has also been deployed by some companies as an internal knowledge management system, and some educators have assigned students to use MediaWiki for collaborative group projects.


= Heading 1 =
Indentation as used on talk pages:
:Each colon at the start of a line
::causes the line to be indented by three more character positions.
:::(The indentation persists
* Item1
* Item2
* Item3
* Item4
** Sub-item 4 a)
*** Sub-item 4 a) 1.
**** Sub-item 4 a) 1. i)
**** Sub-item 4 a) 1. ii)
** Sub-item 4 b)
=== Ordered Lists ===
* Item5
# Item1
# Item2
# Item3
# Item4
## Sub-item 1
### Sub-sub-item
#### Sub-sub-sub-item
## Sub-item 2
# Item5
MEDUSA (pl, appeared 2002)
Origin: Cambridge University
Country: United Kingdom


MEDUSA, (since 2004 MEDUSA4) is a CAD program used in the areas of mechanical and plant engineering by manufacturers and Engineering, Procurement and Construction (EPC) companies. The system's history is closely tied to the beginnings of mainstream CAD and the research culture fostered by Cambridge University and the UK government as well as the resulting transformation of Cambridge into a world-class tech centre in the 1980s.
Melody (pl, appeared 2022)
Creators: Yoav Lavi
Origin: https://github.com/yoav-lavi/melody/issues
Country: Israel
Website: https://yoav-lavi.github.io/melody/book/

Melody - A language that compiles to regular expressions and aims to be more easily readable and maintainable


GitHub description: Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable
Memex (computingMachine, appeared 1945)
Creators: Vannevar Bush
Origin: Office of Scientific Research and Development
Country: United States


The memex (originally coined "at random", though sometimes said to be a portmanteau of "memory" and "index") is the name of the hypothetical proto-hypertext system that Vannevar Bush described in his 1945 The Atlantic Monthly article "As We May Think". Bush envisioned the memex as a device in which individuals would compress and store all of their books, records, and communications, "mechanized so that it may be consulted with exceeding speed and flexibility".  The memex would provide an "enlarged intimate supplement to one's memory". The concept of the memex influenced the development of early hypertext systems (eventually leading to the creation of the World Wide Web) and personal knowledge base software.  The hypothetical implementation depicted by Bush for the purpose of concrete illustration was based upon a document bookmark list of static microfilm pages and lacked a true hypertext system, where parts of pages would have internal structure beyond the common textual format. Early electronic hypertext systems were thus inspired by memex rather than modeled directly upon it.
Mercurial (application, appeared 2005)
Origin: https://www.mercurial-scm.org/wiki/BugTracker
Country: United States


Mercurial is a distributed revision-control tool for software developers. It is supported on Microsoft Windows and Unix-like systems, such as FreeBSD, macOS and Linux. Mercurial's major design goals include high performance and scalability, decentralized, fully distributed collaborative development, robust handling of both plain text and binary files, and advanced branching and merging capabilities, while remaining conceptually simple. It includes an integrated web-interface. Mercurial has also taken steps to ease the transition for users of other version control systems, particularly Subversion. Mercurial is primarily a command-line driven program, but graphical user interface extensions are available, e.g. TortoiseHg, and several IDEs offer support for version control with Mercurial. All of Mercurial's operations are invoked as arguments to its driver program hg (a reference to Hg - the chemical symbol of the element mercury). Matt Mackall originated Mercurial and serves as its lead developer. Mercurial is released as free software under the terms of the GNU GPL v2 (or any later version). It is mainly implemented using the Python programming language, but includes a binary diff implementation written in C.
Mercury (pl, appeared 1995)
Creators: Zoltan Somogyi
Origin: University of Melbourne
Country: Australia
Website: http://www.mercurylang.org
File extensions: m


Mercury is a functional logic programming language made for real-world uses. The first version was developed at the University of Melbourne, Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's supervision, and released on April 8, 1995. Mercury is a purely declarative logic programming language. It is related to both Prolog and Haskell. It features a strong, static, polymorphic type system, and a strong mode and determinism system. The official implementation, the Melbourne Mercury Compiler, is available for most Unix and Unix-like platforms, including Linux, macOS, and for Windows (32bits only).
mermaid (textMarkup, appeared 2014)
Origin: https://github.com/mermaid-js
Country: Various
Website: https://mermaidjs.github.io/



GitHub description: Generation of diagram and flowchart from text in a similar manner as markdown

gitGraph:
options
{
    "nodeSpacing": 150,
    "nodeRadius": 10
}
end
commit
branch newbranch
checkout newbranch
commit
commit
checkout master
commit
commit
merge newbranch
Mesa (pl, appeared 1970)
Origin: Computer Systems Laboratory
Country: United States


Mesa is a programming language developed in the late 1970s at the Xerox Palo Alto Research Center in Palo Alto, California, United States. The language name was a pun based upon the programming language catchphrases of the time, because Mesa is a "high level" programming language. Mesa is an ALGOL-like language with strong support for modular programming. Every library module has at least two source files: a definitions file specifying the library's interface plus one or more program files specifying the implementation of the procedures in the interface. To use a library, a program or higher-level library must "import" the definitions. The Mesa compiler type-checks all uses of imported entities; this combination of separate compilation with type-checking was unusual at the time.Mesa introduced several other innovations in language design and implementation, notably in the handling of software exceptions, thread synchronization, and incremental compilation. Mesa was developed on the Xerox Alto, one of the first personal computers with a graphical user interface, however most of the Alto's system software was written in BCPL. Mesa was the system programming language of the later Xerox Star workstations, and for the GlobalView desktop environment.  Xerox PARC later developed Cedar, which was a superset of Mesa. Mesa and Cedar had a major influence on the design of other important languages, such as Modula-2 and Java, and was an important vehicle for the development and dissemination of the fundamentals of GUIs, networked environments, and the other advances Xerox contributed to the field of computer science.
Meson (pl, appeared 2013)
Origin: https://github.com/mesonbuild
Country: Various


Meson (/ˈmɛ.sɒn/) is a software tool for automating the building (compiling) of software. The overall goal for Meson is to promote programmer productivity.Meson is free and open-source software written in Python 3 and subject to the terms of the Apache 2.0 License.
MessagePack (binaryDataFormat, appeared 2009)
Origin: https://github.com/msgpack
Country: Various
Website: https://msgpack.org/


MessagePack is a computer data interchange format. It is a binary form for representing simple data structures like arrays and associative arrays. MessagePack aims to be as compact and simple as possible. The official implementation is available in a variety of languages such as C, C++, C#, D, Erlang, Go, Haskell, Java, JavaScript, Lua, OCaml, Perl, PHP, Python, Ruby, Scala, Smalltalk, and Swift.
Meta-Assembler (assembly, appeared 1977)
Also known as: MASM
Origin: UNIVAC Sperry
Country: United States

This manual describes the SPERRY UNIVAC 1100 Series Meta-Assembler (MASM) processor and language. This manual is directed to users with basic Assembler programming knowledge and experienc€~. Definition of the machine language which is to be assembled by MASM is not given in this document. This information is available in the relevant hardware manuals. MASM is called a meta-assembler because it is not specifically bound to generating code for a particular hardwar~ architecture. With an unaltered environment, MASM will generate code for an 1100 Serit:!s hardware architecture. However, with the directives and built-in functions provided, the user may alter the environment to generate code for any hardware architecture. This assumes the output of MASM (1100 Series Relocatable Binary Format) can be converted to an acceptable form for to the operating system on .the alternate architecture. The processor accepts both Fieldata and ASCII input and maintains character constants in either code as specified by the user. MASM uses,an internal code to store character constants which do not have to be maintained iri a specific character code. MASM performs specified tasks based on the interpretation of statements received primarily via the Source Input Routine (SIR$) and produces an output. The output produced depends upon the user's request. If a relocatable binary element is requested, it is produced by the Relocatable Output Routine (ROH). M,A,SM optionally produces a printed listing of the the input and its processed form. The structure of both the input and output forms are presented elsewhere in this manual. MASM performs its function in two scans of the input. The first scan is known as the summary pass, and the second is known as the generative pass. These two passes of the source input, that is, from the first source image encountered to the last source image, are known as the main assembly. Assemblies invoked within the main assembly are known as subassemblies. Certain initialization is done at the start of each pass
Meta II (grammarLanguage, appeared 1962)
Origin: University of California, Los Angeles
Country: United States


META II is a domain-specific programming language for writing compilers. It was created in 1963-1964 by Dewey Val Schorre at UCLA. META II uses what Schorre called syntax equations. Its operation is simply explained as:   Each syntax equation is translated into a recursive subroutine which tests the input string for a particular phrase structure, and deletes it if found. Meta II programs are compiled into an interpreted byte code language. VALGOL and SMALGOL compilers illustrating its capabilities were written in the META II language,  VALGOL is a simple algebraic language designed for the purpose of illustrating META II. SMALGOL was a fairly large subset of ALGOL 60.
MetaComCo (pl, appeared 1981)
Also known as: MBASIC ABasiC AmigaDOS
Origin: MetaComCo
Country: England


MetaComCo (MCC) was a computer systems software company started in 1981 and based in Bristol, England by Peter Mackeonis and Derek Budge. A division of Tenchstar, Ltd. MetaComCo's first product was an MBASIC compatible interpreter for IBM PCs, which was licensed by Peter Mackeonis to Digital Research in 1982, and issued as the Digital Research Personal Basic, or PBASIC, running under CP/M. Other computer languages followed, also licensed by Digital Research and MetaComCo established an office in Pacific Grove, California, to service their United States customers. In 1984 Dr. Tim King joined the company, bringing with him a version of the operating system TRIPOS for the Motorola 68000 processor which he had previously worked on whilst a researcher at the University of Cambridge. This operating system was used as the basis of AmigaDOS (file-related functions of AmigaOS); MetaComCo won the contract from Commodore because the original planned Amiga disk operating system called Commodore Amiga Operating System (CAOS) was behind schedule; timescales were incredibly tight and TRIPOS provided a head start for a replacement system. MetaComCo also developed ABasiC for the Amiga which was initially provided with Amigas. Much to Commodore's annoyance MetaComCo also worked with Atari to produce the BASIC that was initially provided with the Atari ST — ST BASIC. The company also sold the Lattice C compiler for the Sinclair QL and the Atari ST and range of other languages  (e.g. Pascal, BCPL) for m68k-based computers. MetaComCo also represented LISP and REDUCE software from the RAND Corporation. Several of the team at MetaComCo went on to found Perihelion Software. Mackeonis founded Triangle Publishing, the software publishing company responsible for creating the ST Organizer for the Atari ST and PC Organizer and Counterpoint (a GUI system) for Amstrad Computers and GoldStar computers.
METAFONT (application, appeared 1977)
Origin: Stanford University
Country: United States


Metafont is a description language used to define raster fonts. It is also the name of the interpreter that executes Metafont code, generating the bitmap fonts that can be embedded into e.g. PostScript. Metafont was devised by Donald Knuth as a counterpart to his TeX typesetting system. One of the characteristics of Metafont is that all of the shapes of the glyphs are defined with geometrical equations. In particular, one can define a given point to be the intersection of a line segment and a Bézier cubic.
Metal (library, appeared 2014)
Origin: Apple
Country: United States


Metal is a low-level, low-overhead hardware-accelerated 3D graphic and compute shader application programming interface (API) developed by Apple Inc., and which debuted in iOS 8. Metal combines functions similar to OpenGL and OpenCL under one API. It is intended to bring to iOS, macOS, and tvOS apps some of the performance benefits of similar APIs on other platforms, such as Vulkan (which debuted in mid-February 2016) and DirectX 12.  Metal is an object-oriented API that can be invoked using the Swift or Objective-C programming languages.  Full-blown control of the Metal framework (as well as the related MetalKit framework) is accessible via the Metal Unified Graphics and Compute Language. According to Apple promotional materials: "Metal is a C++ based programming language that developers can use to write code that is executed on the GPU for graphics and general-purpose data-parallel computations. Since Metal is based on C++, developers will find it familiar and easy to use. With Metal, both graphics and compute programs can be written with a single, unified language, which allows tighter integration between the two."
METAPOST (pl, appeared 1994)
Creators: John D. Hobby
Origin: https://web.archive.org/web/20070929092912/http://foundry.supelec.fr/projects/metapost/
Country: Various

A graphics language that can output PostScript, SVG, and some other formats.

MetaPost refers to both a programming language and the interpreter of the MetaPost programming language. Both are derived from Donald Knuth's Metafont language and interpreter. MetaPost produces vector graphic diagrams from a geometric/algebraic description. The language shares Metafont's declarative syntax for manipulating lines, curves, points and geometric transformations. However,  Metafont is set up to produce fonts, in the form of image files (in .gf format) with associated font metric files (in .tfm format), whereas MetaPost produces EPS, SVG, or PNG files The output of Metafont consists of the fonts at a fixed resolution in a raster-based format, whereas MetaPost's output is vector-based graphics (lines, Bézier curves) Metafont output is monochrome, whereas MetaPost uses RGB or CMYK colors. The MetaPost language can include text labels on the diagrams, either strings from a specified font, or anything else that can be typeset with TeX. Starting with version 1.8, Metapost allows floating-point arithmetic with 64 bits (default: 32 bit fixed-point arithmetic)Many of the limitations of MetaPost derive from features of Metafont. For instance, MetaPost does not support all features of PostScript. Most notably, paths can have only one segment (so that regions are simply connected), and regions can be filled only with uniform colours. PostScript level 1 supports tiled patterns and PostScript 3 supports Gouraud shading.


beginfig(2);
u=1cm;
draw (2u,2u)--(0,0)--(0,3u)--(3u,0)--(0,0);
pickup pencircle scaled 4pt;
for i=0 upto 2:
 for j=0 upto 2: drawdot (i*u,j*u); endfor
endfor
endfig
MewMew (esolang, appeared 2020)
Creators: Palash Bauri
Origin: https://github.com/bauripalash/mewmew/issues
Country: India
Website: https://palashbauri.in/mewmew



GitHub description: /ᐠ｡ꞈ｡ᐟ\ MewMew Programming Language - Program in Cats' Language
mgmt (pl, appeared 2015)
Creators: James Shubin
Origin: https://github.com/purpleidea/mgmt/issues
Country: Canada
Website: https://purpleidea.com/tags/mgmtconfig/



GitHub description: Next generation distributed, event-driven, parallel config management!

import "datetime"
$is_friday = datetime.weekday(datetime.now()) == "friday"
file "/srv/files/" {
 state => $const.res.file.state.exists,
 mode => if $is_friday { # this updates the mode, the instant it changes!
   "0550"
 } else {
   "0770"
 },
}
MHEG-5 (schema, appeared 1997)
Origin: Multimedia and Hypermedia Experts Group
Country: Switzerland


MHEG-5, or ISO/IEC 13522-5, is part of a set of international standards relating to the presentation of multimedia information, standardised by the Multimedia and Hypermedia Experts Group (MHEG). It is most commonly used as a language to describe interactive television services.
ΜC++ (pl, appeared 1992)
Creators: pabuhr
Origin: University of Waterloo
Country: Canada
Website: https://plg.uwaterloo.ca/usystem/uC++.html


μC++, also called uC++, is a programming language, an extension of C++ designed for concurrent programming. Among other features, it adds coroutines, tasks, and monitors, and extends existing language constructs to integrate with them. Its compiler, named u++, operates as a source-to-source translator targeting C++. μC++ is part of the μSystem project, of the University of Waterloo, Ontario, Canada, a large-scale project led by professor Peter Buhr with the goal to create a "highly-concurrent shared-memory programming system".It is used in course CS 343 in University of Waterloo.Every μC++ program should include the uC++.h header file before any other header, although this is not necessary for more recent versions. uC++ is now open source, available on GitHub.

GitHub description: concurrency for C++
mdl (isa, appeared 2019)
Stands for: Microarchitecture Description Language
Creators: Reid Tatge
Origin: https://github.com/MPACT-ORG
Country: United States
Website: https://github.com/MPACT-ORG

We’ve created a DSL and compiler for modeling micro-architecture that handles a very broad class of architectures - CPU, GPUs, VLIWs, DSPs, ML accelerators, and embedded devices. This effort grew out of a need to quickly develop and experiment with high-quality compilers and tools to facilitate rapid architecture exploration. We named the DSL “MDL” for “Microarchitecture Description Language”


GitHub description: The LLVM Project is a collection of modular and reusable compiler and toolchain technologies. Note: the repository does not accept github pull requests at this moment. Please submit your patches at http://reviews.llvm.org.
MicroPython (pl, appeared 2014)
Creators: Damien P. George
Origin: https://github.com/micropython
Country: Australia and The Netherlands
Website: https://micropython.org/


MicroPython is a software implementation of the Python 3 programming language, written in C, that is optimized to run on a microcontroller. MicroPython is a full Python compiler and runtime that runs on the micro-controller hardware. The user is presented with an interactive prompt (the REPL) to execute supported commands immediately. Included are a selection of core Python libraries; MicroPython includes modules which give the programmer access to low-level hardware.MicroPython was originally created by the Australian programmer and physicist Damien George, after a successful Kickstarter backed campaign in 2013. While the original Kickstart campaign released MicroPython with a pyboard microcontroller, MicroPython supports a number of ARM based architectures. MicroPython has since been run on Arduino platform based products, ESP8266, ESP32, and Internet of things hardware. In 2016 a version of MicroPython for the BBC Micro Bit was created as part of the Python Software Foundation's contribution to the Micro Bit partnership with the BBC.The source code for the project is available on GitHub.

GitHub description: MicroPython - a lean and efficient Python implementation for microcontrollers and constrained systems