Academia.eduAcademia.edu

Outline

Title
Abstract
Data
Action Analysis and Compiler Generation
References
All Topics
Computer Science
Theoretical Computer Science

Theory and Practice of Action Semantics

Profile image of Peter MossesPeter Mosses

1996, Mathematical Foundations of Computer Science 1996

Abstract
sparkles

AI

This paper presents the theory and practice of action semantics, a framework designed to provide an extensible and modular approach to describing programming languages. The authors argue that action-semantic descriptions (ASDs) can encapsulate the complexities of real programming languages more effectively than traditional denotational or operational semantics, which often require extensive revisions with any changes to the language. The paper discusses the foundations of action semantics, its pragmatic advantages, and its applications in language implementation, contributing to a better understanding of how to develop and utilize programming language semantics effectively.

Related papers

A Blikle An experiment with denotational semantics
Andrzej Blikle

Preprint, 2019

The paper is devoted to showing how to systematically design a programming language in “reverse order”, i.e. from denotations to syntax. This construction is developed in an algebraic framework consisting of three many-sorted algebras: of denotations, of an abstract syntax and of a concrete syntax. These algebras are constructed in such a way that there is a unique homomorphism from concrete syntax to denotations, which constitutes the denotational semantics of the language. Besides its algebraic framework, the model is set-theoretic, i.e. the denotational domains are just sets, rather than Scott’s reflexive domains. The method is illustrated by a layer-by-layer development of a virtual language Lingua: an applicative layer, an imperative layer (with recursive procedures) and an SQL layer where Lingua is regarded as an API (Application Programming Interface) for an SQL engine. The latter is given a denotational semantics as well. The langue is equipped with a strong typing mechanism which covers basic types (numbers, Booleans, etc.), lists, arrays, record and their arbitrary combinations plus SQL-like types: rows, tables and databases. The model of types includes SQL integrity constraints. The described model is further developed in a preprint book available on my profile: “A Denotational Engineering of Programming Languages”.

View PDFchevron_right
Parametric Denotational Semantics for Extensible Language Definition and Program Analysis
In-Ho Yi

2018

We present a novel approach to construction of a formal semantics for a programming language. Our approach, using a parametric denotational semantics, allows the semantics to be easily extended to support new language features, and abstracted to define program analyses. We apply this in analysing a duck-typed, reflective, curried dynamic language. The benefits of this approach include its terseness and modularity, and the ease with which one can gradually build language features and analyses on top of a previous incarnation of a semantics.

View PDFchevron_right
An Experiment with a User Manual of a Programming Language Based on a Denotational Semantics
Andrzej Blikle

ArXiv, 2019

Denotational models should provide an opportunity for the revision of current practices seen in the manuals of programming languages. New styles should on one hand base on denotational models but on the other - do not assume that today readers are acquainted in this field. A manual should, therefore, provide some basic knowledge and notation needed to understand the definition of a programming language written in a new style. At the same time - I strongly believe that - it should be written for professional programmers rather than for amateurs. The role of a manual is not to teach the skills of programming. Such textbooks are, of course, necessary, but they should tell the readers what the programming is about rather than the technicalities of a concrete language. The paper contains an example of a manual for a virtual programming language Lingua developed in our project.

View PDFchevron_right
A denotational semantics of a concatenative/compositional programming language
Jurij Mihelič

Acta Polytechnica Hungarica, 2021

A distinctive feature of concatenative languages is that a concatenation of their programs corresponds to a composition of meaning functions of these programs. At first programming in such languages may resemble assembly language programming. In spite of this, they also exhibit many similarities to high-level functional programming languages. We start our presentation with the definition of the language syntax. The main part of the paper consists of the definition of a meaning of programs in the language. To do this we employ a well-known method based on denotational semantics. We also informally introduce the language and its meaning as well as present its background and provide motivation for the work. Our exposition is accompanied by many examples and in the last part of the paper, we also discuss various language extensions and identify several proposals for further research.

