article

Open access

Metalevel building blocks for modular systems

Editor: Andrew W. Appel Author:

Suresh JagannathanAuthors Info & Claims

ACM Transactions on Programming Languages and Systems (TOPLAS), Volume 16, Issue 3

Pages 456 - 492

https://doi.org/10.1145/177492.177578

Published: 01 May 1994 Publication History

Abstract

The formal definition of any namespace device found in a programming language can be given in terms of transformations on a semantic environment. It is worthwhile, therefore, to consider the implications of incorporating environments as bona fide data objects in a programming system.

In this article, we propose a treatment of environments and the mechanism by which they are reified and manipulated, that addresses these concerns. The language described below (Rascal) permits environments to be reified into data structures, and data structures to be reflected into environments, but gives users great flexibility to constrain the extent and scope of these processes. We argue that the techniques and operators developed define a cohesive basis for building large-scale modular systems using reflective programming techniques.

References

[1]

ABELSON, H. AND SUSSMAN, G. 1985. Structure and Interpretation of Computer Programs. MIT Press, Cambridge, Mass.

[2]

ADAMS, N. AND REES, J. 1988. Object-oriented programming in Scheme. In Proc. of the ACM Syrup. on Lisp and Functional Programming, 277-288. ACM, New York.

[3]

APPEL, A. 1992. Compiling with Continuations. Cambridge University Press, Cambridge, U.K.

[4]

BURSTALL, R. AND LAMPSON, B. 1984. A kernel language for modules and abstract data types. In International Syrup. on Semantics of Data Types, Volume 173, Springer-Verlag, New York. Lecture Notes in Computer Science.

[5]

CARDELL, L., DOHAHUE, J., JORDAN, M., KALSOW, B., AND NELSON, G. 1989. The Modula-3 type system. In the 16th A CM Syrup. on Principles of Prog. Languages, ACM, New York, 202-213.

[6]

CHAMBERS, C. AND UNGAR, D. 1989. Customization: Optimizing compiler technology for Self, a dynamically-typed object-oriented programming language. In A CM SIGPLAN '89 Conference on Prog. Language Design and Implementation, ACM, New York, 146-160.

[7]

CLINGER, W. AND REES, J. 1991. Revised4 Report on the Algorithmic Language Scheme. ACM Lisp Pointers 4, 3 (July), 1-55.

[8]

CLINGER, W. AND RP.ES, J. 1993. Macros that work. In the 18th ACM Syrup. on Principles of Prog. Languages, ACM, New York. 155-163

[9]

COOK, W. AND PALSBERG, J. 1989. A denotational semantics of inheritance and its correctness. In OOPSLA'89 Conference Proceedings, ACM SIGPLAN Not. 24(10), (Oct. 1989), 433- 444.

[10]

CURTIS, P. AND RAVEN, J. 1990. A module system for Scheme. In Proc. of the ACM Syrup. on Lisp and Functional Programming, ACM, New York. 13-19.

[11]

DAHL, O., MYHRHAUG, B., AND NYGAARD, K. 1970. The Simula67 base common base language. Tech. rep., Norwegien Computing Center.

[12]

DES RIVII~RES, J. AND SMITH, B. 1984. The implementation of procedurally reflective languages. In Proc. of the A CM Syrup. on Lisp and Functional Prog., ACM, New York, 331-347.

[13]

DEUTSCH, P. AND SCHIFFMAN, A. 1983. Efficient implementation of the SmMltMk-80 system. In the 10th A CM Syrup. on Principles of Prog. Languages, ACM, New York~ 297-302.

[14]

FELLEISEN, M. 1988. The theory and practice of first-class prompts. In the 15th A CM Syrup. on Principles of Prog. Languages, ACM, New York, 180-190.

[15]

FRIEDMAN, D. AND WAND, M. 1984. Reification: Reflection without metaphysics. In Proc. of the A CM Syrup. on Lisp and Functional Programming, ACM, New York, 348-355.

[16]

GELERNTER, D., JAGANNATHAN, S., AND LONDON, W. 1987. Environments as first-class objects. In the i~th A CM Syrup. on Principle of Prog. Languages Conference, ACM, New York.

[17]

GOLDBERG, A. AND ROBSON, D. 1983. Smalltalk-80: The Language and its Implementation. Addison-Wesley Press. Reading, Mass.

[18]

HARPER, R. AND LILLIBRIDGE~ M. 1994. A type-theoretic approach to higher-order modules with sharing. In the 19th A CM Symp. on Principles of Prog. Languages, ACM, New York, 123-137.

[19]

HUDAK, P., PEYTON JONES, S. L., AND WADLER, P. 1992. Report on the functional programming language Haskell, version 1.2. ACM SIGPLAN Not. 27, 5 (May).

[20]

JAGANNATHAN, S. 1988. A programming language supporting first-class, parallel environments. Ph.D. thesis, MIT, Cambridge, Mass. (Also published as Tech. rep. LCS-TR 434.)

