Publications of Franz Puntigam (Punt00)

Franz Puntigam.
Concurrent Object-Oriented Programming with Process Types.
Habilitationsschrift. Der Andere Verlag, Osnabrück, Germany, 2000.

Abstract:

Types in object-oriented programming languages are an important concept supporting the reuse and maintenance of software. Conventional types of objects specify constant sets of messages that can be accepted by the objects. However, messages in a concurrent system cannot always be accepted; their acceptability depends on synchronization conditions. Changes of message acceptability frequently follow fixed, statically known patterns. Conventional types do not reflect such changes.

Unlike conventional types, process types specify sets of acceptable message sequences. Whenever a message is accepted, the acceptability of the following messages can change as expressed in a process type. Although message acceptability changes dynamically a compiler can statically ensure the acceptability of all messages occurring in a system.

This book studies process types embedded in a concurrent object calculus. The material is based on the author's research carried out within the last five years. Intended readers are computer scientists and practitioners interested in concurrent object-oriented programming and types. Some familiarity with object-oriented programming concepts is presumed. This book answers among others the following questions:

• Why is it important to model synchronization conditions in types, and how can we do that in a practically useful way?
• What is the meaning of subtyping on process types, and how can we decide subtyping?
• What do we expect from a concurrent object-oriented programming language supporting such types?
• How can we perform static type checking, and which properties can we expect from type-checked programs?
• How can we apply static type checking to prevent deadlocks?
• How can we reduce the amount of type information a programmer has to write?

The book is structured as follows. In Chapter 1 we argue that there are good reasons for types to play an important role in object-oriented programming. Because of missing information about synchronization, types in conventional object-oriented languages are not sufficient for concurrent programming. We briefly overview approaches towards typed concurrent programming and motivate the investigation of process types.

In Chapter 2 we introduce a concurrent object calculus as a basis for discussing our types. Process types are integrated into this calculus. We define the important notions of type equivalence, subtyping, type determinism, and type safety and show by examples how we can use the calculus and its type system.

In Chapter 3 we discuss process types and some relations on them. We prove among other properties that type equivalence, subtyping, and type determinism are decidable. Furthermore, we introduce prototype sets as a semantic model for types and show that type equivalence and subtyping are sound and complete with reference to equality and containment of prototype sets together with an extensibility criterion.

In Chapter 4 we deal with static type checking. We introduce a strong type system which ensures that type-checked processes in our calculus are type safe. Static type checking supports separate compilation and type-safe component replacement. We briefly discuss also some practical implementation issues.

In the next two chapters we extend the process type concept to increase the expressiveness of types. Synchronized process types discussed in Chapter 5 are useful in situations where clients of an object are strictly coordinated. These types model stronger synchronization conditions. Obligatory messages specified by the types in Chapter 6 must eventually be sent while optional messages can be sent. We show how static type checking can prevent deadlocks that may cause obligatory messages not to be sent.

In Chapter 7 we discuss state inference. Programmers using this type concept define object types only partially. The missing type information is computed during static type checking. Programmers usually need not care about state information in types.

Finally, in Chapter 8 we briefly recapitulate the material in this book and mention some open problems to be addressed in future work.

@Book{Punt00,
  author    = {Franz Puntigam},
  title     = {Concurrent Object-Oriented Programming with Process Types},
  publisher = {{Der Andere Verlag}},
  year      = 2000,
  address   = {Osnabr{\"u}ck, Germany}
}