pldb/PLDB huggingface dataset:
Microsoft BASIC (pl, appeared 1975)
Origin: Microsoft


Microsoft BASIC is the foundation product of the Microsoft company. It first appeared in 1975 as Altair BASIC, which was the first BASIC by Microsoft and the first high level programming language available for the Altair 8800 microcomputer. During the home computer craze during the late-1970s and early-1980s, Microsoft BASIC was ported to and supplied with practically every computer design. Slight variations to add support for machine-specific functions led to a profusion of related designs like Commodore BASIC and Atari Microsoft BASIC. As the early home computers gave way to newer designs like the IBM PC and Apple Macintosh, BASIC was no longer as widely used, although it retained a strong following. The release of Visual BASIC reignited its popularity and it remains in wide use on Microsoft Windows platforms in its most recent incarnation, Visual Basic .NET
Microsoft Macro Assembler (assembly, appeared 1981)
Origin: Microsoft
Website: https://docs.microsoft.com/en-us/cpp/assembler/masm/microsoft-macro-assembler-reference


The Microsoft Macro Assembler (MASM) is an x86 assembler that uses the Intel syntax for MS-DOS and Microsoft Windows. Beginning with MASM 8.0 there are two versions of the assembler - one for 16-bit and 32-bit assembly sources, and another (ML64) for 64-bit sources only. MASM is maintained by Microsoft, but since version 6.12 has not been sold as a separate product, it is instead supplied with various Microsoft SDKs and C compilers. Recent versions of MASM are included with Microsoft Visual Studio.
Meditech Interpretive Information System (pl, appeared 1986)
Stands for: Meditech Interpretive Information System
Origin: Massachusetts General Hospital
Country: United States


MIIS (Meditech Interpretive Information System) is a MUMPS-like programming language that was created by A.Neil Pappalardo and Curt W. Marble, on a DEC PDP at Mass General Hospital from 1964 to 1968. MUMPS evolution took two major directions: MUMPS proper and MIIS. MUMPS became an ANSI and ISO-standard language. When many MUMPS implementations standardized to be compatible, MIIS did not standardize, but became a proprietary system instead. As an example of the differences between MUMPS and MIIS, the value of a logical expression in MUMPS may be false = zero (0) or true = non-zero, canonically, one (1). In MIIS, the value false is the empty string and the value of true is a string consisting of the ASCII delete character (code 127 decimal). There is also a philosophical difference between the dialects.  MIIS often takes the approach that code should march along, regardless of possible errors, where MUMPS will error out to prevent more serious problems.  For example, when encountering an undefined variable, MUMPS generates an error where MIIS treats it as nil. In the 1980s Brigham and Women's Hospital in Massachusetts used MIIS to program their Data General Mainframe. In 1986, SCAMC reported that Vancouver General Hospital also had an Integrated Cardiology Patient Management System written in MIIS. The MIIS language has been used in programming library systems as well as health industry systems. The OCLC's library system is one example. It has also been used to create financial systems for insurance brokers, as seen in Ireland and the UK in the late 1970s.
MIME (textDataFormat, appeared 1991)
Stands for: Multipurpose Internet Mail Extensions
Creators: Nathaniel Borenstein
Ned Freed
Origin: Carnegie Mellon University
Country: United States


Multipurpose Internet Mail Extensions (MIME) is an Internet standard that extends the format of email to support:  Text in character sets other than ASCII Non-text attachments: audio, video, images, application programs etc. Message bodies with multiple parts Header information in non-ASCII character setsVirtually all human-written Internet email and a fairly large proportion of automated email is transmitted via SMTP in MIME format.MIME is specified in six linked RFC memoranda:  RFC 2045,  RFC 2046,  RFC 2047,  RFC 4288,  RFC 4289 and   RFC 2049; with the integration with SMTP email specified in detail in   RFC 1521 and   RFC 1522. Although MIME was designed mainly for SMTP, the content types defined by MIME standards are also of importance in communication protocols outside of email, such as HTTP for the World Wide Web. Servers insert the MIME header at the beginning of any Web transmission. Clients use this content type or media type header to select an appropriate viewer application for the type of data the header indicates. Some of these viewers are built into the Web client or browser (for example, almost all browsers come with GIF and JPEG image viewers as well as the ability to handle HTML files).


MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=frontier

This is a message with multiple parts in MIME format.
--frontier
Content-Type: text/plain

This is the body of the message.
--frontier
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64

PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUg
Ym9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==
--frontier--
MIMIC (pl, appeared 1964)
Origin: Wright-Patterson Air Force Base
Country: United States


MIMIC, known in capitalized form only, is a former simulation computer language developed 1964 by H. E. Petersen, F. J. Sansom and L. M. Warshawsky of Systems Engineering Group within the Air Force Materiel Command at the Wright-Patterson AFB in Dayton, Ohio, United States. It is an expression-oriented continuous block simulation language, but capable of incorporating blocks of FORTRAN-like algebra. MIMIC is a further development from MIDAS (Modified Integration Digital Analog Simulator), which represented analog computer design. Written completely in FORTRAN but one routine in COMPASS, and ran on Control Data supercomputers, MIMIC is capable of solving much larger simulation models. With MIMIC, ordinary differential equations describing mathematical models in several scientific disciplines as in engineering, physics, chemistry, biology, economics and as well as in social sciences can easily be solved by numerical integration and the results of the analysis are listed or drawn in diagrams. It also enables the analysis of nonlinear dynamic conditions. The MIMIC software package, written as FORTRAN overlay programs, executes input statements of the mathematical model in six consecutive passes. Simulation programs written in MIMIC are compiled rather than interpreted. The core of the simulation package is a variable step numerical integrator of fourth-order Runge-Kutta method. Many useful functions related to electrical circuit elements exist besides some mathematical functions found in most scientific programming languages. There is no need to sort the statements in order of dependencies of the variables, since MIMIC does it internally. Parts of the software organized in overlays are:  MIMIN (input)– reads in user simulation program and data, MIMCO (compiler) – compiles the user program and creates an in-core array of instructions, MIMSO (sort)– sorts the instructions array after dependencies of variables, MIMAS (assembler) – converts the BCD instructions into machine-oriented code, MIMEX (execute)– executes the user program by integrating, MIMOUT (output)– puts out the data as a list or diagram of data.
mimium (pl, appeared 2019)
Creators: Tomoya Matsuura
Origin: Kyushu University
Country: Japan
Website: https://mimium.org

mimium (MInimal Musical medIUM) a programming language as an infrastructure for sound and music.


GitHub description: mimium (MInimal Musical medIUM) a programming language as an infrastructure for sound and music.

// A minimal example below generates a sinewave of 440Hz:
// minimal.mmm
twopi = 3.141595*2
sr = 48000
fn dsp(){
    out = sin(now * 440 * twopi / sr)
    return (out,out)
}
mimix-stream-language (pl, appeared 2018)
Also known as: msl
Creators: Rommel MARTINEZ
Origin: https://github.com/themimixcompany
Country: United States
Website: https://mimix.io/dev/msl

MSL is built from Lisp style s-expressions. MSL differs from Lisp in the way it processes functions and arguments, so Lisp expressions cannot be directly included inside MSL nor vice-versa. MSL code can only contain other MSL.


GitHub description: MSL Engine

(@lonely-planet Lonely Planet (@Hawaii)
(@intro The goddess (@Pele) …)
(@chapter 1 (@p1 When the ancient (@Hawaii Hawaiians)…) (@p2 ...))
(@chapter 2 …)))
MINC (pl, appeared 1985)
Origin: Princeton University
Country: United States


MINC ("MINC is not C") is a data specification language written in the mid-1980s by a Princeton University graduate student named Lars Graf. This kind of naming is known as a "recursive acronym".  It contains many (though not all) of the syntactical capabilities of the C programming language, and can be used to implement simple procedural programs that can be executed by a runtime parser (that is to say, MINC does not need to be compiled in any way).  MINC continues to be used only in a handful of programs written in the 1980s (e.g. Real-Time Cmix). It has been for all intents and purposes superseded by modern scripting languages such as Perl, Python, and Tcl. A controversial aspect of the language is whether it is pronounced "mink" or "min-see".
MiniD (pl, appeared 2006)
Creators: Jarrett Billingsley
Origin: http://www.dsource.org/projects/minid
Country: United States
Website: http://www.dsource.org/projects/minid