[21]

JOHNSSON, W. 1985. Lambda lifting: Transforming programs to recursive equations. In Proc. of the A CM Conference on Functional Programming Languages and Computer Architecture, Lecture Notes in Computer Science. Vol. 201. Springer-Verlag, New York.

[22]

KAMIN, S. 1988. Inheritance in Smalltalk-80: A denotational definition. In the 15th A CM Symp. on Principles of Prog. Languages, ACM, New York, 80-87.

[23]

KOHLBECKER, E. AND WAND, M. 1987. Macro-by-example: Deriving syntactic transformations from their specifications. In the 1~th A CM Syrup. on Principles of Prog. Languages, ACM, New York, 77-85.

[24]

KRANZ, D., KELSEY, R., REES, J., HUDAK, P., PHILBIN, J., AND ADAMS, N. 1986. Orbit: An optimizing compiler for Scheme. ACM SIGPLAN Not. 21, 7 (July), 219-233.

[25]

LAMPING~ J. 1988. A unified system of parameterization for programming languages. In Proc. of the A CM Symp. on Lisp and Functional Programming, ACM, New York, 1-11.

[26]

LEE, S.-D. AND FRIEDMAN, D. 1993. Quasi-static scoping: Sharing variable bindings across multiple lexical scopes. In the 20th A CM Syrup. on Pmneiples of Prow. Languages, ACM, New York, 479-492.

[27]

LIEBERMANN, H. 1986. Using prototypical objects to implement shared behavior in objectoriented systems. In OOPSLA'86 Conference Proceedings, SIGPLAN Not. 21(11), (Nov. 1986), 214-223.

[28]

LISKOV, B, SYNDER, A., ATKINSON, R., AND SCHAFFERT, C. 1977. Abstraction mechanisms in CLU. Commun. A CM 20, 8 (Aug.), 564- 576.

[29]

MACQUEEN, D. 1988. An implementation of standard ML modules. In Proc. of the A CM Syrup. on Lisp and Functzonal Programming, ACM, New York, 212-223.

[30]

