MDL, short for MIT Design Language, is a high-level programming language developed at the Massachusetts Institute of Technology (MIT) in the late 1960s by Gerald Sussman and Carl Hewitt. Originally designed for artificial intelligence and symbolic processing, MDL extended the capabilities of Lisp with built-in data types, structures, and control mechanisms suited for complex AI programs, simulation systems, and interactive environments. Developers historically accessed MDL through MIT’s ITS (Incompatible Timesharing System) or later emulators, with code interpreted directly in memory, as no modern installer exists; archival resources and historical documentation are available at MDL Programming Language Archive.

MDL was created to address limitations in early AI programming, particularly the need for flexible symbolic processing, dynamic data structures, and interactive program construction. Its design emphasizes extensibility, dynamic evaluation, and expressive symbolic manipulation, allowing programmers to prototype AI algorithms efficiently and represent complex knowledge structures directly in code.

MDL: Data Types and Variables

MDL supports multiple data types including numbers, strings, lists, and symbolic atoms. Variables are dynamically typed and can hold any of these data structures, allowing flexible representation of AI concepts.

; Define variables
:set x 42
:set y "hello"
:set mylist (1 2 3 4 5)

; Display values
:print x
:print y
:print mylist

Variables in MDL can be reassigned or manipulated at runtime. Lists are fundamental structures, supporting recursive and iterative processing similar to Lisp.

MDL: Functions and Procedures

Functions (also called procedures) are declared with define and can take arguments to process data. Recursion is heavily used for symbolic computation.

; Define a factorial function
:define factorial (n)
  (if (= n 0)
      1
      (* n (factorial (- n 1))))

; Compute factorial of 5
:print (factorial 5)

Functions in MDL allow modular code and reuse of symbolic and numerical operations. Conditional expressions use if and cond to branch logic.

MDL: Lists and Iteration

Lists are core to MDL programming. Iteration over lists is done using recursive or built-in iteration constructs, allowing manipulation of sequences and complex structures.

; Sum all elements of a list
:define sum-list (lst)
  (if (null lst)
      0
      (+ (car lst) (sum-list (cdr lst))))

:print (sum-list mylist)

Recursive processing of lists supports symbolic reasoning, AI algorithms, and manipulation of hierarchical data, analogous to Lisp and PLANNER implementations.

MDL: Symbolic Evaluation

MDL allows dynamic creation and evaluation of symbolic expressions at runtime.

; Define a symbolic expression
:set expr (+ x 10)

; Evaluate expression
:print (eval expr)

This dynamic evaluation is key for AI programs, enabling meta-programming, rule-based systems, and on-the-fly computation of symbolic formulas, similar in concept to Lisp and PLANNER.

MDL is historically significant in the development of artificial intelligence, symbolic processing, and interactive computing. Its features influenced later languages and AI frameworks, and it is studied today for historical insights alongside Lisp, PLANNER, and early AI scripting systems.

Compiler
Script
Toolkit

Explore More