The MiniD (has been renamed Croc) programming language is a small, lightweight, extension language in the vein of Lua or Squirrel, but designed to be used mainly with the D programming language.  It supports both object-oriented and imperative programming paradigms, as well as some simple functional aspects. Distributed under the licence of zlib/libpng, MiniD is free software.


module matrix

local SIZE = 30

function mkmatrix(rows, cols)
{
    local count = 1
    local m = array.new(rows)

    for(i: 0 .. rows)
    {
        m[i] = array.new(cols)

        for(j: 0 .. cols)
        {
            ++count
            m[i][j] = count
        }
    }

    return m
}

function mmult(rows, cols, m1, m2, m3)
{
    for(i: 0 .. rows)
    {
        for(j: 0 .. cols)
        {
            local val = 0

            for(k: 0 .. cols)
                val += m1[i][k] * m2[k][j]

            m3[i][j] = val
        }
    }

    return m3
}

function main(N)
{
    local n = 1

    if(isString(N))
        n = toInt(N)

    local m1 = mkmatrix(SIZE, SIZE)
    local m2 = mkmatrix(SIZE, SIZE)
    local mm = mkmatrix(SIZE, SIZE)

    for(i: 0 .. n)
        mmult(SIZE, SIZE, m1, m2, mm)

    writefln(mm[0][0], " ", mm[2][3], " ", mm[3][2], " ", mm[4][4])
}
MIPS architecture (isa, appeared 1985)
Origin: MIPS Technologies
Imagination Technologies
Keywords: .data
.text
syscall
trap
add
addu
addi
addiu
and
andi
div
divu
mult
multu
nor
or
ori
sll
slv
sra
srav
srl
srlv
sub
subu
xor
xori
lhi
lho
lhi
llo
slt
slti
sltu
sltiu
beq
bgtz
blez
bne
j
jal
jalr
jr
lb
lbu
lh
lhu
lw
li
la
sb
sh
sw
mfhi
mflo
mthi
mtlo
move


MIPS is a reduced instruction set computer (RISC) instruction set architecture (ISA) developed by MIPS Technologies (formerly MIPS Computer Systems). The early MIPS architectures were 32-bit, with 64-bit versions added later. There are multiple versions of MIPS: including MIPS I, II, III, IV, and V; as well as five releases of MIPS32/64 (for 32- and 64-bit implementations, respectively). As of April 2017, the current version is MIPS32/64 Release 6. MIPS32/64 primarily differs from MIPS I–V by defining the privileged kernel mode System Control Coprocessor in addition to the user mode architecture. Several optional extensions are also available, including MIPS-3D which is a simple set of floating-point SIMD instructions dedicated to common 3D tasks, MDMX (MaDMaX) which is a more extensive integer SIMD instruction set using the 64-bit floating-point registers, MIPS16e which adds compression to the instruction stream to make programs take up less room, and MIPS MT, which adds multithreading capability. Computer architecture courses in universities and technical schools often study the MIPS architecture. The architecture greatly influenced later RISC architectures such as Alpha. As of April 2017, MIPS processors are used in embedded systems such as residential gateways and routers. Originally, MIPS was designed for general-purpose computing, and during the 1980s and 1990s, MIPS processors for personal, workstation, and server computers were used by many companies such as Digital Equipment Corporation, MIPS Computer Systems, NEC, Pyramid Technology, SiCortex, Siemens Nixdorf, Silicon Graphics, and Tandem Computers. Historically, video game consoles such as the Nintendo 64, Sony PlayStation, PlayStation 2 and PlayStation Portable use MIPS processors. MIPS processors also used to be popular in supercomputers during the 1990s, but all such systems have dropped off the TOP500 list. These uses were complemented by embedded applications at first, but during the 1990s, MIPS became a major presence in the embedded processor market, and by the 2000s, most MIPS processors were for these applications. In the mid- to late-1990s, it was estimated that one in three RISC microprocessors produced was a MIPS processor. MIPS is a modular architecture supporting up to four coprocessors (CP0/1/2/3). In MIPS terminology, CP0 is the System Control Coprocessor (an essential part of the processor that is implementation-defined in MIPS I–V), CP1 is an optional floating-point unit (FPU) and CP2/3 are optional implementation-defined coprocessors (MIPS III removed CP3 and reused its opcodes for other purposes). For example, in the PlayStation video game console, CP2 is the Geometry Transformation Engine (GTE), which accelerates the processing of geometry in 3D computer graphics.
Mirah (pl, appeared 2009)
Creators: Charles Oliver Nutter
Origin: https://github.com/mirah
Country: United States
Website: http://www.mirah.org


