Advanced Languages for Systems Software: The Fox Project in 1994

It has been amply demonstrated in recent years that careful attention to the structure of systems software can lead to greater flexibility, reliability, and ease of implementation, without incurring an undue penalty in performance. It is our contention that advanced programming languages---particularly languages with a mathematically rigorous semantics, and featuring higher-order functions, polymorphic types, first-class continuations, and a useful and powerful module system---are ideally suited to expressing such structure. Indeed, our previous research has shown that the use of an advanced programming language can have a fundamental effect on system design, leading naturally to system architectures that are highly modular, efficient, and allow re-use of code. We are thus working to demonstrate the viability and benefits of advanced languages for programming real-world systems. To achieve this, we have organized our research into the three areas of language design, compiler technology, and systems building. This report describes the current plans for this effort, which we refer to as the Fox project.

[1]  Peter Henderson,et al.  Purely Functional Operating Systems , 1982 .

[2]  John C. Mitchell,et al.  On the type structure of standard ML , 1993, TOPL.

[3]  Rance Cleaveland,et al.  Implementing mathematics with the Nuprl proof development system , 1986 .

[4]  Olivier Danvy,et al.  Representing Control: a Study of the CPS Transformation , 1992, Mathematical Structures in Computer Science.

[5]  Manuel Fähndrich,et al.  Venari/ML Interfaces and Examples , 1993 .

[6]  David D. Clark,et al.  The structuring of systems using upcalls , 1985, SOSP '85.

[7]  Alexander Aiken,et al.  Soft typing with conditional types , 1994, POPL '94.

[8]  John C. Reynolds,et al.  The Coherence of Languages with Intersection Types , 1991, TACS.

[9]  Luca Cardelli,et al.  Modula-3 Report (revised) , 1992 .

[10]  Larry L. Peterson,et al.  A language-based approach to protocol implementation , 1993, TNET.

[11]  F. Pfenning.  Logic programming in the LF logical framework , 1991 .

[12]  Peter Lee,et al.  Standard ML Signatures for a Protocol Stack , 1993 .

[13]  Robin Milner,et al.  Commentary on standard ML , 1990 .

[14]  Xavier Leroy,et al.  Unboxed objects and polymorphic typing , 1992, POPL '92.

[15]  John H. Reppy,et al.  First-Class Synchronous Operations in Standard ML , 1989 .

[16]  David Turner.  An overview of Miranda , 1986, SIGP.

[17]  Frank Pfenning,et al.  Natural Semantics and Some of Its Meta-Theory in Elf , 1992, ELP.

[18]  Brian N. Bershad,et al.  Protocol service decomposition for high-performance networking , 1994, SOSP '93.

[19]  P. J. Landin.  The Mechanical Evaluation of Expressions , 1964, Comput. J..

[20]  Peter Sestoft,et al.  Partial evaluation and automatic program generation , 1993, Prentice Hall international series in computer science.

[21]  John C. Reynolds,et al.  Types, Abstraction and Parametric Polymorphism , 1983, IFIP Congress.

[22]  Rod M. Burstall,et al.  HOPE: An experimental applicative language , 1980, LISP Conference.

[23]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[24]  Xavier Leroy,et al.  The ZINC experiment : an economical implementation of the ML language , 1990 .

[25]  John C. Mitchell,et al.  An extension of standard ML modules with subtyping and inheritance , 1991, POPL '91.

[26]  Martín Abadi,et al.  A Theory of Primitive Objects - Untyped and First-Order Systems , 1994, TACS.

[27]  Pierre-Louis Curien,et al.  The Categorical Abstract Machine , 1987, Sci. Comput. Program..

[28]  Alan Jay Smith,et al.  Experimental evaluation of on-chip microprocessor cache memories , 1984, ISCA '84.

[29]  David Turner.  An approach to functional operating systems , 1990 .

[30]  J. Gregory Morrisett,et al.  Adding threads to Standard ML , 1990 .

[31]  Martín Abadi,et al.  A Theory of Primitive Objects: Second-Order Systems , 1995, Sci. Comput. Program..

[32]  John C. Reynolds,et al.  Definitional Interpreters for Higher-Order Programming Languages , 1972, ACM '72.