MACQUEEN, D. AND TOFTE, M. 1994. A semantics for higher-order functors. In Proc. European Syrup on Programming (ESOP'94), Springer-Verlag, New York.

[31]

MILNER, R., TOFTE, M, AND HARPER, m. 1990. The Definition of Standard ML. MIT Press, Cambridge, Mass.

[32]

PEYTON-JONES, S. L. 1987. The Implementation of Funetwnal Programming Languages. Prentice Hall.

[33]

REDDY, U. 1988. Objects as closures: Abstract semantics of object-oriented languages. In Proc. of the A CM Syrup on L,sp and Functional Programming, ACM, New York, 289-297

[34]

REES 1993. Another Module System for Scheme Scheme48 documentation.

[35]

SMITH~ B. 1982. Reflection and Semantics in a Procedural Language. Ph. D. thesis, MIT, Cambridge, Mass. (Also published as Tech. rep. LCS TR-272.)

[36]

STEELE JR.~ G 1978. Rabbit: A Compiler for Scheme. Master's thesis, Massachusetts Institute of Technology, Cambridge, Mass.

[37]

STEELE JR., G 1990. Common Lisp: The Language. Digital Press, Bedford, Mass.

[38]

STEELE JR., G. AND SUSSMAN, G. 1978. The art of the interpreter, or the modularity complex. Tech. rep AI-TM 453, MIT Artificial Intelligence Laboratory, Cambridge, Mass.

[39]

STRACHEY, C. AND WADSWORTH, C. 1974. Continuations: A mathematical semantics for handling full jumps. Technical Report PRG-11, Programming Research Group, Oxford University, Oxford, U.K.

[40]

TOFTE, M. 1992. Principal signatures for higher-order program modules. In the 19th A CM Syrup on Pmnciples of Prow Languages, ACM, New York, 189-199.

[41]

UNGAR, D. AND SMITH, R. 1987. SELF" The power of simplicity In OOPSLA'87 Conference Proceedings, SIGPLAN Notices 22(12), (Dec. 1987), 227-241.

[42]

UNGAI~, D., SMITH, ~. B., CHAMBERS, C., AND H()LZLE~ U. 1992 Object, message, and performance: How they co-exist in Self. IEEE Comp~t. 25, 10 (Oct.)~ 53-65.

[43]

U.S. Dept. of Defense 1982. Reference Manual for the ADA Programmzn9 Language. U.S. Dept. of Defense, Washington, D.C.

[44]

WAND M. AND FRIEDMAN, D. P. 1988. The mystery of the tower revealed: A non-reflective description of the reflective tower. L~sp and Symbol. Comput 1, 1 (June), 11-38

[45]

WIRTH, N. 1985. Programming in Modula-2 Sprmger-Verlag, Berlin.

Cited By

Raji D(2019)That's not fair!XRDS: Crossroads, The ACM Magazine for Students10.1145/331312725:3(44-48)Online publication date: 10-Apr-2019
https://dl.acm.org/doi/10.1145/3313127
Wolf C(2019)Co-creating the future of work: Lessons from workplace automationXRDS: Crossroads, The ACM Magazine for Students10.1145/331312025:3(41-43)Online publication date: 10-Apr-2019
https://dl.acm.org/doi/10.1145/3313120
Robert L(2019)The future of pedestrian-automated vehicle interactionsXRDS: Crossroads, The ACM Magazine for Students10.1145/331311525:3(30-33)Online publication date: 10-Apr-2019
https://dl.acm.org/doi/10.1145/3313115
Show More Cited By

Index Terms

Metalevel building blocks for modular systems
1. Software and its engineering
  1. Software notations and tools
    1. General programming languages
      1. Language features
2. Theory of computation
  1. Semantics and reasoning
    1. Program semantics
      1. Denotational semantics

Recommendations

Modular language implementation in Rascal - experience report

All software evolves, and programming languages and programming language tools are no exception. And just like in ordinary software construction, modular implementations can help ease the process of changing a language implementation and its dependent ...
Modular development of interpreters from semantic building blocks

We present an integration of modular monadic semantics and generic programming concepts that facilitates the modular development of interpreters. Using modular monadic semantics, the computational structure is obtained as the composition of several ...
Modular logic programming

Modularity is a key issue in the design of modern programming languages. When designing modular features for declarative languages in general, and for logic programming languages in particular, the challenge lies in avoiding the superimposition of a ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM Transactions on Programming Languages and Systems

ACM Transactions on Programming Languages and Systems Volume 16, Issue 3

May 1994

773 pages

ISSN:0164-0925

EISSN:1558-4593

DOI:10.1145/177492

Editor:
Andrew W. Appel
Princeton Univ., Princeton, NJ

Issue’s Table of Contents

Copyright © 1994 ACM.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 01 May 1994

Published in TOPLAS Volume 16, Issue 3

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Article

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

45
Total Citations
View Citations
409
Total Downloads

Downloads (Last 12 months)54
Downloads (Last 6 weeks)19

Reflects downloads up to 18 Dec 2024

Other Metrics

View Author Metrics

Citations

Cited By

Raji D(2019)That's not fair!XRDS: Crossroads, The ACM Magazine for Students10.1145/331312725:3(44-48)Online publication date: 10-Apr-2019
https://dl.acm.org/doi/10.1145/3313127
Wolf C(2019)Co-creating the future of work: Lessons from workplace automationXRDS: Crossroads, The ACM Magazine for Students10.1145/331312025:3(41-43)Online publication date: 10-Apr-2019
https://dl.acm.org/doi/10.1145/3313120
Robert L(2019)The future of pedestrian-automated vehicle interactionsXRDS: Crossroads, The ACM Magazine for Students10.1145/331311525:3(30-33)Online publication date: 10-Apr-2019
https://dl.acm.org/doi/10.1145/3313115
Zhou HXue J(2016)A Compiler Approach for Exploiting Partial SIMD ParallelismACM Transactions on Architecture and Code Optimization10.1145/288610113:1(1-26)Online publication date: 28-Mar-2016
https://dl.acm.org/doi/10.1145/2886101
Akram SSartor JCraeynest KHeirman WEeckhout L(2016)Boosting the Priority of GarbageACM Transactions on Architecture and Code Optimization10.1145/287542413:1(1-25)Online publication date: 7-Mar-2016
https://dl.acm.org/doi/10.1145/2875424
Wang ZWang XHou FLuo YWang Z(2016)Dynamic Memory Balancing for VirtualizationACM Transactions on Architecture and Code Optimization10.1145/285150113:1(1-25)Online publication date: 28-Mar-2016
https://dl.acm.org/doi/10.1145/2851501
Raikov IDe Schutter E(2012)The Layer-Oriented Approach to Declarative Languages for Biological ModelingPLoS Computational Biology10.1371/journal.pcbi.10025218:5(e1002521)Online publication date: 17-May-2012
https://doi.org/10.1371/journal.pcbi.1002521
Anthes G(2012)Zoom in, zoom outCommunications of the ACM10.1145/2380656.238066355:12(18-19)Online publication date: 1-Dec-2012
https://dl.acm.org/doi/10.1145/2380656.2380663
Gorlick MStrasser KTaylor R(2012)COASTProceedings of the 2012 Joint Working IEEE/IFIP Conference on Software Architecture and European Conference on Software Architecture10.1109/WICSA-ECSA.212.15(71-80)Online publication date: 20-Aug-2012
https://dl.acm.org/doi/10.1109/WICSA-ECSA.212.15
Gorlick MStrasser KBaquero ATaylor RLopes CFisher K(2011)CRESTProceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion10.1145/2048147.2048202(193-194)Online publication date: 22-Oct-2011
https://dl.acm.org/doi/10.1145/2048147.2048202
Show More Cited By

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Media

Figures

Other

Tables

View Issue’s Table of Contents