Component Composition in Business and System Modelling

Bespoke development of large business systems can be couched in terms of the composition of components, which are, put simply, chunks of development work. Design, mapping a specification to an implementation, can also be expressed in terms of components: a refinement comprising an abstract component, a concrete component and a mapping between them. Similarly, system extension is the composition of an existing component, the legacy system, with a new component, the extension. This paper overviews work being done on a UK EPSRC funded research project formulating and formalizing techniques for describing, composing and performing integrity checks on components. Although the paper focuses on the specification and development of information systems, the techniques are equally applicable to the modeling and re-engineering of businesses, where no computer system may be involved

Observation and abstract behaviour in specification and implementation of state-based systems

Classical algebraic specification is an accepted framework for specification. A criticism which applies is the fact that it is functional, not based on a notion of state as most software development and implementation languages are. We formalise the idea of a state-based object or abstract machine using algebraic means. In contrast to similar approaches we consider dynamic logic instead of equational logic as the framework for specification and implementation. The advantage is a more expressive language allowing us to specify safety and liveness conditions. It also allows a clearer distinction of functional and state-based parts which require different treatment in order to achieve behavioural abstraction when necessary. We shall in particular focus on abstract behaviour and observation. A behavioural notion of satisfaction for state-elements is needed in order to abstract from irrelevant details of the state realisation

Formal Transformations from Graphically-Based Object-Oriented Representations to Theory-Based Specifications

Formal software specification has long been touted as a way to increase the quality and reliability of software; however, it remains an intricate, manually intensive activity. An alternative to using formal specifications is to use graphically-based, semi-formal specifications such as those used in many object-oriented specification methodologies. While semi-formal specifications are generally easier to develop and understand, they lack the rigor and precision of formal specification techniques. The basic premise of this investigation is that formal software specifications can be constructed using correctness preserving transformations from graphically-based object-oriented representations. In this investigation, object-oriented specifications defined using Rumbaugh\u27s Object Modeling Technique (OMT) were translated into algebraic specifications. To ensure the correct translation of graphically-based OMT specifications into their algebraic counterparts, a formal semantics for interpreting OMT specifications was derived and an algebraic model of object-orientation was developed. This model defines how object-oriented concepts are represented algebraically using an object-oriented algebraic specification language O-SLANG. O-SLANG combines basic algebraic specification constructs with category theory operations to capture internal object class structure as well as relationships between classes. Next, formal transformations from OMT specifications to O-SLANG specifications were defined and the feasibility of automating these transformations was demonstrated by the development of a proof-of-concept system

Developing Error Handling Software for Object-Oriented Geographical Information

The inclusion of error handling capabilities within geographical information systems (GIS) is seen by many as crucial to the future commercial and legal stability of the technology. This thesis describes the analysis, design, implementation and use of a GIS able to handle both geographical information (GI) and the error associated with that GI. The first stage of this process is the development of an error-sensitive GIS, able to provide core error handling functionality in a form flexible enough to be widely applicable to error-prone GI. Object-oriented (OO) analysis, design and programming techniques, supported by recent developments in formal OO theory, are used to implement an error-sensitive GIS within Laser-Scan Gothic OOGIS software. The combination of formal theory and GIS software implementation suggests that error-sensitive GIS are a practical possibility using OO technology. While the error-sensitive GIS is an important step toward full error handling systems, it is expected that most GIS users would require additional high level functionality before use of error- sensitive GIS could become commonplace. There is a clear need to provide error handling systems that actively assist non-expert users in assessing, using and understanding error in GI. To address this need, an error-aware GIS offering intelligent domain specific error handling software tools was developed, based on the core error-sensitive functionality. In order to provide a stable software bridge between the flexible error-sensitive GIS and specialised error-aware software tools, the error-aware GIS makes use of a distributed systems component architecture. The component architecture allows error-aware software tools that extend core error-sensitive functionality to be developed with minimal time and cost overheads. Based on a telecommunications application in Kingston-upon-Hull, UK, three error-aware tools were developed to address particular needs identified within the application. First, an intelligent hypertext system in combination with a conventional expert system was used to assist GIS users with error-sensitive database design. Second, an inductive learning algorithm was used to automatically populate the error-sensitive database with information about error, based on a small pilot error assessment. Finally, a visualisation and data integration tool was developed to allow access to the error-sensitive database and error propagation routines to users across the Internet. While a number of important avenues of further work are implied by this research, the results of this research provide a blueprint for the development of practical error handling capabilities within GIS. The architecture used is both robust and flexible, and arguably represents a framework both for future research and for the development of commercial error handling GIS

Composite objects: dynamic representation and encapsulation by static classification of object references

The composition of several objects to one higher-level, composite object is a central technique in the construction of object-oriented software systems and for the management of their structural and dynamic complexity. Standard object-oriented programming languages, however, focus their support on the elementary objects and on class inheritance (the other central technique). They do not provide for the expression of objects' composition, and do not ensure any kind of encapsulation of composite objects. In particular, there is no guarantee that composite objects control the changes of their own state (state encapsulation). We propose to advance software quality by new program annotations that document the design with respect to object composition and, based on them, new static checks that exclude designs violating the encapsulation of composite objects' state. No significant restrictions are imposed on the composite objects' internal structure and dynamic construction. Common design patterns like Iterators and Abstract Factories are supported. We extend a subset of the Java language by mode annotations at all types of object references, and a user-specified classification of all methods into potentially state changing mutators and read-only observers. The modes superimpose composition relationships between objects connected by paths of references at run-time. The proposed mode system limits, orthogonally to the type system, the invocation of mutator methods (depending on the mode of the reference to the receiver object), the permissibility of reference passing (as parameter or result), and the compatibility between references of different modes. These restrictions statically guarantee state encapsulation relative to the mode-expressed object composition structure