[33]  Alain Deutsch,et al.  On determining lifetime and aliasing of dynamically allocated data in higher-order functional specifications , 1989, POPL '90.

[34]  Andrew W. Appel,et al.  Standard ML of New Jersey , 1991, PLILP.

[35]  Kenneth P. Birman,et al.  Reliable communication in the presence of failures , 1987, TOCS.

[36]  Ascander Suarez.  Compiling ML into CAM , 1990 .

[37]  John Hughes,et al.  Why Functional Programming Matters , 1989, Comput. J..

[38]  D. A. Turner,et al.  Miranda: A Non-Strict Functional language with Polymorphic Types , 1985, FPCA.

[39]  Luca Cardelli,et al.  Typeful Programming , 1989, Formal Description of Programming Concepts.

[40]  Michael N. Nelson,et al.  An Implementation of UNIX on an Object-oriented Operating System , 1993, USENIX Winter.

[41]  R. Milner,et al.  A Logic for Computable Functions with Reflexive and Polymorphic Types , 1975 .

[42]  Larry L. Peterson,et al.  A language-based approach to protocol implementation , 1992, SIGCOMM '92.

[43]  Andrew P. Tolmach.  Tag-free garbage collection using explicit type parameters , 1994, LFP '94.

[44]  Mark Lillibridge,et al.  Explicit polymorphism and CPS conversion , 1993, POPL '93.

[45]  Didier Rémy,et al.  Type checking records and variants in a natural extension of ML , 1989, POPL '89.

[46]  Benjamin C. Pierce,et al.  Object-oriented programming without recursive types , 1993, POPL '93.

[47]  Neil D. Jones,et al.  Mix: A self-applicable partial evaluator for experiments in compiler generation , 1989, LISP Symb. Comput..

[48]  Kim B. Bruce.  Safe type checking in a statically-typed object-oriented programming language , 1993, POPL '93.

[49]  F. Honsell,et al.  A Framework for De ning LogicsRobert Harper , 1987 .

[50]  Mark Lillibridge,et al.  A type-theoretic approach to higher-order modules with sharing , 1994, POPL '94.

[51]  Jeannette M. Wing,et al.  Tinkertoy Transactions , 1993 .

[52]  John C. Reynolds,et al.  GEDANKEN—a simple typeless language based on the principle of completeness and the reference concept , 1970, Commun. ACM.

[53]  Susan J. Eggers,et al.  A case for runtime code generation , 1993 .

[54]  William Stoye,et al.  A new scheme for writing functional operating systems , 1984 .

[55]  Alain Deutsch,et al.  An Operational Model of Strictness Properties and Its Abstractions (Extended Abstract) , 1991, Functional Programming.

[56]  Calton Pu,et al.  Incremental partial evaluation: the key to high performance, modularity and portability in operating systems , 1993, PEPM '93.

[57]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[58]  Robert Cartwright,et al.  Soft typing , 2004, SIGP.

[59]  Larry L. Peterson,et al.  The x-kernel: a platform for accessing internet resources , 1990, Computer.

[60]  Murray Hill.  An Implementation of Standard ML Modules , 1988 .

[61]  Paul R. Wilson,et al.  Effective “static-graph” reorganization to improve locality in garbage-collected systems , 1991, PLDI '91.

[62]  G.D. Plotkin,et al.  LCF Considered as a Programming Language , 1977, Theor. Comput. Sci..

[63]  David B. MacQueen.  Modules for standard ML , 1984, LFP '84.

[64]  Paul Hudak,et al.  ORBIT: an optimizing compiler for scheme , 1986, SIGPLAN '86.

[65]  Manuel Fähndrich,et al.  Extensions to Standard ML to Support Transactions , 1992 .

[66]  Andrew W. Appel,et al.  Continuation-passing, closure-passing style , 1989, POPL '89.

[67]  Forbes AvenuePittsburgh,et al.  Compiler Veriication in Lf , 1992 .

[68]  Joyce L. Vedral,et al.  Functional Programming Languages and Computer Architecture , 1989, Lecture Notes in Computer Science.