Mirah (formerly Duby) is a programming language based on Ruby language syntax, local type inference, hybrid static–dynamic type system, and a pluggable compiler toolchain. Mirah was created by Charles Oliver Nutter to be "a 'Ruby-like' language, probably a subset of Ruby syntax, that [could] compile to solid, fast, idiomatic JVM bytecode." The word mirah refers to the gemstone ruby in the Javanese language, a play on the concept of Ruby in Java.

GitHub description: The Mirah Programming Language

def foo(a:String, b:int)
Miranda (pl, appeared 1985)
Creators: David Turner
Origin: Research Software Ltd
Country: United Kingdom


Miranda is a lazy, purely functional programming language designed by David Turner as a successor to his earlier programming languages SASL and KRC, using some concepts from ML and Hope.  It was produced by Research Software Ltd. of England (which holds a trademark on the name Miranda) and was the first purely functional language to be commercially supported.Miranda was first released in 1985, as a fast interpreter in C for Unix-flavour operating systems, with subsequent releases in 1987 and 1989. Miranda had a strong influence on the later Haskell programming language.
Miva (pl, appeared 1996)
Origin: Miva Merchant, Inc
Country: United States
Website: http://www.mivascript.com
File extensions: mv
mvc
mvt


Miva Script is a proprietary computer scripting language mainly used for internet applications such as e-commerce. As of 2015, it is developed, maintained and owned by Miva Merchant, Inc., based in San Diego, California. Many web hosting companies support Miva Script on their servers, but it is significantly less widespread than other popular web languages.
ML (pl, appeared 1973)
Stands for: Meta Language
Creators: Robin Milner
Origin: University of Edinburgh
Country: United Kingdom


ML ('Meta Language') is a general-purpose functional programming language. It has roots in Lisp, and has been characterized as "Lisp with types". It is known for its use of the polymorphic Hindley–Milner type system, which automatically assigns the types of most expressions without requiring explicit type annotations, and ensures type safety – there is a formal proof that a well-typed ML program does not cause runtime type errors. ML provides pattern matching for function arguments, garbage collection, imperative programming, call-by-value and currying. It is used heavily in programming language research and is one of the few languages to be completely specified and verified using formal semantics. Its types and pattern matching make it well-suited and commonly used to operate on other formal languages, such as in compiler writing, automated theorem proving and formal verification.
MLAB (pl, appeared 1975)
Origin: National Institutes of Health
Country: United States


mLab is a fully managed cloud database service that hosts MongoDB databases. mLab runs on cloud providers Amazon, Google, and Microsoft Azure, and has partnered with platform-as-a-service providers. In May 2011, mLab secured $3 million in first-round funding from Foundry Group, Baseline Ventures, Upfront Ventures, Freestyle Capital and David Cohen.In October 2012, mLab received a follow-on investment of $5 million  and shortly thereafter, mLab was named by Network World as one of the 10 most useful cloud databases along with Amazon Web Services, Google Cloud SQL, Microsoft Azure, Rackspace, and others. In June 2014, MongoDB Inc. announced a fully managed highly available MongoDB-as-a-Service Add-On offering on the Microsoft Azure store. The offering is delivered in collaboration with Microsoft and mLab.In February 2016, mLab changed its name from MongoLab to mLab to expand into new areas and products.In October 2018, mLab announced that it will be acquired by MongoDB Inc., citing reasons of a shared vision and engineering culture. All engineers at mLab have been invited to join MongoDB Inc. All of mLab's customers will be transitioned to MongoDB Atlas instances.. The acquisition "is expected to close in the fourth quarter of MongoDB’s fiscal year ending Jan. 31, 2019".
mlir (ir, appeared 2019)
Creators: Chris Lattner
Origin: https://github.com/tensorflow
Country: Various
Website: https://mlir.llvm.org/



