Paul A. Bailes

A proposal for a bachelor's degree program in software engineering

Perception of Software Engineering as a multi-disciplinary profession like established branches of engineering justifies its treatment in a specialised bachelors degree. Identification of the essence of professional engineering education in general, and the instantiation of this essence with the particular content requirements of SE, provide precise SEE design criteria. The critical role of the introductory Programming course in establishing the importance of correct SE methods dictates the adoption of functional programming for its purposes. Necessary resources for teaching functional programming to introductory classes are either available or easily accessible. The curriculum overall builds upon this foundation, avoiding mistakes in existing CS curricula, providing quality academic education with the extensive practical and integrative work required for professional preparation.

TOWARDS AN OPEN SOFTWARE CONVERSION ARCHITECTURE

A generic architecture for the development and application of software conversion tools exposes the requirements set for appropriate enabling technologies. Extrapolation of this set beyond its satisfaction by existing proprietary technology then exposes the opportunity/need for open interfaces between separate components providing orthogonal dimensions of the overall functionality. Some novel aspects of the solutions considered include retrofitting persistence to an open compiler-compiler, and using the Unix file system as a persistent object store, while in the background the advent of standard interfaces to persistence technology suggests that the overall goal is feasible.

A generic, knowledge-based re-engineering architecture

A generic architecture for semi-automated reengineering and conversion of legacy systems is motivated, devised, applied, and evaluated. The motivation for mere semi-automation (as opposed to full automation) is that perfectly automatic conversion is unattainable and that explicit attention should be paid to handling the residue gracefully. The architecture needs to satisfy a number of specific application-oriented constraints, and depends heavily on the Software Refinery metaprogramming environment for its realization.

Automating software evolution

Software maintenance and evolution are the most expensive activities in the software process, consuming 60% to 80% of the total time spent on a software system. However our understanding of maintenance activities has barely developed beyond arbitrary change to arbitrary things. The standard categories of maintenance are based on subjective characteristics (purpose), rather than objective attributes. Only by understanding the relationships and dependencies between entities in the software process (such as specification, design and implementation) can we begin to objectively categorise and potentially automate aspects of software evolution.

DAda—an Ada preprocessor for functional programming

The impact of declarative (functional) programming is inhibited by the need to learn/use new languages. A series of language extensions implemented by preprocessing, which integrates functional programming into the Ada culture, is described. Features include lazy streams, recursive data structures, the abolition of assignment and its replacement by data-flow control constructs.

A re-engineering evaluation of Software Refinery: architecture, process and technology

The quality of software re-engineering tools depends on that of the generic environments used in their construction. Because re-engineering is extremely challenging, too much so for full automation, generic re-engineering environment design criteria emphasise linguistic expressiveness and interaction with persistent repositories for program representations. Existing quality re-engineering environments, such as the Software Refinery tool, go a long way to satisfying these criteria, but fail to meet open systems criteria. One remedial approach is to recreate some of the functionality of these environments by modifying public domain technology, but which runs the risk of limited interoperability and over-investment in development.<<ETX>>

GRIT-an extended REFINE for more executable specifications

Knowledge-based software engineering (KBSE) languages should be as expressive as possible and should allow the reflection in executable programs of their non-executable specification origins. REFINE is the KBSE language for the Software Refinery metaprogramming environment. REFINEs expressiveness is extended with recursively-enumerable sets and parallel logical connectives. A subtype system was developed for the otherwise typeless functional language G, hence the name GRIT (G-REFINE InTegration) for this effort. The relationships between REFINE programs and original specifications is made possible by using the recursively-enumerable sets as the basis for a comprehensive system of run-time-checked assertions, which are subject to both set- and type-theoretic compositions.<<ETX>>

A proposal for a genuinely-lazy streams facility for Ada

Abstract The first stage in developing a preprocessor-based Ada extension for functional programming is a facility for demand-driven, “lazy” data streams. One example of the applicability of such structures is in producer-consumer situations. As well as demand-driven data generation, laziness ensures that multiple references to the same element of a stream do not involve re-calculation of its value. A characterization of stream definitions in a genuine functional language is translated into the corresponding Ada forms, and a new syntactic interface to these forms put forward. Complementary operations that manipulate streams are introduced likewise. The robustness of the design and its implementation path are demonstrated by example, but the need and potential for further development are acknowledged.

Full functional programming in a declarative Ada dialect

Functional-style programming and languages have an important role to play in the software life cycle, but for a variety of technical and organisational reasons are of limited utility until they are integrated with existing languages, notably Ada. A preprocessor implementation provides the full generality of functional programming - programmer-definable function-valued functions - and the usual consequent facility set: lazy evaluation; streams; and data-flow style control constructs. The design and implementation of contemporary functional languages sets quality standards that the Ada9X effort would do well to heed.

KBSE and Ada - Object and Enabling Technology

“Layering” is a visualisation technique that enables basic relationships between software system components to be overlaid with the results of more sophisticated design recovery analyses. Layering can be implemented via a simple presentation tool, to which the results of different analysers can be coupled. Knowledge-based analysis technology can be extended to support Ada83-Ada95 conversion. Taking advantage of the self-implementation of the enabling technology, the conversion tool can be involuted so that the enabling technology itself is able to be represented in Ada95.