Anthony MacDonald

Model-driven development within a legacy system: an industry experience report

Model-driven development claims to offer the same improvement to developers that the step from assembly to procedural programming languages offered developers in the last century. In this paper we report on a project that assessed the feasibility of applying a model-driven development approach to the evolution of a non-trivial legacy system in an industrial setting. The project focused on whether the promises of model-driven development hold in the real world and whether it possible to adopt model-driven development without losing the investment in existing third generation language code. An existing component from a system was redeveloped and integrated back into the system using a current model-driven development tool at Invensys Rail Systems Australia. From experiences throughout the project, and with the tool, a set of requirements for future model-driven development and model-driven development tools was produced. These requirements are designed to both aid tool developers, and to give companies a way of assessing the maturity of both future model-driven development tools and model-driven development itself.

SubCM: a tool for improved visibility of software change in an industrial setting

Software configuration management is the discipline of managing large collections of software development artefacts from which software products are built. Software configuration management tools typically deal with artefacts at fine levels of granularity - such as individual source code files - and assist with coordination of changes to such artefacts. This paper describes a lightweight tool, designed to be used on top of a traditional file-based configuration management system. The add-on tool support enables users to flexibly define new hierarchical views of product structure, independent of the underlying artefact-repository structure. The tool extracts configuration and change data with respect to the user-defined hierarchy, leading to improved visibility of how individual subsystems have changed. The approach yields a range of new capabilities for build managers, and verification and validation teams. The paper includes a description of our experience using the tool in an organization that builds large embedded software systems.

Guiding object-oriented design

We show how software architectural styles can be used to guide object oriented design. Design guidance is important, as the initial phases of software design significantly impact software quality. We use two different architectural styles to guide the design process from a formal specification to a design. Software architectural styles assist by providing a different level of reuse than currently practised in software design. A style provides a framework for top level structure and guides selection of components and interfaces. We show the impact of software architectural styles on software design.

Developing relational navigation to effectively understand software

Effective comprehension of complex software systems requires understanding of both the individual documents that represent software and the complex relationships that exist within and between documents. Relationships of all kinds play a vital role in a software engineers comprehension of, and navigation within and between, software documents. User-determined relationships have the additional role of enabling the engineer to create and maintain relational documentation that cannot be generated by tools or derived from other relationships. We argue that for a software development environment to effectively support the understanding of complex software systems, relational navigation must be supported at both the document-focused (intra-document) and relation-focused (inter-document) levels. The need for a relation-focused approach is highlighted by an evaluation of an existing document-focused relational interface. We conclude with the requirements for a relation-focused approach to relational navigation. These requirements focus on the users perspective when interacting with a collection of related documents. We define the requirements for a software development environment that effectively supports the understanding of the software documents and relationships that define a complex software system.

A framework for subsystem-based configuration management

Existing software configuration management (CM) tools are limited in the support they provide for configuration and change management of hierarchically structured software systems. This paper describes a framework for CM of subsystems-logically coherent collections of software development artefacts, including code, documentation and test sets. The goal is to provide visibility of changes at intermediate levels between whole-system and source-code levels, thereby reducing the complexity of the build V&V and change management processes. The framework supports characterisation of subsystems and changes to subsystems, and provides hooks into change tracking processes.

Structuring Z Specifications: Some Choices

This paper investigates the issue of structuring Z specifications. It uses examples from a large specification to examine both conventions for using Z and notational extensions including Object-Z. Because of the importance of good structure within a specification, specifiers need to be aware of a range of techniques and where each is applicable.

Some elements of Z specification style: structuring techniques

This article investigates the issue of structuring Z specifications. It uses examples from a large specification (the production cell) to examine both conventions for using Z and notational extensions, including Object-Z. Because of the importance of good structure within a specification, specifiers need to be aware of a range of structuring techniques and understand where each is applicable.

Enhanced Document Traceability for Development of Complex High-Integrity Software-Systems

An instantiation of the experimental UQ* document development environment was generated as part of an industry sponsored research project. The instantiation included two new syntax-directed textual document editors and a trace relation presentation tool that were developed as part of this research. The environment was used to test and explore how an environment with enhanced inter- and intra-document traceability can help meet the needs of current system development processes. It was found that projects to develop complex high-integrity soft ware-based systems exhibit three key tracing dimensions: evolution; refinement; and explication. It was also found that only relatively low levels of requirement to software design and related explanatory document traceability are currently being realised in representative software-system development environments. A tracing simulation exercise carried out showed that with the use of UQ* as a document-centred traceability engine, significant improvements in traceability levels were achievable. Indeed, with the support of UQ* it was possible to create, maintain, query, navigate and display direct links between system, subsystem and software requirements and program source code developed to meet them.