Summary

This chapter has presented an introduction to the theoretical foundations of abstract data types. In particular, a characterization was given of types as constraints.

Abstraction and types

1


slide: Section 8.1: Abstraction and types

In section 1, we discussed the notion of abstraction in programming languages and distinguished between control and data abstractions. Abstract data types were characterized as values in some domain, and we looked at the various ways in which to define mathematical models for types.

Algebraic specification

2

  • signature -- producers and observers
  • generator universe -- equivalence classes
  • initial model -- no junk, no confusion
  • objects -- multiple world semantics

slide: Section 8.2: Algebraic specification

In section 2, we studied the algebraic specification of abstract data types by means of a signature characterizing producers and observers. We discussed the notions of equivalence classes and initial models, which consist of precisely the equivalence classes that are needed.

Decomposition -- modules versus objects

3

  • data abstraction -- generators/observers matrix
  • modules -- operation oriented
  • objects -- data oriented

slide: Section 8.3: Decomposition -- modules versus objects

Also, we looked at the interpretation of objects as algebras, and we discussed a multiple world semantics allowing for dynamic state changes. In section 3, we looked at the various ways we may realize data abstractions and we distinguished between a modular approach, defining a collection of operations, and a data oriented approach, employing objects.

Types versus classes

4

  • types -- syntactically, semantically, pragmatically
  • compatible modifications -- type, signature, class

slide: Section 8.4: Types versus classes

Finally, in section 4, we discussed the differences between a syntactic, semantic and operational interpretation of types, and how these viewpoints affect our notion of refinement or compatible modification.

Questions

  1. Characterize the differences between control abstractions and data abstractions. Explain how these two kinds of abstractions may be embodied in programming language constructs.
  2. How can you model the meaning of abstract data types in a mathematical way? Do you know any alternative ways?
  3. Explain how types may affect object-oriented programming.
  4. What is a signature? What distinction can you make between the various functions specified in a signature?
  5. What is an initial model? What properties does such a model satisfy?
  6. How would you characterize the meaning of an object with dynamic state changes in an algebraic fashion?
  7. Explain how you may characterize an abstract data type by means of a matrix with generator columns and observer rows. What benefits does such an organization have?
  8. How would you characterize the differences between the realization of abstract data types by modules and by objects? Discuss the trade-offs involved.
  9. How would you characterize the distinction between types and classes? Mention three ways of specifying types. How are these kinds related to each other?
  10. How would you characterize signature compatible modifications? Explain its weaknesses. What alternatives can you think of?

Further reading

There is a vast amount of literature on the algebraic specification of abstract data types. You may consult, for example,  [Dahl92].