A formal model of software subsystems

People form internal mental models of the things they interact with in order to understand those interactions. This psychological insight has been used by the human-computer interaction (HCI) community to build computer systems that are more intuitive for end users, but it has not yet been applied to the problems of software designers, programmers, and maintainers. In fact, conventional programming languages do little to help client programmers develop good mental models of software subsystems. The main problem is that the conventional wisdom that software modules are merely a syntactic mechanism for organizing declarations and controlling visibility is wrong. This skewed view of the nature of software modules limits their utility as effective building-blocks for creating large, complex software systems that are comprehensible to human readers. To constitute effective building-blocks, modules must present simple mental models to the software professionals involved in assembling them into larger modules, and ultimately into complete software systems. Because a module has no real semantic denotation of its own, there is no way for one to imagine such building-blocks as contributing to the understandability of the software comprising them. This dissertation presents the basic concepts of the ACTI model (Abstract and Concrete Templates and Instances), a theoretical model of software structure and meaning that addresses these concerns formally. ACTI supports the assignment of useful semantic denotations to software subsystems (building-blocks). Further, these assigned semantics can present models of each subsystem that are much simpler to understand than a straightforward composition of the lower-level parts from which the subsystem is constructed. In addition, ACTI is a mathematically formal, language-independent model of software components that captures a unifying conceptual view of software architecture embedded in modern module-structured languages. Here, the term "software component" refers to a reusable software subsystem, where a subsystem can vary in grain size from a single module up to a large scale generic architecture. It also unifies the module-structured and object-oriented views of what a software component is, and successfully integrates the key features of inheritance with parameterized programming.