This paper discusses modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time. The effectiveness of a “modularization ” is dependent upon the criteria used in dividing the system into modules. A system design problem is presented and both a conventional and unconventional decomposition are described. It is shown that the unconventional decompositions have distinct advantages for the goals outlined. The criteria used in arriving at the decompositions are discussed. The unconventional decomposition, if implemented with the conventional assumption that a module consists of one or more subroutines, will be less efficient in most cases. An alternative approach to implementation which does not have this effect is sketched.

Component-based approaches for the software development are well-known. Most of these approaches (like CORBA and COM++) focus on the realization of the connection between the components and their interactions. In this paper we concentrate on the missing items in the component-based software engineering: the problem how to model component composition and to validate them. We apply the component model based on the interface description with InPorts and OutPorts which allow a rather detailed definition of the components interaction. Moreover we take the term feature to name the core requirements to a component. Features are used to drive the description of the component composition which is regarded as an combination of features expressed by logical operators. Moreover the InPorts and OutPorts describe the dynamic component interactions. The combination of OutPorts and InPorts according to the component composition rules allows to reason about the component system's dynamic behavior.

Approved for public release; distribution is unlimited. This thesis was completed in cooperation with the Institute for Information Superiority and Innovation.

Abstract. Component-based approaches for the software development are well-known up to now. Most of these approaches (like CORBA and COM++) focus on the realization of the connection between the components and their interactions. In this paper we concentrate on the missing items in the componentbased software engineering: the problem how to model component composition and to validate them. We apply the component model based on the interface description with InPorts and OutPorts which allow a rather detailed definition of the components interaction. Moreover we take the term feature to name the core requirements to a component. Features are used to drive the description of the component composition which is regarded as an combination of features expressed by logical operators. Moreover the InPorts and OutPorts describe the dynamic component interactions. The combination of OutPorts and InPorts according to the component composition rules allows to reason about the component systems dynamic behavior. 1

Abstract: Protocols are formal models which may be used to define the interactions within processes. Moreover, protocols may be the base of process improvement e.g. by applying game theory. In the paper we focus on models of interactions between system components (which we name versions) and the possibilities to verify that the version systems fulfill the rules (specifications) of the protocols. First, we consider the static relationships between the versions as base. Second, we discuss the dynamic interactions between these versions and present a model checking-based approach to verify the interaction specifications of the protocols. Such verified interaction sequences (or processes) are a starting point of optimizations by game theory approaches. 1