[69]  Xavier Leroy,et al.  Polymorphic type inference and assignment , 1991, POPL '91.

[70]  Henry Massalin,et al.  Synthesis: an efficient implementation of fundamental operating system services , 1992 .

[71]  Yousef A. Khalidi,et al.  Spring Virtual Memory System, The , 1993 .

[72]  Jeannette M. Wing,et al.  Persistence+undoability=transactions , 1992, Proceedings of the Twenty-Fifth Hawaii International Conference on System Sciences.

[73]  John H. Reppy,et al.  CML: A Higher-Order Concurrent Language , 1991, PLDI.

[74]  Benjamin G. Zorn,et al.  Comparing mark-and sweep and stop-and-copy garbage collection , 1990, LISP and Functional Programming.

[75]  William J. Bolosky,et al.  Mach: A New Kernel Foundation for UNIX Development , 1986, USENIX Summer.

[76]  Luca Cardelli,et al.  The Modula–3 type system , 1989, POPL '89.

[77]  Luca Cardelli,et al.  Compiling a functional language , 1984, LFP '84.

[78]  Jean D. etc. Ichbiah.  Reference Manual for the ADA Programming Language , 1983 .

[79]  Xavier Leroy,et al.  Manifest types, modules, and separate compilation , 1994, POPL '94.

[80]  T. Anderson,et al.  Eecient Software-based Fault Isolation , 1993 .

[81]  Robin Milner,et al.  Edinburgh lcf: a mechanized logic of computation , 1978 .

[82]  Andrew W. Appel,et al.  A Standard ML compiler , 1987, FPCA.

[83]  Gordon D. Plotkin,et al.  Call-by-Name, Call-by-Value and the lambda-Calculus , 1975, Theor. Comput. Sci..

[84]  Per Martin-Löf,et al.  Constructive mathematics and computer programming , 1984 .

[85]  Andrew W. Appel,et al.  Compiling with Continuations , 1991 .

[86]  John C. Reynolds,et al.  Towards a theory of type structure , 1974, Symposium on Programming.

[87]  Robert Harper,et al.  Typing first-class continuations in ML , 1991, POPL '91.

[88]  John H. Reppy,et al.  Asynchronous Signals is Standard ML , 1990 .

[89]  Guy L. Steele,et al.  A compiler for scheme (a study in compiler optimization) , 1978 .

[90]  E. B. Moss,et al.  Nested Transactions: An Approach to Reliable Distributed Computing , 1985 .

[91]  John C. Reynolds,et al.  Preliminary design of the programming language Forsythe , 1988 .

[92]  Fritz Henglein,et al.  Efficient Type Inference for Higher-Order Binding-Time Analysis , 1991, FPCA.

[93]  John C. Mitchell,et al.  The essence of ML , 1988, POPL '88.

[94]  Calton Pu,et al.  Threads and input/output in the synthesis kernal , 1989, SOSP '89.

[95]  Fritz Henglein,et al.  Global tagging optimization by type inference , 1992, LFP '92.

[96]  Paul Rovner.  Extending Modula-2 to Build Large, Integrated Systems , 1986, IEEE Software.

[97]  P. J. Landin,et al.  Correspondence between ALGOL 60 and Church's Lambda-notation , 1965, Commun. ACM.

[98]  WadlerPhilip,et al.  Report on the programming language Haskell , 1992 .

[99]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[100]  Barbara Liskov,et al.  Guardians and Actions: Linguistic Support for Robust, Distributed Programs , 1983, TOPL.

[101]  Larry L. Peterson,et al.  A dynamic network architecture , 1992, TOCS.

[102]  Mark Lillibridge,et al.  Polymorphic type assignment and CPS conversion , 1993, LISP Symb. Comput..

[103]  L. Peter Deutsch,et al.  Efficient implementation of the smalltalk-80 system , 1984, POPL.

[104]  Dana S. Scott,et al.  Outline of a Mathematical Theory of Computation , 1970 .

[105]  Simon L. Peyton Jones,et al.  Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine , 1992, Journal of Functional Programming.

[106]  Dana S. Scott,et al.  Some Domain Theory and Denotational Semantics in Coq , 2009, TPHOLs.