pldb/PLDB huggingface dataset:
Modula-3 (pl, appeared 1986)
Also known as: m3
Origin: Digital Equipment Corporation
elego Software Solutions GmbH
Country: United States and Germany
Website: http://www.modula3.org
Keywords: AND
ANY
ARRAY
AS
BEGIN
BITS
BRANDED
BY
CASE
CONST
DIV
DO
ELSE
ELSIF
END
EVAL
EXCEPT
EXCEPTION
EXIT
EXPORTS
FINALLY
FOR
FROM
GENERIC
IF
IMPORT
IN
INTERFACE
LOCK
LOOP
METHODS
MOD
MODULE
NOT
OBJECT
OF
OR
OVERRIDES
PROCEDURE
RAISE
RAISES
READONLY
RECORD
REF
REPEAT
RETURN
REVEAL
SET
THEN
TO
TRY
TYPE
TYPECASE
UNSAFE
UNTIL
UNTRACED
VALUE
VAR
WHILE
WITH


Modula-3 is a programming language conceived as a successor to an upgraded version of Modula-2 known as Modula-2+. While it has been influential in research circles (influencing the designs of languages such as Java, C#, and Python) it has not been adopted widely in industry. It was designed by Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan (before at the Olivetti Software Technology Laboratory), Bill Kalsow and Greg Nelson at the Digital Equipment Corporation (DEC) Systems Research Center (SRC) and the Olivetti Research Center (ORC) in the late 1980s. Modula-3's main features are simplicity and safety while preserving the power of a systems-programming language. Modula-3 aimed to continue the Pascal tradition of type safety, while introducing new constructs for practical real-world programming. In particular Modula-3 added support for generic programming (similar to templates), multithreading, exception handling, garbage collection, object-oriented programming, partial revelation and explicit mark of unsafe code. The design goal of Modula-3 was a language that implements the most important features of modern imperative languages in quite basic forms. Thus allegedly dangerous and complicating features such as multiple inheritance and operator overloading were omitted.
Modula (pl, appeared 1975)
Creators: Niklaus Wirth
Origin: ETH Zurich
Country: Switzerland


The Modula programming language is a descendant of the Pascal programming language. It was developed in Switzerland in the 1970s by Niklaus Wirth, the same person who designed Pascal. The main innovation of Modula over Pascal is a module system, used for grouping sets of related declarations into program units; hence the name Modula. The language is defined in a report by Wirth called Modula. A language for modular multiprogramming published 1976. Modula was first implemented by Niklaus Wirth himself on a PDP-11. Very soon other implementations followed, most important the University of York Modula compiler and a compiler developed at Philips Laboratories named PL Modula, which generated code for the LSI-11 microprocessor. The development of Modula was discontinued soon after its publication. Wirth then concentrated his efforts on Modula's successor, Modula-2.
Module Management System (pl, appeared 2005)
Origin: https://github.com/endlesssoftware
Country: Australia

MMK is similar in functionality to Digital's DEC/Module Management System (MMS), and understands a syntax in its description files which is a superset of that which is understood by MMS.



!
! $Id: descrip.mms 35 2008-01-08 21:37:42Z tmr $
!
! Project:  LISP -- The LISP Interpreter
! Created:  22-DEC-2008 18:35
! Author:   tmr

cc = cc
cflags = /define="_VMS_=1" -
/WARN=DISABLE=(ZERODIV,FLOATOVERFL,NOMAINUFLO) -
/IEEE_MODE=UNDERFLOW_TO_ZERO/FLOAT=IEEE
core = LISP_CORE
main = LISP_MAIN
exec = [.bin]LISP
clib = SYS$LIBRARY:VAXCRTL
head = LISP_CORE
objs = $(core).obj, $(main).obj

$(exec) : $(objs)
        DEFINE/NOLOG LNK$LIBRARY $(clib)
        LINK/EXEC=$(exec) $(objs)
        DEASSIGN LNK$LIBRARY

$(core).obj : $(core).c, $(head).h

$(main).obj : $(main).c, $(head).h

clean :
        del *.obj;*
        del *.exe;*
moinmoin (textMarkup, appeared 2000)
Origin: https://github.com/moinwiki
Country: Germany
Website: http://moinmo.in/HelpOnMoinWikiSyntax




Table of contents:
<<TableOfContents()>>

Table of contents (up to 2nd level headings only):
<<TableOfContents(2)>>

= heading 1st level =
== heading 2nd level ==
=== heading 3rd level ===
==== heading 4th level ====
===== heading 5th level =====
====== no heading 6th level ======
Mojo (pl, appeared 2022)
Creators: Chris Lattner
Website: https://www.modular.com/mojo
File extensions: mojo

Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models.


GitHub description: The Mojo Programming Language

def softmax(lst):
  norm = np.exp(lst - np.max(lst))
  return norm / norm.sum()

struct NDArray:
  def max(self) -> NDArray:
    return self.pmap(SIMD.max)

struct SIMD[type: DType, width: Int]:
  def max(self, rhs: Self) -> Self:
    return (self >= rhs).select(self, rhs)
Molecular Query Language (queryLanguage, appeared 2007)
Origin: Goethe University Frankfurt
Country: Germany

We have developed a Java library for substructure matching that features easy-to-read syntax and extensibility. This molecular query language (MQL) is grounded on a context-free grammar, which allows for straightforward modification and extension. The formal description of MQL is provided in this paper. Molecule primitives are atoms, bonds, properties, branching, and rings. User-defined features can be added via a Java interface. In MQL, molecules are represented as graphs. Substructure matching was implemented using the Ullmann algorithm because of favorable run-time performance. The Ullmann algorithm carries out a fast subgraph isomorphism search by combining backtracking with effective forward checking. MQL software design was driven by the aim to facilitate the use of various cheminformatics toolkits. Two Java interfaces provide a bridge from our MQL package to an external toolkit: the first one provides the matching rules for every feature of a particular toolkit; the second one converts the found match from the internal format of MQL to the format of the external toolkit. We already implemented these interfaces for the Chemistry Development Toolkit.
Mond (pl, appeared 2014)
Creators: Rohan Singh
Origin: https://github.com/Rohansi/Mond
Country: Canada
Website: https://web.archive.org/web/20160429013247/https://rohbot.net/mond/
Keywords: Infinity
NaN
break
case
const
continue
debugger
default
do
else
false
for
foreach
fun
global
if
in
null
return
seq
switch
true
undefined
var
while
yield

A scripting language for C# which can be embedded in Lua-like manner.


GitHub description: A scripting language for .NET Core

// documentation can be found here: https://github.com/Rohansi/Mond/wiki
seq range(start, end) {
    for (var i = start; i <= end; i++)
        yield i;
}

seq where(list, filter) {
    foreach (var x in list) {
        if (filter(x))
            yield x;
    }
}

seq select(list, transform) {
    foreach (var x in list)
        yield transform(x);
}

fun toArray(list) {
    var array = [];

    foreach (var value in list) {
        array.add(value);
    }

    return array;
}

return range(0, 1000)
       |> where(x -> x % 2 == 0)
       |> select(x -> x / 2)
       |> toArray();
MongoDB (application, appeared 2009)
Origin: https://www.mongodb.com/community/forums/
Website: https://www.mongodb.com/
Keywords: find
findOne
drop
createIndex


MongoDB (from humongous) is a free and open-source cross-platform document-oriented database program. Classified as a NoSQL database program, MongoDB uses JSON-like documents with schemas. MongoDB is developed by MongoDB Inc., and is published under a combination of the GNU Affero General Public License and the Apache License.

GitHub description: The MongoDB Database
Monkey (pl, appeared 2011)
Creators: Anthony Diamond
Origin: https://github.com/Regal-Internet-Brothers
Country: United States
Website: https://web.archive.org/web/20171205070657/http://monkey-x.com/


Monkey X is a high-level programming language designed for video game development for many different platforms, including desktop and laptop computers, mobile phones, tablets, and video game consoles. The language itself is an object-oriented dialect of BASIC, which the compiler translates into native source code for several target platforms. The resulting code is then compiled normally. Currently the official target platforms include: Windows (Including the Windows 8 store), OS X, Linux, Xbox 360, Android, iOS, among others. Community-driven, user-made targets have also been created, some notable user-targets include: MonkeyMax (BlitzMax), Monkey-Python (Python), and a Nintendo DS target.Monkey X's main implementation (compiler), and a number of official modules are open source. Monkey X's main application/game framework, Mojo, is partially commercial. The compiler and most of the official modules can be found on GitHub. Monkey is also distributed in several compiled binary forms from its official website (registration required, to build the compiler). For details, see: Mojo (framework), and Game targets (technical).

GitHub description: A modified version of the TransCC "driver" for Monkey's compiler, adapted slightly to work in web browsers.
MOO (pl, appeared 1993)
Stands for: MUD, object-oriented
Origin: University of Waterloo
Country: Canada


The MOO programming language is a relatively simple programming language used to support the MOO Server. It is dynamically typed and uses a prototype-based object-oriented system, with syntax roughly derived from the Algol school of programming languages.


@program toy:wind
this.wound = this.wound + 2;
player:tell("You wind up the ", this.name,".");
player.location:announce(player.name, " winds up the ", this.name,".");
.
MINI OBJECT-ORIENTED LANGUAGE (pl, appeared 2010)
Origin: Universidade de Lisboa
Country: Portugal
Website: http://rss.di.fc.ul.pt/tools/mool/

Mool is a mini object-oriented language in a Java-like style with support for concurrency, that allows programmers to specify class usage protocols as types.



class File { 
   usage lin{open; Read} where 
   Read = lin{eof; <lin{close; end} + lin{read; Read}>};
 ...
}
MoonScript (pl, appeared 2011)
Origin: https://github.com/leafo/moonscript/issues
Country: United States
Website: http://moonscript.org/



GitHub description: :crescent_moon: A language that compiles to Lua

class Thing
  name: "unknown"

class Person extends Thing
  say_name: => print "Hello, I am #{@name}!"

with Person!
  .name = "MoonScript"
  \say_name!
MOOSE (pl, appeared 1994)
Origin: University of California, Los Angeles
Country: United States

MOOSE is a Maisie-based Object-Oriented Simulation Environment that uses inheritance to support iterative design of efficient simulation models.  The novel features of MOOSE include its ability to describe complex guards that may be used by an object to specify dynamic enabling conditions for its methods and may also be inherited selectively by a derived object.  MOOSE is the first simulation environment to suggest the use of inheritance in driving parallel implementations of an object that may exploit specific knowledge about the application, architecture, or simulation algorithm to improve its efficiency.  The paper introduces object-oriented design of simulation models, gives an overview of MOOSE, and illustrates its use in the design of parallel simulation models.  Experimental results are provided on the speedup achieved by a parallel simulation of a simple stochastic benchmark.
Morfik (pl, appeared 2000)
Origin: Morfik Technology Pty Ltd
Country: Australia


Morfik Technology Pty Ltd. is an Australian software company that was acquired by Altium in 2010.  The company is known for developing a set of visual designers, compilers and a Framework combined in an Integrated development environment (IDE) aimed at developing Ajax applications in a high-level language such as Java, C#, BASIC or Object Pascal.  Morfik includes visual design tools for Web interfaces, database structure, and queries.  It supports the classic client–server model, however like all Ajax applications, the client-side code runs within a browser. The Morfik development tool converts the forms that the user draws into DHTML, compiles the client-logic into JavaScript, and builds the application and database server engines to house the server-side code.
Morse code (notation, appeared 1837)
Country: United States


Morse code is a character encoding scheme used in telecommunication that encodes text characters as standardized sequences of two different signal durations called dots and dashes  or dits and dahs. Morse code is named for Samuel F. B. Morse, an inventor of the telegraph. The International Morse Code encodes the ISO basic Latin alphabet, some extra Latin letters, the Arabic numerals and a small set of punctuation and procedural signals (prosigns). Each Morse code symbol is formed by a sequence of dots and dashes. The dot duration is the basic unit of time measurement in Morse code transmission. The duration of a dash is three times the duration of a dot. Each dot or dash within a character is followed by period of signal absence, called a space, equal to the dot duration. The letters of a word are separated by a space of duration equal to three dots, and the words are separated by a space equal to seven dots. To increase the efficiency of encoding, Morse code was designed so that the length of each symbol is approximately inverse to the frequency of occurrence in text of the English language character that it represents. Thus the most common letter in English, the letter "E", has the shortest code: a single dot. Because the Morse code elements are specified by proportion rather than specific time durations, the code is usually transmitted at the highest rate that the receiver is capable of decoding. The Morse code transmission rate (speed) is specified in groups per minute, commonly referred to as words per minute.Morse code is usually transmitted by on-off keying of an information carrying medium such as electric current, radio waves, visible light or sound waves.  The current or wave is present during time period of the dot or dash and absent during the time between dots and dashes.Morse code can be memorized, and Morse code signalling in a form perceptible to the human senses, such as sound waves or visible light, can be directly interpreted by persons trained in the skill.Because many non-English natural languages use other than the 26 Roman letters, Morse alphabets have been developed for those languages.  In an emergency, Morse code can be generated by improvised methods such as turning a light on and off, tapping on an object or sounding a horn or whistle, making it one of the simplest and most versatile methods of telecommunication. The most common distress signal is SOS – three dots, three dashes, and three dots – internationally recognized by treaty.


−− −−− ·−· ··· ·       −·−· −−− −·· ·
Mortran (pl, appeared 1973)
Origin: Stanford University
Country: United States


Mortran (More Fortran) is an extension of the Fortran programming language used for scientific computation. It introduces syntax changes, including the use of semicolons to end statements, in order to improve readability and flexibility. Mortran code is macro-processed into Fortran code for compilation. Note that Mortran, like many preprocessors, does not make a complete analysis of the Fortran source and, like many preprocessors, may not always make its assumptions/requirements explicit.  Consider, for example, Mortran multiple assignment.  From the Mortran User Guide:  produces the following FORTRAN statements:  In this example, the produced Fortran implements the multiple assignment correctly only if X is not aliased to I or to A(I,K), assuming the multiple assignment semantics are left to right.
Motif (pl, appeared 1989)
Origin: Open Software Foundation
Country: United States


In computing, Motif refers to both a graphical user interface (GUI) specification and the widget toolkit for building applications that follow that specification under the X Window System on Unix and Unix-like operating systems. Motif is the toolkit for the Common Desktop Environment and IRIX Interactive Desktop, thus it was the standard widget toolkit for Unix. Closely related to Motif is the Motif Window Manager (MWM). After many years as proprietary software, Motif was released in 2012, as free software under the GNU Lesser General Public License (LGPL).
Mouse (pl, appeared 1970)
Origin: https://sourceforge.net/p/mouse/mailman
Country: United States
Website: https://mouse.sourceforge.net


The Mouse programming language is a small computer programming language developed by Dr. Peter Grogono in the late 1970s and early 1980s. It was developed as an extension of an earlier language called MUSYS, which was used to control digital and analog devices in an electronic music studio. Mouse was originally intended as a small, efficient language for microcomputers with limited memory.  It is an interpreted, stack-based language and uses Reverse Polish notation.  To make an interpreter as easy as possible to implement, Mouse is designed so that a program is processed as a stream of characters, interpreted one character at a time. The elements of the Mouse language consist of a set of (mostly) one-character symbols, each of which performs a specific function (see table below).  Since variable names are limited to one character, there are only 26 possible variables in Mouse (named A-Z).  Integers and characters are the only available data types. Despite these limits, Mouse includes a number of relatively advanced features, including:  Conditional branching Loops Pointers Macros (subroutines (which may be recursive)) Arrays Code tracingThe design of the Mouse language makes it ideal for teaching the design of a simple interpreter.  Much of the book describing Mouse is devoted to describing the implementation of two interpreters, one in Z80 assembly language, the other in Pascal.
mpl (pl, appeared 1988)
Origin: Maximal Software, Inc.
Country: United States
Website: http://www.maximalsoftware.com/mpl/
File extensions: mpl




{   Planning.mpl   } 

{   Aggregate production planning for 12 months   } 


TITLE 
   Production_Planning; 

INDEX 
   product = 1..3; 
   month   = (January,February,March,April,May,June,July,
              August,September,October,November,December); 

DATA 
   price[product]              := (105.09, 234.00, 800.00);
   Demand[month,product]       := 1000 DATAFILE(demand.dat);
   ProductionCapacity[product] := 1000 (10, 42, 14);
   ProductionCost[product]     := (64.30, 188.10, 653.20);
   InventoryCost               := 8.8 ; 

DECISION VARIABLES
   Inventory[product,month]     ->  Invt
   Production[product,month]    ->  Prod
   Sales[product,month]         ->  Sale 

MACRO 
   Revenues  := SUM(product,month: price * Sales);
   TotalCost := SUM(product,month: InventoryCost * Inventory
                                 + ProductionCost * Production);
MODEL

   MAX   Profit  =  Revenues - TotalCost ;

SUBJECT TO
   InventoryBalance[product,month]  ->  IBal : 
   Inventory  =  Inventory[month-1] + Production - Sales ;

BOUNDS 
   Sales  < ProductionCapacity ; Inventory[month="January..November]" < 90000 ; 
   Inventory[month="December]" ; END
MPS (grammarLanguage, appeared 2010)
Stands for: Meta programming System
Origin: JetBrains s.r.o.
Country: Czech Republic
Website: https://www.jetbrains.com/mps/

With MPS you can define custom editors for a new language and make using these DSLs simpler. Even domain experts, who are not familiar with traditional programming, can easily work in MPS with domain-specific languages designed around their domain-specific terminology.

JetBrains MPS is a metaprogramming system which is being developed by JetBrains. MPS is a tool to design Domain-specific languages (DSL). It uses projectional editing which allows users to overcome the limits of language parsers, and build DSL editors, such as ones with tables and diagrams. It implements language-oriented programming. MPS is an environment for language definition, a language workbench, and integrated development environment (IDE) for such languages.

GitHub description: JetBrains Meta programming System
MQL5 (pl, appeared 2005)
Origin: MetaQuotes Software
Country: Russia


MQL4 (MetaQuotes Language 4) and MQL5 (MetaQuotes Language 5) are integrated programming languages designed for developing trading robots, technical market indicators, scripts and function libraries within the MetaTrader software. The primary objective of MQL4 and MQL5 is automation of trading and facilitation of operational analysis. MQL4 and MQL5 comprises an extensive codebase source code library used for developing trading robots.
Message Queuing Telemetry Transport (protocol, appeared 1999)
Stands for: Message Queuing Telemetry Transport
Origin: Organization for the Advancement of Structured Information Standards
Country: United States
Website: http://mqtt.org/


MQTT (Message Queuing Telemetry Transport) is an ISO standard (ISO/IEC PRF 20922) publish-subscribe-based messaging protocol. It works on top of the TCP/IP protocol. It is designed for connections with remote locations where a "small code footprint" is required or the network bandwidth is limited. The publish-subscribe messaging pattern requires a message broker. Andy Stanford-Clark of IBM and Arlen Nipper of Cirrus Link authored the first version of the protocol in 1999.In 2013, IBM submitted MQTT v3.1 to the OASIS specification body with a charter that ensured only minor changes to the specification could be accepted. MQTT-SN is a variation of the main protocol aimed at embedded devices on non-TCP/IP networks, such as Zigbee. Historically, the "MQ" in "MQTT" came from the IBM MQ (then 'MQSeries') message queuing product line. However, queuing itself is not required to be supported as a standard feature in all situations.Alternative message-oriented middleware includes the  Advanced Message Queuing Protocol (AMQP),  Streaming Text Oriented Messaging Protocol (STOMP), the IETF Constrained Application Protocol, XMPP, DDS, OPC UA, and Web Application Messaging Protocol (WAMP).
Mscgen (textMarkup, appeared 2016)
Origin: https://code.google.com/archive/p/mscgen/issues
Country: United Kingdom
Website: http://www.mcternan.me.uk/mscgen/




# MSC for some fictional process
msc {
  hscale = "2";

  a,b,c;

  a->b [ label = "ab()" ] ;
  b->c [ label = "bc(TRUE)"];
  c=>c [ label = "process(1)" ];
  c=>c [ label = "process(2)" ];
  ...;
  c=>c [ label = "process(n)" ];
  c=>c [ label = "process(END)" ];
  a<<=c [ label = "callback()"];
  ---  [ label = "If more to run", ID="*" ];
  a->a [ label = "next()"];
  a->c [ label = "ac1()\nac2()"];
  b<-c [ label = "cb(TRUE)"];
  b->b [ label = "stalled(...)"];
  a<-b [ label = "ab() = FALSE"];
}
MSX BASIC (pl, appeared 1984)
Origin: Microsoft
Country: United States


MSX BASIC is a dialect of the BASIC programming language. It is an extended version of Microsoft Standard BASIC Version 4.5, and includes support for graphic, music, and various peripherals attached to MSX Personal Computers. Generally, MSX-BASIC is designed to follow GW-BASIC, which is one of the standard BASICs running on 16-bit computers. During the creation of MSX-BASIC, effort was made to make the system flexible and expandable.
Marine Trading Markup Language (xmlFormat, appeared 2000)
Also known as: mtml
Origin: shipserv
Country: United Kingdom
Website: https://www.shipserv.com

The Marine Trading Markup Language (MTML), formalized in the MTML Document Type Definition, "is a standard to help a broad base of small, medium and large buyers and suppliers in the marine trading industry conduct their fundamental trading transactions electronically via the Internet."