GitHub description: "Multi-Level Intermediate Representation" Compiler Infrastructure

// Syntactically similar to LLVM:
func @testFunction(%arg0: i32) {
  %x = call @thingToCall(%arg0) : (i32) -> i32
  br ^bb1
^bb1:
  %y = addi %x, %x : i32
  return %y : i32
}
mmix (assembly, appeared 1999)
Origin: HM Hochschule München University of Applied Sciences
Country: Germany

During the 1990s I spent considerable time designing a computer that would be representative of modern machines, yet easy to learn. Several of the leading experts in the field gave me considerable help with the design. The result was MMIX — "A RISC computer for the new millennium". In 1999 I completed the preliminary software to support basic MMIX programming and the simulation of many versions of the architecture.



 LOC Data_Segment
 GREG  @
Text  BYTE  "Hello world!",10,0

 LOC #100

Main  LDA $255,Text
 TRAP  0,Fputs,StdOut
 TRAP  0,Halt,0
MMX instruction set (isa, appeared 1997)
Origin: Intel Corporation
Country: United States


MMX is a single instruction, multiple data (SIMD) instruction set designed by Intel, introduced in 1997 with its P5-based Pentium line of microprocessors, designated as "Pentium with MMX Technology". It developed out of a similar unit introduced on the Intel i860, and earlier the Intel i750 video pixel processor. MMX is a processor supplementary capability that is supported on recent IA-32 processors by Intel and other vendors. MMX has subsequently been extended by several programs by Intel and others: 3DNow!, Streaming SIMD Extensions (SSE), and ongoing revisions of Advanced Vector Extensions (AVX).
mochi (pl, appeared 2014)
Origin: https://github.com/i2y/mochi/issues
Country: Japan

Mochi is a dynamically typed programming language for functional programming and actor-style programming. Its interpreter is written in Python3. The interpreter translates a program written in Mochi to Python3's AST / bytecode.


GitHub description: Dynamically typed functional programming language

def factorial(n, m):
   if n == 1:
       m
   else:
       factorial(n - 1, n * m)
Model 204 (pl, appeared 1972)
Origin: Computer Corporation of America
Country: United States


Model 204 (M204) is a database management system for IBM and compatible mainframe computers, “born” 1965 October 13, and first deployed in 1972. It incorporates a programming language and an environment for application development.  Implemented in assembly language for IBM System/360 and its successors, M204 can deal with very large databases and transaction loads of 1000 TPS.
Modelica (pl, appeared 1997)
Origin: Modelica Association
Country: Sweden
Website: http://www.modelica.org/


Modelica is an object-oriented, declarative, multi-domain modeling language for component-oriented modeling of complex systems, e.g., systems containing mechanical, electrical, electronic, hydraulic, thermal, control, electric power or process-oriented subcomponents. The free Modelica language is developed by the non-profit Modelica Association. The Modelica Association also develops the free Modelica Standard Library that contains about 1360 generic model components and 1280 functions in various domains, as of version 3.2.1.
Modula-2 (pl, appeared 1978)
Creators: Niklaus Wirth
Origin: ETH Zurich
Country: Switzerland
File extensions: mod
m2
def
MOD
DEF
mi
md


Modula-2 is a computer programming language designed and developed between 1977 and 1985 by Niklaus Wirth at the Swiss Federal Institute of Technology in Zurich (ETH Zurich) as a revision of Pascal to serve as the sole programming language for the operating system and application software for the personal workstation Lilith. The principal concepts were: The module as a compilation unit for separate compilation The coroutine as the basic building block for concurrent processes Types and procedures that allow access to machine-specific data. Modula-2 was viewed by Niklaus Wirth as a successor to his earlier programming languages Pascal and Modula. The language design was also influenced by the Mesa language and the new programming possibilities of the early personal computer Xerox Alto, both from Xerox, that Wirth saw during his 1976 sabbatical year at Xerox PARC. The computer magazine BYTE devoted the August 1984 issue to the language and its surrounding environment.