Doug Mc Ilroy (formerly )

Famous early Unix guy (see InventorsOfUnix); hounded Ken Thompson into creating pipes out of interest in coroutines and things similar to FlowBasedProgramming.

"Doug McIlroy, the inventor of pipes, is said to point out that both pipes and lazy lists behave exactly like coroutines."

Inventor of lots of things that he is not widely acknowledged for, such as macros. And (jointly) CoreWars!

Explicit pointer data types/variables as a higher level language construct were first introduced in PL/I, by Harold "Bud" Lawson with input from DonKnuth and DougMcIlroy

"McIlroy was probably the first to propose the modern form of macros and the idea of conditional assembly"

"McIlroy had been working on macros in the later 1950s, and was always theorizing to anyone who would listen about linking macros together to eliminate the need to make a series of discrete commands to obtain an end result. "If you think about macros," McIlroy explained, "they mainly involve switching data streams. I mean, you're taking input and you suddenly come to a macro call, and that says, 'Stop taking input from here and go take it from there.'"

"Somewhere at that time I talked of a macro as a 'switchyard for data streams,' and there's a paper hanging in Brian Kernighan's office, which he dredged up from somewhere, where I talked about screwing together streams like a garden hose. So this idea had been banging around in my head for a long time." SAP extended to include conditional and recursive macros: the beginning of the great macro-language tradition at Bell Labs (everything from L6 and AMBIT to C) macro assembler; 1959 Eastwood, D. E. and McIlroy, M. D. "Macro compiler modification of SAP". Bell Telephone Laboratories Computation Center, 1959 Arden, Bruce W. review of McIlroy 1960

      in ACM Computing Reviews, January-December 1960
      Macro processing modification of SAP. Led to TRAC.
                (accd. to
        This paper describes a form for defining new operations in
        terms of a basic assembly-like language and other defined
        operations. The use of such macro-instructions provides a concise
        way of describing complicated procedures The author describes
        and illustrates with examples the important features of these
        definitions such as (1) the ability to refer to other definitions,
        (2) the indication of a reference hierarchy by parentheses, (3)
        the ability to conditionally include or exclude instructions,
        and (4) the ability to create floating addresses. An application
        of these techniques to writing algebraic compilers is briefly
        indicated. This application deals only with fully parenthesized
        expressions and it is not clear how remote symbolic references
        (floating addresses) within definitions are handled.
           It is interesting to this reviewer to observe the gradual
        coalition of the structure of macro-assemblers (or compilers)
        and algebraic compilers. The author"s description of the coding
        that must be added to a programming routine to make it a macro-
        instruction compiler also constitutes a description of the
        essential portion of an algebraic compiler. This similarity
        suggests that an alternate approach might be to start instead
        with a base program which contains a syntactical scanner,
        a storage allocation procedure, and a mechanism for handling
        remote connections.
McIlroy, M.D., "Using SAP Macro Instructions to Manipulate Symbolic Expression,"
 Computer Laboratory Memo, Bell Telephone Laboratories, Murray Hill, N.J., 1960.

McIlroy, M. D. "Macro Instruction Extension of Compiler Languages"
      in [ACM] CACM 3(04) April 1960
        Macroinstruction compilers constructed from a small set of
        functions can be made extremely powerful. In particular,
        conditional assembly, nested definitions, and parenthetical
        notation serve to make a compiler capable of accepting very
        general extensions to its ground language.
Holbrook, Bernard D. and Brown, W. Stanley "A History of Computing Research at Bell Laboratories (1937-1975)" Computing Science Technical Report No. 99 1982
        In the late 1950s. several symbolic assembly languages, such as
        SAP, had become available, and by 1957 some of these, including
        IBM"s SCAT and SAP for the 704 machine, permitted users to
        define macroinstructions (often called macros) as shorthand for
        frequently occurring sequences of machine instructions. Then
        in 1959, M. Douglas McIlroy and Douglas E. Eastwood of Bell
        Labs introduced conditional and recursive macros into SAP,
        and in 1960 described how macros could be used to extend any
        programming language to meet the user"s own special requirements.
Syntax macros and extended translation Volume 9 , Issue 11 (November 1966) table of contents Pages: 790 - 793 Year of Publication: 1966 ISSN:0001-0782 Author B. M. Leavenworth
A translation approach is described which allows one to extend the syntax and semantics of a given high-level base language by the use of a new formalism called a syntax-macro. Syntax-macros define string transformations based on syntactic elements of the base language. Two types of macros are discussed, and examples are given of their use. The conditional generation of macros based on options and alternatives recognized by the scan are also described

From Macros to Reusable Generative Programming


EditText of this page (last edited July 25, 2008) or FindPage with title or text search