View PDFchevron_right
Disentangling denotational semantics specifications
João Saraiva

Journal of Universal Computer Science, 2008

Denotational semantics is a powerful technique to formally define programming languages. However, language constructs are not always orthogonal, so many semantic equations in a definition may have to be aware of unrelated constructs semantics. Current approaches for modularity in this formalism do not address this problem, providing, for this reason, tangled semantic definitions. This paper proposes an incremental approach for denotational semantic specifications, in which each step can either add new features or adapt existing equations, by means of a formal language based on function transformation and aspect weaving.

View PDFchevron_right
Denotational semantics as a specification of code generators
Martin Raskovsky

ACM SIGPLAN Notices, 1982

We describe the automatic generation - from the formal denotational semantic specification - of an efficient compiler's code generation phase, producing efficient code for real machines. The method has been succesfully implemented and tested with languages as complex as GEDANKEN!

View PDFchevron_right
Denotational Semantics
Joe Stoy

Undergraduate Topics in Computer Science, 2007

View PDFchevron_right
A Correspondence Between Denotational Semantics and Code Generation
Martin Raskovsky

Doctorate Thesis, 1982

We describe a method for the systematic derivation, or automatic generation - from the formal denotational semantic specification - of an efficient compiler's code generation phase,producing efficient code for real machines. The method has been successfully implemented and tested with languages as complex as GEDANKEN! The method has been used to implement a compiler-compiler which inputs the semantic specification of a programming language written in a standard denotational form, analyses it in the light of its semantic contents, decides upon certain predecided general implementation issues and outputs a program written in the systems programming language BCPL. This program constitutes the type .checking and code generation phases of a compiler for the given language. Its structure and operation is in effect essentially the same that we would have produced by hand. The only hand coding is the interface for the particular target machine, required for both the primitive functionsof the original specification and those introduced by the compiler-compiler. For the latter, our system provides a library of routines to generate code for the DEC-10 system. So that in all the examples we tried, we only had to hand codethe former. The parser is separately generated with an LLl system which also generates BCPL procedures.

View PDFchevron_right
Formal Semantics of Programming Languages - An Overview
Peter Mosses

Electronic Notes in Theoretical Computer Science, 2006

These notes give an overview of the main frameworks that have been developed for specifying the formal semantics of programming languages. Some of the pragmatic aspects of semantic descriptions are discussed, including modularity, and potential applicability to visual and modelling languages. References to the literature provide starting points for further study.

View PDFchevron_right
Denotational semantics for a program logic of objects
Bernhard Reus

Mathematical Structures in Computer Science, 2006

The object-calculus is an imperative and object-based programming language where every object comes equipped with its own method suite. Consequently, methods need to reside in the store ("higher-order store") which complicates the semantics. Abadi and Leino defined a program logic for this language enriching object types by method specifications. We present a new soundness proof for their logic using Denotational Semantics. It turns out that denotations of store specifications are predicates defined by mixed-variant recursion. A benefit of our approach is that derivability and validity can be kept distinct. Moreover, it is revealed which of the limitations of Abadi and Leino's logic are incidental design decisions and which follow inherently from the use of higher-order store. We discuss the implications for the development of other, more expressive, program logics.

View PDFchevron_right

