Foundations of a Module Concept for Distributed Object Systems

This thesis provides a logical and mathematical foundation for object-oriented specification languages with a further modularisation unit between the system and object classes. The unit is denoted object-oriented module, or module for short, and initially described in an informal way. Modules offer a better approach to reusability and provide better structuring of large, complex and distributed systems. In our approach, systems and single modules are represented by theory presentations in a module logic. These presentations, also called module specifications, are pairs consisting of a module signature and a set of module axioms. The axioms are formulae in a newly developed module logic MDTL (Module Distributed Temporal Logic). This is a true-concurrent branching-time discrete distributed first-order temporal logic that is interpreted over labelled event structures. Winskel et al. introduced certain event structure morphisms to organise event structures into a category ev with limits. Here we present a second notion of morphism between event structures, so-called communication event structure morphisms, that result in a different category cev with just the right colimits for our purposes. Crucially, in some cases a morphism in ev has a corresponding reverse morphism in cev. A categorical construction is presented which uses limits in ev and colimits in cev. The construction may be used to model several module operations in a uniform way. In particular, we consider concurrent composition (synchronous, asynchronous, or mixed), parameter actualisation, refinement, restriction (hiding) and renaming.

[1]  Laura Giordano,et al.  A Modal Extension of Logic Programming: Modularity, Beliefs and Hypothetical Reasoning , 1998, J. Log. Comput..

[2]  Amílcar Sernadas,et al.  Object-Oriented Design of Information Systems: Theoretical Foundations , 1993, CISM - Advances in Database Systems.

[3]  Peter Buneman,et al.  Theoretical Aspects of Object-Oriented Programming , 1994 .

[4]  Frits W. Vaandrager A simple definition for parallel composition of prime event structures , 1989 .

[5]  Matthew Hennessy,et al.  Algebraic theory of processes , 1988, MIT Press series in the foundations of computing.

[6]  José Luiz Fiadeiro,et al.  The Basic Building Blocks of Information Systems , 1989, ISCO.

[7]  L. P. Deutsch,et al.  Design reuse and frameworks in the smalltalk-80 system , 1989 .

[8]  Joseph A. Goguen,et al.  Identifying Inheritance Structure in Object-Oriented Systems Analysis: A Pattern Matching Approach. , 1994 .

[9]  Rita Loogen,et al.  Modelling nondeterministic concurrent processes with event structures , 1991, Fundam. Informaticae.

[10]  G. K. Smelser The structure of the eye , 1961 .

[11]  Martín Abadi,et al.  A Theory of Objects , 1996, Monographs in Computer Science.

[12]  Gul A. Agha,et al.  The Structure and Semantics of Actor Languages , 1990, REX Workshop.

[13]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[14]  Glynn Winskel,et al.  Event Structure Semantics for CCS and Related Languages , 1982, ICALP.

[15]  Kevin Lano,et al.  Logical Specification of Reactive and Real-Time Systems , 1998, J. Log. Comput..

[16]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[17]  Hans-Dieter Ehrich,et al.  Specifying communication in distributed information systems , 2000, Acta Informatica.

[18]  K. Mani Chandy,et al.  Parallel program design - a foundation , 1988 .

[19]  Michael Papathomas,et al.  A Unifying Framework for Process Calculus Semantics of Concurrent Object-Oriented Languages , 1991, Object-Based Concurrent Computing.

[20]  Laura Giordano,et al.  Structuring Logic Programs: A Modal Approach , 1994, J. Log. Program..

[21]  Antonio Brogi,et al.  Modular logic programming , 1994, TOPL.

[22]  Clemens A. Szyperski,et al.  Import is Not Inheritance - Why We Need Both: Modules and Classes , 1992, ECOOP.

[23]  Grit Denker Semantic Refinement of Concurrent Object Systems Based on Serializability , 1995, Object Orientation with Parallelism and Persistence.

[24]  G. Denker,et al.  Specifying distributed information systems: fundamentals of an object-oriented approach using distributed temporal logic , 1997 .

[25]  David Peleg,et al.  Communication in Concurrent Dynamic Logic , 1987, J. Comput. Syst. Sci..

[26]  Ivar Jacobson,et al.  Object-oriented software engineering - a use case driven approach , 1993, TOOLS.

[27]  Carolyn L. Talcott,et al.  Actor Languages Their Syntax, Semantics, Translation, and Equivalence , 1999, Theor. Comput. Sci..

[28]  Alan W. Brown,et al.  The Current State , 2016 .

[29]  Michael Kifer,et al.  Concurrency and Communication in Transaction Logic , 1996, JICSLP.

[30]  John Hughes,et al.  Report on the Programming Language Haskell 98 , 1999 .

[31]  José Meseguer,et al.  Unifying Functional, Object-Oriented and Relational Programming with Logical Semantics , 1987, Research Directions in Object-Oriented Programming.

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

[33]  Juliana Küster Filipe Bowles,et al.  On Dynamic Aspects of OOD Frameworks in Component-Based Software Development in Computational Logic , 1999, LOPSTR.

[34]  Dale Miller,et al.  A Logical Analysis of Modules in Logic Programming , 1989, J. Log. Program..

[35]  C. A. R. Hoare,et al.  Communicating Sequential Processes (Reprint) , 1983, Commun. ACM.

[36]  Glynn Winskel,et al.  Event Structures , 1986, Advances in Petri Nets.

[37]  Michael Barr,et al.  Category theory for computing science , 1995, Prentice Hall International Series in Computer Science.

[38]  Juliana Küster Filipe Bowles,et al.  The TROLL Approach to Conceptual Modeling: Syntax, Semantics and Tools , 1998, ER.

[39]  Matthias Felleisen,et al.  Units: cool modules for HOT languages , 1998, PLDI.

[40]  Cristina Sernadas,et al.  From Data Types to Object Types , 1990, J. Inf. Process. Cybern..

[41]  Gert Smolka A Foundation for Higher-order Concurrent Constraint Programming , 1994, CCL.

[42]  Mikio Aoyama,et al.  New Age of Software Development: How Component-Based Software Engineering Changes the Way of Software Development ? , 1998 .

[43]  Robert M. Keller,et al.  Formal verification of parallel programs , 1976, CACM.

[44]  Leslie Lamport,et al.  The temporal logic of actions , 1994, TOPL.

[45]  David Lorge Parnas,et al.  The Modular Structure of Complex Systems , 1984, IEEE Transactions on Software Engineering.

[46]  Robert Bruce Findler,et al.  Modular object-oriented programming with units and mixins , 1998, ICFP '98.

[47]  Cristina Sernadas,et al.  Abstract Object Types for Databases , 1988, OODBS.

[48]  William E. Lorensen,et al.  Object-Oriented Modeling and Design , 1991, TOOLS.

[49]  Evelina Lamma,et al.  Modularity in Logic Programming , 1994, J. Log. Program..

[50]  Robert L. Glass In the beginning - personal recollections of software pioneers , 1997 .

[51]  Oscar Nierstrasz,et al.  Design Guidelines for Tailorable Frameworks , 1997 .

[52]  Glynn Winskel,et al.  An introduction to event structures , 1988, REX Workshop.

[53]  Michele Bugliesi,et al.  A Linear Logic Calculus Objects , 1996, JICSLP.

[54]  P. S. Thiagarajan,et al.  An Event Structure Semantics for General Petri Nets , 1996, Theor. Comput. Sci..

[55]  Amir Pnueli,et al.  The temporal logic of programs , 1977, 18th Annual Symposium on Foundations of Computer Science (sfcs 1977).

[56]  Oscar Nierstrasz,et al.  Towards and Object Calculus , 1991, Object-Based Concurrent Computing.

[57]  Antoni W. Mazurkiewicz,et al.  Basic notions of trace theory , 1988, REX Workshop.

[58]  Joseph A. Goguen,et al.  Institutions: abstract model theory for specification and programming , 1992, JACM.

[59]  Wolfgang Pree,et al.  Design Patterns for Object-Oriented Software Development , 1994, Proceedings of the (19th) International Conference on Software Engineering.

[60]  David Harel,et al.  First-Order Dynamic Logic , 1979, Lecture Notes in Computer Science.

[61]  Mogens Nielsen,et al.  Models for Concurrency , 1992 .

[62]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[63]  Ilaria Castellani,et al.  Permutation of transitions: An event structure semantics for CCS and SCCS , 1988, REX Workshop.

[64]  Christoph Kreitz,et al.  Formal Reasoning about Modules, Reuse and their Correctness , 1996, FAPR.

[65]  John C. Mitchell,et al.  On the Relationship Between Classes, Objects, and Data Abstraction , 1998, Theory Pract. Object Syst..

[66]  Amílcar Sernadas,et al.  A Linear Temporal Logic Approach to Objects with Transactions , 1997, AMAST.

[67]  Giovanni A. Cignoni,et al.  A Proposal to Merge Multiple Tuple Spaces, Object Orientation, and Logic Programming , 1996, Comput. Lang..

[68]  Ilaria Castellani,et al.  Parallel Product of Event Structures , 1997, Theor. Comput. Sci..

[69]  David A. Wolfram,et al.  A Sheaf Semantics for FOOPS Expressions , 1991, Object-Based Concurrent Computing.

[70]  Carolyn L. Talcott,et al.  Towards a Theory of Actor Computation , 1992, CONCUR.

[71]  David Lorge Parnas,et al.  On the Design and Development of Program Families , 2001, IEEE Transactions on Software Engineering.

[72]  Ivica Crnkovic,et al.  Object-oriented design frameworks: formal specification and some implementation issues , 2001 .

[73]  Gul A. Agha,et al.  Concurrent object-oriented programming , 1993, CACM.

[74]  Glynn Winskel,et al.  Petri Nets, Event Structures and Domains, Part I , 1981, Theor. Comput. Sci..

[75]  Clemens A. Szyperski,et al.  Component software - beyond object-oriented programming , 2002 .

[76]  P. S. Thiagarajan,et al.  Temporal Logics for Communicating Sequential Agents: I , 1992, Int. J. Found. Comput. Sci..

[77]  José Meseguer,et al.  Order-Sorted Algebra I: Equational Deduction for Multiple Inheritance, Overloading, Exceptions and Partial Operations , 1992, Theor. Comput. Sci..

[78]  Matthew Flatt,et al.  PLT MzScheme: Language Manual , 2000 .

[79]  C. A. R. Hoare,et al.  A Model for Communicating Sequential Processes , 1980, On the Construction of Programs.

[80]  Rocco De Nicola,et al.  On the consistency of 'truly concurrent' operational and denotational semantics , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[81]  Mary Shaw,et al.  Abstraction and Verification in Alphard: Introduction to Language and Methodology , 1976 .

[82]  Glynn Winskel,et al.  Events in computation , 1980 .

[83]  Amílcar Sernadas,et al.  Local Specification of Distributed Families of Sequential Objects , 1994, COMPASS/ADT.

[84]  Benjamin C. Pierce,et al.  Simple type-theoretic foundations for object-oriented programming , 1994, Journal of Functional Programming.

[85]  Johannes Sametinger,et al.  Software Engineering with Reusable Components , 1997, Springer Berlin Heidelberg.

[86]  Brian Foote,et al.  Designing Reusable Classes , 2001 .

[87]  Niklaus Wirth,et al.  Modula: A language for modular multiprogramming , 1977, Softw. Pract. Exp..

[88]  Mogens Nielsen,et al.  Hereditary History Preserving Bisimilarity Is Undecidable , 1999, STACS.

[89]  Søren Christensen A logical characterization of asynchronously communicating agents , 1990 .

[90]  Mario Tokoro,et al.  Traces Semantics for Actor Systems , 1991, Object-Based Concurrent Computing.

[91]  Martin Fowler,et al.  Analysis patterns - reusable object models , 1996, Addison-Wesley series in object-oriented software engineering.

[92]  Per Brinch Hansen The purpose of concurrent Pascal , 1975 .

[93]  Muffy Calder,et al.  What Use are Formal Design and Analysis Methods to Telecommunications Services? , 1998, FIW.

[94]  Amílcar Sernadas,et al.  Logics for Specifying Concurrent Information Systems , 1998, Logics for Databases and Information Systems.

[95]  Horst Herrlich,et al.  Abstract and concrete categories , 1990 .

[96]  Mario Tokoro,et al.  On Asynchronous Communication Semantics , 1991, Object-Based Concurrent Computing.

[97]  C. A. R. Hoare,et al.  A Theory of Communicating Sequential Processes , 1984, JACM.

[98]  Ralph E. Johnson,et al.  Frameworks = (components + patterns) , 1997, CACM.

[99]  Gunter Saake,et al.  OMTROLL - Object Modeling in Troll , 1993 .

[100]  Clemens A. Szyperski,et al.  Why objects are not enough , 1998 .

[101]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.