home *** CD-ROM | disk | FTP | other *** search
/ ftp.disi.unige.it / 2015-02-11.ftp.disi.unige.it.tar / ftp.disi.unige.it / pub / .person / ZuccaE / ftpREADME < prev    next >
Text File  |  2002-06-05  |  12KB  |  252 lines
  1. Papers available in this directory in .ps.gz format:
  2.  
  3. FST-TCS90
  4. ---------
  5. R. Breu and E. Zucca
  6. An Algebraic Compositional Semantics of an Object Oriented Notation with Concurrency.  
  7.  
  8. In C.E. Veni Madhavan,  editor, 
  9. Foundations of Software Technology and Theoretical Computer Science, 
  10. number 405 in Lecture Notes in Computer Science, pages 131-142. 
  11. Springer Verlag, Berlin, 1990.
  12.  
  13. Abstract:
  14. This paper presents an algebraic compositional semantics for a schema of an
  15. object-oriented syntax which models many existing features as class hierarchies,
  16. polymorphism and concurrency, using a pattern which could be applied to different
  17. concrete languages. The semantics is defined in a classical denotational style, i.e.
  18. giving an abstract syntax, the semantic domains and the interpretation of the syntactic
  19. operators. 
  20. The given semantics is algebraic in the sense that the value denoted by a class is a
  21. class of algebras described by an algebraic specification.  A class combinator (e.g.
  22. inheritance) is semantically interpreted in this framework as a function which handles 
  23. classes of algebras or, in an equivalent way, as a specification combinator. Moreover, 
  24. our schema of semantic definition allows to model also concurrent features if any, by 
  25. underlying an approach to concurrency based on algebraic transition systems.
  26.  
  27. MFCS93
  28. ------
  29. E. Astesiano, G. Reggio, and E. Zucca.
  30. Stores as Homomorphisms and Their Transformations.
  31.  
  32. In A. M. Borzyszkowsky and S. Sokolowsky, editors, 
  33. Mathematical Foundations of Computer Science 1993, 
  34. number 711 in Lecture Notes in Computer Science, pages 242-251. 
  35. Springer Verlag, Berlin, 1993.
  36.   
  37. Abstract:
  38. In the classical denotational model of imperative languages handling structured types, 
  39. like arrays, requires an ad-hoc treatment for each data type, including e.g. an ad-hoc 
  40. allocation and deallocation mechanism. Our aim is to give a homogeneous approach that 
  41. can be followed whichever is the data structure of the language. 
  42. We start from the traditional model for Pascal-like languages, which uses a notion of 
  43. store as a mapping from left values (containers for values, usually called locations), 
  44. into right values; we combine this idea with the well-known algebraic approach for 
  45. modelling data types. More precisely, we consider an algebraic structure both for the 
  46. right and the left values; consequently, the store becomes a homomorphic mapping of 
  47. the left into the right structure.
  48. Seeing a store as a homomorphism has a number of interesting consequences. First
  49. of all, the transformations over a store can be uniformly and rigorously
  50. defined on the basis of the principle that they are minimal variations
  51. compatible with some basic intended effect (e.g., some elementary substitution).
  52. Thus semantic clauses too, which rely on these transformations as auxiliary
  53. functions, can be given uniformly; for example, we can give a unique clause for
  54. assignment for any data type in Pascal and Ada-like languages.
  55.  
  56.  
  57. Volkse
  58. ------
  59. E. Astesiano and E. Zucca.
  60. A Semantic Model for Dynamic Systems.
  61.  
  62. In U.W. Lipeck and B. Thalheim, editors, 
  63. Modelling Database Dynamics, Volkse 1992, Workshops in Computing, pages 63-83. 
  64. Springer Verlag, Berlin, 1993.
  65.   
  66. Abstract:
  67. We present a new formal structure, called d-oid, for modelling systems of evolving 
  68. objects. In our view, d-oids are the dynamic counterpart of many-sorted algebras, in 
  69. the sense that they can model dynamic structures as much as algebras can model 
  70. static data types. D-oids are a basis for giving syntax and semantics for kernel 
  71. languages for defining methods; these languages are built over what we call method 
  72. expressions, like applicative kernel languages are built over terms. Moreover some 
  73. hints are given towards modelling classes and inheritance.
  74.  
  75. MSCS
  76. ----
  77.  E. Astesiano and E. Zucca.
  78.  D-oids: a Model for Dynamic Data-Types.
  79.  
  80.  Mathematical Structures in Computer Science.
  81.  Vol. 5, number 2, pp. 257-282.
  82.  June 1995.
  83.  (DISI-TR-94-16)
  84.  
  85. Abstract: 
  86. We propose a semantic framework  for dynamic systems which, in a sense, 
  87. extends the well-known algebraic approach for modeling
  88. static data structures to the dynamic case. 
  89. The framework is based on a new mathematical structure, called d-oid, consisting of 
  90. a set of instant structures and a set of dynamic operations. An instant structure 
  91. is a static structure, e.g. an algebra; a dynamic operation is a transformation of 
  92. instant structures with an associated point to point map, which allows to keep track
  93. of the transformations of single objects and thus is called tracking map. By an
  94. appropriate notion of morphism the d-oids over a dynamic signature constitute a 
  95. category. 
  96. It is shown that d-oids can model object systems and support an abstract notion of 
  97. possibly unique object identity; moreover, for a d-oid satisfying an identity
  98. preserving condition, there exist an essentially equivalent d-oid where the elements 
  99. of instant structures are just names.   
  100.  
  101.  
  102. JCSS
  103. ----
  104.  E. Astesiano and E. Zucca.
  105.  A Free Construction of Dynamic Terms.
  106.  
  107.  Journal of Computer and System Sciences.
  108.  Vol. 52, number 1, pp. 143-156.
  109.  February 1996.
  110.  (DISI-TR-94-25)
  111.  
  112. Abstract: 
  113. In this paper we show that it is possible to extend in a natural way to the dynamic
  114. case some basic results of the classical approach to (static) data types. Within an 
  115. appropriate framework of dynamic structures (called d-oids), which play the same role
  116. of algebras in the static case, we define a language
  117. of dynamic terms, also enjoying the property of unique canonical representation;
  118. moreover dynamic terms constitute a free structure whenever the static terms in the
  119. underlying static framework are so. As a main application of the above construction, 
  120. we get a rather elegant kernel language for recursive definitions of dynamic derived
  121. operations, which parallels the well-known McCarthy's schema for a kernel applicative
  122. language. This kernel language can be seen also as a metalanguage for expressing the 
  123. semantics of concrete (e.g. imperative or object based) languages.
  124.  
  125.  
  126. WADT95
  127. ------
  128. E. Zucca.
  129.  Implementation of Data Structures in an Imperative Framework.
  130.  
  131.  In Recent Trends in Data Type Specification '94 
  132.  (10th Workshop on Specification of Abstract Data Types joint with the 5th COMPASS Workshop
  133.   - Selected Papers),
  134.  number 906 in Lecture Notes in Computer Science, pages 483-498, 
  135.  Berlin, 1995. Springer Verlag.
  136.  (DISI-TR-94-28)
  137.  
  138. Abstract:
  139. We present a formal definition of implementation between concrete structures within
  140. the framework of dynamic data-types. The main outcome is an adequate and uniform
  141. semantic model for stating when a software module in an imperative or object
  142. based language is a correct implementation of a data structure. Moreover, the
  143. definition is obtained extending in a natural way the notion used in the static case,
  144. showing that our dynamic frameworks are a ``sound'' generalization
  145. of static frameworks.  
  146.  
  147. MFCS96
  148. ------
  149. E. Zucca.
  150.  From Static to Dynamic Abstract Data-Types.
  151.  
  152. In W. Penczek and A. Szalas, editors, 
  153.   Mathematical Foundations of Computer Science 1996, 
  154.   number 1113 in Lecture Notes in Computer Science, pages 579-590. 
  155.   Springer Verlag, Berlin, 1996.
  156.  
  157. Abstract:
  158. We show how to extend in a canonical way a given formalism for specifying
  159. (static) data types (like usual algebraic specification frameworks) with dynamic features. 
  160.  What we obtain in this way is a
  161. corresponding formalism for specifying dynamic data-types based on the 
  162. "state-as-algebra" approach: a dynamic data-type models a 
  163. dynamically evolving system in which any state can be viewed as 
  164. a static data type in the underlying formalism, and the dynamic evolution is given 
  165. by operations handling states. Formally, our construction is a transformation
  166. of (pre)institutions. 
  167.  
  168. FAC96Short
  169. ----------
  170. R. Breu and E. Zucca
  171. An Algebraic Semantic Framework for Object Oriented Languages with Concurrency
  172. (Extended Abstract, 10 pages).
  173.   
  174. Formal Aspects of Computing, Vol.8, number 6, pages 706-715, 1996.
  175.  
  176. Abstract: This paper presents an algebraic semantics for a schema of 
  177. object oriented languages including concurrent features. A class, the basic 
  178. syntactic unit of object oriented languages, denotes a set of algebras determined 
  179. by an algebraic specification. This specification describes a system of (possibly 
  180. active) objects interacting via method calls. Extending other approaches, 
  181. structured classes are modelled in a fully compositional way. This means that the 
  182. semantic counterpart of class combinators like inheritance and clientship are 
  183. specification combinators. A model of records with sharing allows us to describe 
  184. typical object oriented features like object sharing, inheritance polymorphism and 
  185. dynamic binding. For modelling how objects evolve in a concurrent environment, we 
  186. rely on an algebraic description of labelled transition systems.
  187.  
  188. FAC96Full
  189. ---------
  190. R. Breu and E. Zucca
  191. An Algebraic Semantic Framework for Object Oriented Languages with Concurrency.
  192. (Full Version, 45 pages).
  193.   
  194. Formal Aspects of Computing (electronic supplement), Vol.8E, number 6, 1996.
  195. (DISI-TR-95-02, 1994)
  196.  
  197. TCS98
  198. -----
  199. E. Zucca.
  200.  From Static to Dynamic Abstract Data-Types: an Institution Transformation.
  201.  
  202. Theoretical Computer Science, Vol 216, Issue 1/2, March 1999.
  203. (DISI-TR-96-1, 1996)
  204.  
  205. Abstract:
  206. We show how to extend in a canonical way a given formalism for specifying
  207. (static) data types (like usual algebraic specification frameworks) with dynamic 
  208. features. 
  209. What we obtain in this way is a corresponding formalism for specifying
  210. dynamic data-types based on the "state-as-algebra" approach: a dynamic data-type 
  211. models a dynamically evolving system in which any state can be viewed as 
  212. a static data type in the underlying formalism, and the dynamic evolution is given 
  213. by operations handling configurations. Formally, our construction is a functor between
  214. two appropriate categories of (specialized) institutions. 
  215.  
  216. SCP98
  217. -----
  218. E. Astesiano, G. Reggio and E. Zucca
  219. Stores as Homomorphisms and Their Transformations - A Uniform Approach to
  220. Structured Types in Imperative Languages     
  221.  
  222. Science of Computer Programming, Vol. 34 Issue 3, pag.163-190, June 1999.
  223. (DISI-TR-94-14, 1994)
  224. Extended version of  MFCS93 (Stores as Homomorphisms and Their 
  225. Transformations)
  226.  
  227. Abstract: We address the problem of giving a clean and uniform mathematical 
  228. model for handling user defined data types in imperative languages, contrary to
  229. the ad-hoc treatment usual in classical denotational semantics.
  230. The problem is solved by defining the store as a homomorphic mapping of an
  231. algebraic structure of left values modelling containers into another one of
  232. right values modelling contents. Consequently store transformations can be
  233. defined uniformly on the principle that they are minimal variations of the
  234. store embedding some basic intended effects and compatible with the
  235. homomorphic structure of the store. 
  236.  
  237. FAC99
  238. ----------------
  239. P. Audebaud and E. Zucca
  240. Deriving Proof Rules From Continuation Semantics
  241.   
  242. Formal Aspects of Computing, 11(4), 1999.
  243. (RR 97-19, LIP-ENS Lyon, 1997)
  244.  
  245. Abstract: We claim that the continuation style semantics of a programming language 
  246. can provide a starting point for constructing a proof system for that language. The
  247. basic idea is to see weakest precondition as a particular instance of continuation 
  248. style semantics, hence to interpret correctness assertions (e.g. Hoare triples) 
  249. as inequalities over continuations. This approach also shows a
  250. correspondence between labels in a program and annotations.
  251.  
  252. Last update 18 August 1999