References (76)

  1. S. Abramsky. Semantics of interaction. In Trees in Algebra and Programming { CAAP'96, Proc. 21st Int. Coll., Link oping, volume 1059 of Lecture Notes in Computer Science, page 1. Springer-Verlag, 1996.
  2. G. Agha, I. A. Mason, S. F. Smith, and C. L. Talcott. A foundation for actor computation. To appear in Journal of Functional Programming, 1994.
  3. A. Bondorf and J. Palsberg. Compiling actions by partial evaluation. In FPCA'93, Proc. Sixth ACM Conf. on Functional Programming Languages and Computer Ar- chitecture, Copenhagen, pages 308{317, 1993.
  4. D. Brown and D. A. Watt. Sort inference in the Actress compiler generator. In 44], pages 81{98, 1994.
  5. D. F. Brown, H. Moura, and D. A. Watt. Actress: an action semantics directed compiler generator. In CC'92, Proc. 4th Int. Conf. on Compiler Construction, Paderborn, volume 641 of Lecture Notes in Computer Science, pages 95{109. Springer-Verlag, 1992.
  6. K.-G. Doh. Action Semantics-Directed Prototyping. PhD thesis, Kansas State University, 1992.
  7. K.-G. Doh. Action transformation by partial evaluation. In PEPM'95, Proc. ACM/SIGPLAN Symposium on Partial Evaluation and Semantics-based Program Transformation, La Jolla, California, pages 230{240, 1995.
  8. K.-G. Doh and D. A. Schmidt. Extraction of strong typing laws from action seman- tics de nitions. In ESOP'92, Proc. European Symposium on Programming, Rennes, volume 582 of Lecture Notes in Computer Science, pages 151{166. Springer-Verlag, 1992.
  9. K.-G. Doh and D. A. Schmidt. Action semantics-directed prototyping. Comput. Lang., 19(4):213{233, 1993.
  10. K.-G. Doh and D. A. Schmidt. The facets of action semantics: Some principles and applications (extended abstract). In 44], pages 1{15, 1994.
  11. S. Even and D. A. Schmidt. Category sorted algebra-based action semantics. The- oretical Comput. Sci., 77:73{96, 1990.
  12. S. Even and D. A. Schmidt. Type inference for action semantics. In ESOP'90, Proc. European Symposium on Programming, Copenhagen, volume 432 of Lecture Notes in Computer Science, pages 118{133. Springer-Verlag, 1990.
  13. J. A. Goguen, J. W. Thatcher, E. G. Wagner, and J. B. Wright. Initial algebra semantics and continuous algebras. J. ACM, 24:68{95, 1977.
  14. Y. Gurevich. Evolving algebras 1993: Lipari guide. In E. B orger, editor, Speci ca- tion and Validation Methods. Oxford University Press, 1995.
  15. B. S. Hansen and J. Bundgaard. The role of the ANDF formal speci cation. Tech- nical Report 202104/RPT/5, issue 2, DDC International A/S, Lundtoftevej 1C, DK{2800 Lyngby, Denmark, 1992.
  16. B. S. Hansen and J. U. Toft. The formal speci cation of ANDF, an application of action semantics. In 44], pages 34{42, 1994.
  17. C. Hintermeier, H. Kirchner, and P. D. Mosses. Combining algebraic and set- theoretic speci cation. In Recent Trends in Data Type Speci cation, Proc. 11th Workshop on Speci cation of Abstract Data Types, Oslo, 1995, Selected Papers, vol- ume 1130 of Lecture Notes in Computer Science, pages 255{274. Springer-Verlag, 1996. To appear.
  18. P. Klint. A meta-environment for generating programming environments. ACM Transactions on Software Engineering Methodology, 2(2):176{201, 1993.
  19. P. Krishnan. Speci cation of systems with interrupts. J. Systems Software, 21:291{304, 1993.
  20. P. Krishnan, B. McKenzie, and S. Hunt. Guile: Graphical user interface for linguis- tic experiments. In Proceedings of the 17th Annual Computer Science Conference, Australian Communications, pages 309{320, 1994.
  21. P. Krishnan and P. D. Mosses. Specifying asynchronous transfer of control. In RTFT'92, Proc. Symp. on Formal Techniques in Real-Time and Fault-Tolerant Systems, Delft, volume 571 of Lecture Notes in Computer Science. Springer-Verlag, 1992.
  22. S. B. Lassen. Design and semantics of action notation. In 44], pages 34{42, 1994.
  23. S. B. Lassen. Action semantics reasoning about functional programs. BRICS, Dept. of Computer Science, Univ. of Aarhus, Dec. 1995.
  24. S. B. Lassen. Basic action theory. Technical Report RS-95-25, BRICS, Dept. of Computer Science, Univ. of Aarhus, 1995.
  25. S. Liang and P. Hudak. Modular denotational semantics for compiler construc- tion. In Programming Languages and Systems { ESOP'96, Proc. 6th European Symposium on Programming, Link oping, volume 1058 of Lecture Notes in Com- puter Science, pages 219{234. Springer-Verlag, 1996.
  26. R. Milner, M. Tofte, and R. Harper. The De nition of Standard ML. The MIT Press, 1990.
  27. E. Moggi. Computational lambda-calculus and monads. In LICS'89, Proc. 4th Ann. Symp. on Logic in Computer Science, pages 14{23. IEEE, 1989.
  28. P. D. Mosses. The mathematical semantics of Algol60. Tech. Mono. PRG{12, Programming Research Group, Univ. of Oxford, 1974.
  29. P. D. Mosses. Mathematical Semantics and Compiler Generation. D.Phil. disser- tation, University of Oxford, 1975.
  30. P. D. Mosses. Compiler generation using denotational semantics. In MFCS'76, Proc. Symp. on Math. Foundations of Computer Science, Gda nsk, volume 45 of Lecture Notes in Computer Science. Springer-Verlag, 1976.
  31. P. D. Mosses. Making denotational semantics less concrete. In Proc. Int. Workshop on Semantics of Programming Languages, Bad Honnef, pages 102{109. Abteilung Informatik, Universit at Dortmund, 1977. Bericht nr. 41.
  32. P. D. Mosses. SIS, Semantics Implementation System: Reference manual and user guide. Tech. Mono. MD{30, Dept. of Computer Science, Univ. of Aarhus, 1979. Out of print.
  33. P. D. Mosses. A constructive approach to compiler correctness. In ICALP'80, Proc. Int. Coll. on Automata, Languages, and Programming, Noordwijkerhout, vol- ume 85 of Lecture Notes in Computer Science, pages 449{469. Springer-Verlag, 1980.
  34. P. D. Mosses. A semantic algebra for binding constructs. In Proc. Int. Coll. on Formalization of Programming Concepts, Peñiscola, volume 107 of Lecture Notes in Computer Science, pages 408{418. Springer-Verlag, 1981.
  35. P. D. Mosses. Abstract semantic algebras! In Formal Description of Programming Concepts II, Proc. IFIP TC2 Working Conference, Garmisch-Partenkirchen, 1982, pages 45{71. North-Holland, 1983.
  36. P. D. Mosses. A basic abstract semantic algebra. In Proc. Int. Symp. on Semantics of Data Types, Sophia-Antipolis, volume 173 of Lecture Notes in Computer Science, pages 87{107. Springer-Verlag, 1984.
  37. P. D. Mosses. Uni ed algebras and action semantics. In STACS'89, Proc. Symp. on Theoretical Aspects of Computer Science, Paderborn, volume 349 of Lecture Notes in Computer Science. Springer-Verlag, 1989.
  38. P. D. Mosses. Uni ed algebras and institutions. In LICS'89, Proc. 4th Ann. Symp. on Logic in Computer Science, pages 304{312. IEEE, 1989.
  39. P. D. Mosses. Uni ed algebras and modules. In POPL'89, Proc. 16th Ann. ACM Symp. on Principles of Programming Languages, pages 329{343. ACM, 1989.
  40. P. D. Mosses. Denotational semantics. In Handbook of Theoretical Computer Sci- ence, volume B, chapter 11. Elsevier Science Publishers, Amsterdam; and MIT Press, 1990.
  41. P. D. Mosses. A practical introduction to denotational semantics. In Formal Description of Programming Concepts, IFIP State-of-the-Art Report, pages 1{49. Springer-Verlag, 1991.
  42. P. D. Mosses. Action Semantics. Number 26 in Cambridge Tracts in Theoretical Computer Science. Cambridge University Press, 1992.
  43. P. D. Mosses. On the action semantics of concurrent programming languages. In Semantics: Foundations and Applications, Proc. REX Workshop, Beekbergen, 1992, volume 666 of Lecture Notes in Computer Science, pages 398{424. Springer- Verlag, 1993.
  44. P. D. Mosses, editor. Proc. 1st Intl. Workshop on Action Semantics, Edinburgh, 1994, number NS-94-1 in BRICS Notes Series. BRICS, Dept. of Computer Science, Univ. of Aarhus, 1994.
  45. P. D. Mosses. Uni ed algebras and abstract syntax. In Recent Trends in Data Type Speci cation, Proc. 9th Workshop on Speci cation of Abstract Data Types, Caldes de Malavella, 1992, Selected Papers, volume 785 of Lecture Notes in Computer Science, pages 280{294. Springer-Verlag, 1994.
  46. P. D. Mosses, editor. CoFI: Initiative for a Common Framework for Algebraic Speci cation, URL: http://www.brics.dk/Projects/CoFI, 1996.
  47. P. D. Mosses. A tutorial on action semantics. 50pp. Tutorial notes for FME'94 (Formal Methods Europe, Barcelona, 1994) and FME'96 (Formal Methods Europe, Oxford, 1996), Mar. 1996.
  48. P. D. Mosses and M. A. Musicante. An action semantics for ML concurrency primitives. In FME'94, Proc. Formal Methods Europe: Symposium on Industrial Bene t of Formal Methods, Barcelona, volume 873 of Lecture Notes in Computer Science, pages 461{479. Springer-Verlag, 1994.
  49. P. D. Mosses and D. A. Watt. The use of action semantics. In Formal Description of Programming Concepts III, Proc. IFIP TC2 Working Conference, Gl. Avern s, 1986, pages 135{166. North-Holland, 1987.
  50. P. D. Mosses and D. A. Watt. Pascal action semantics, version 0.6. URL: ftp://ftp.brics.dk/pub/BRICS/Projects/AS/Papers/MossesWatt93DRAFT.ps.Z, Mar. 1993.
  51. H. Moura. Action Notation Transformations. PhD thesis, Dept. of Computing Science, Univ. of Glasgow, 1993.
  52. H. Moura and D. A. Watt. Action transformations in the Actress compiler genera- tor. In CC'94, Proc. 5th Intl. Conf. on Compiler Construction, Edinburgh, volume 786 of Lecture Notes in Computer Science, pages 16{30. Springer-Verlag, 1994.
  53. M. A. Musicante. The Sun RPC language semantics. In Proceedings of PANEL'92, XVIII Latin-American Conference on Informatics. Universidad de Las Palmas de Gran Canaria, 1992.
  54. M. A. Musicante and P. D. Mosses. Communicative action notation with shared storage. Tech. Mono. PB{452, Dept. of Computer Science, Univ. of Aarhus, 1993.
  55. J. P. Nielsen and J. U. Toft. Formal speci cation of ANDF, existing subset. Tech- nical Report 202104/RPT/19, issue 2, DDC International A/S, Lundtoftevej 1C, DK{2800 Lyngby, Denmark, 1994.
  56. P. rb k. OASIS: An optimizing action-based compiler generator. In CC'94, Proc. 5th Intl. Conf. on Compiler Construction, Edinburgh, volume 786 of Lecture Notes in Computer Science, pages 1{15. Springer-Verlag, 1994.
  57. J. Palsberg. An automatically generated and provably correct compiler for a sub- set of Ada. In ICCL'92, Proc. Fourth IEEE Int. Conf. on Computer Languages, Oakland, pages 117{126. IEEE, 1992.
  58. J. Palsberg. Provably Correct Compiler Generation. PhD thesis, Dept. of Com- puter Science, Univ. of Aarhus, 1992. xii+224 pages.
  59. J. Palsberg. A provably correct compiler generator. In ESOP'92, Proc. European Symposium on Programming, Rennes, volume 582 of Lecture Notes in Computer Science, pages 418{434. Springer-Verlag, 1992.
  60. G. D. Plotkin. A structural approach to operational semantics. Lecture Notes DAIMI FN{19, Dept. of Computer Science, Univ. of Aarhus, 1981.
  61. D. A. Schmidt. Denotational Semantics: A Methodology for Language Develop- ment. Allyn & Bacon, 1986.
  62. D. A. Schmidt. The Structure of Typed Programming Languages. The MIT Press, 1994.
  63. K. Slonneger and B. L. Kurtz. Formal Syntax and Semantics of Programming Languages: A Laboratory Based Approach. Addison-Wesley, 1995.
  64. J. E. Stoy. Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory. The MIT Press, 1977.
  65. The RAISE Language Group. The RAISE Speci cation Language. BCS Practi- tioner Series. Prentice-Hall, 1992.
  66. J. U. Toft. Feasibility of using RSL as the speci cation language for the ANDF for- mal speci cation. Technical Report 202104/RPT/12, issue 2, DDC International A/S, Lundtoftevej 1C, DK{2800 Lyngby, Denmark, 1993.
  67. A. van Deursen. Executable Language De nitions: Case Studies and Origin Track- ing Techniques. PhD thesis, Univ. of Amsterdam, 1994.
  68. A. van Deursen and P. D. Mosses. ASD: The action semantic description tools. In AMAST'96, Proc. 5th Intl. Conf. on Algebraic Methodology and Software Technol- ogy, Munich, volume 1101 of Lecture Notes in Computer Science, pages 579{582. Springer-Verlag, 1996.
  69. D. A. Watt. Executable semantic descriptions. Software { Practice and Experi- ence, 16:13{43, 1986.
  70. D. A. Watt. An action semantics of Standard ML. In Proc. Third Workshop on Math. Foundations of Programming Language Semantics, New Orleans, volume 298 of Lecture Notes in Computer Science, pages 572{598. Springer-Verlag, 1988.
  71. D. A. Watt. Programming Language Syntax and Semantics. Prentice-Hall, 1991. Addendum: This paper also appears in MFCS'96, Proc. 21st International Sym- posium on Mathematical Foundations of Computer Science, Cracow, Poland, September 1996 , volume 1113 of Lecture Notes in Computer Science, pages 37{ 61. Springer-Verlag, 1996. Recent Publications in the BRICS Report Series RS-96-53 Peter D. Mosses. Theory and Practice of Action Semantics. December 1996. 26 pp. Appears in Penczek and Szalas, editors, Mathematical Foundations of Computer Science: 21st International Symposium, MFCS '96 Proceedings, LNCS 1113, 1996, pages 37-61.
  72. RS-96-52 Claus Hintermeier, Hélène Kirchner, and Peter D. Mosses. Combining Algebraic and Set-Theoretic Specifica- tions (Extended Version). December 1996. 26 pp. Appears in Haveraaen, Owe and Dahl, editors, Recent Trends in Data Type Specification: 11th Workshop on Specification of Abstract Data Types, joint with 8th COMPASS Work- shop, Selected Papers, LNCS 1130, 1996, pages 255-274.
  73. RS-96-51 Claus Hintermeier, Hélène Kirchner, and Peter D. Mosses. R n -and G n -Logics. December 1996. 19 pp. Appears in Gilles, Heering, Meinke and Möller, edi- tors, Higher-Order Algebra, Logic, and Term-Rewriting: 2nd International Workshop, HOA '95 Proceedings, LNCS 1074, 1996, pages 90-108.
  74. RS-96-50 Aleksandar Pekeč. Hypergraph Optimization Problems: Why is the Objective Function Linear? December 1996. 10 pp. RS-96-49
  75. Dan S. Andersen, Lars H. Pedersen, Hans H üttel, and Josva Kleist. Objects, Types and Modal Logics. December 1996. 20 pp. To be presented at the 4th International Workshop on the Foundations of Object-Oriented, FOOL4, 1997. RS-96-48 Aleksandar Pekeč. Scalings in Linear Programming: Nec- essary and Sufficient Conditions for Invariance. December 1996. 28 pp.
  76. RS-96-47 Aleksandar Pekeč. Meaningful and Meaningless Solu- tions for Cooperative N-person Games. December 1996. 28 pp. RS-96-46 Alexander E. Andreev and Sergei Soloviev. A Decision Al- gorithm for Linear Isomorphism of Types with Complexity Cn(log 2 (n)). November 1996. 16 pp.

Related papers

A Modified Denotational Approach for a Semantics of a Programming Languages
Ljubomir Jerinic

A formal system of describing semantics of programming languages, based on the denotational approach is presented. That approach is modified with some operational view for formal description, combined with the object oriented methods of programming.

View PDFchevron_right
From standard to implementation denotational semantics
Martin Raskovsky

Lecture Notes in Computer Science, 1980

e are developing a compiler compiler. It takes as input the formal definition of a programming lanquage in Denotational Semantics and produces as output a fairly efficient compiler written in a systems programming language which in turn will produce code for a real machine. This wor:c ~ainly deals with the code qeneration parts.

View PDFchevron_right
A DENOTATIONAL ENGINEERING OF PROGRAMMING LANGUAGES
Andrzej Blikle

Preprint, 2018

The book is devoted to two research areas: (1) Designing programming languages along with their denotational models. A denotational model of a language consists of two many-sorted algebras ― an algebra of syntax and an algebra of denotations ― and a (unique) homomorphism from syntax to denotations called the semantics of the language. (2) Designing sound program-constructors for languages with denotational models. In our approach programs syntactically contain their total-correctness specifications. A program is said to be correct if it is correct wrt its specification. A program-constructor is sound if given correct component-programs yields a correct resulting program. Both methods are illustrated on an example-language Lingua.

View PDFchevron_right
Q Lecture Notes on Denotational Semantics
G. Winskel

2012

These notes are designed to accompany 8-10 lectures on denotational semantics for Part II of the Cambridge University Computer Science Tripos. Some of the material of this course (roughly, the first half) used to form part of courses on semantics of programming languages for Parts IB/II. The Part IB course on Semantics of Programming Languages is a prerequisite. Tripos questions Of the many past Tripos questions on programming language semantics, here are those which are relevant to the current course and predate those available from the Lab webpage-all denotational semantics questions available from the Lab webpage are relevant.

View PDFchevron_right
An Experiment with Denotational Semantics
Andrzej Blikle

SN Computer Science

The paper is devoted to showing how to systematically design a programming language in "reverse order", i.e., from denotations to syntax. This construction is developed in an algebraic framework consisting of three many-sorted algebras: of denotations, of an abstract syntax and of a concrete syntax. These algebras are constructed in such a way that there is a unique homomorphism from concrete syntax to denotations, which constitutes the denotational semantics of the language. Besides its algebraic framework, the model is set-theoretic, i.e., the denotational domains are just sets, rather than Scott's reflexive domains. The method is illustrated by a layer-by-layer development of a virtual language Lingua: an applicative layer, an imperative layer (with recursive procedures) and an SQL layer where Lingua is regarded as an API (Application Programming Interface) for an SQL engine. The latter is given a denotational semantics as well. Mathematically, the model is based on so-called naive denotational semantics (Blikle and Tarlecki in Information processing 83.

View PDFchevron_right

Related topics

  • Mathematical Foundations of Comp...
  • Semantic Description
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved