Eric J. Salzman

Teaching programming to beginners - choosing the language is just the first step

Over the years there has been an ongoing debate about which computer language to adopt for a first programming subject. Although some may not agree, the current consensus is that the object-oriented languages are winning the argument, and Java has increasingly become the language of choice for teaching beginners. But choosing the language is only the first step in designing a first programming subject. The adoption of an object-oriented language such as Java offers an opportunity to completely rethink our approach to teaching first-year programming, an opportunity that should not be missed. In this paper we identify what we see as the non language-specific core issues, and discuss how we approached these issues when designing and teaching a programming subject for beginners.

A Comparison of Two Notations for Process Communication

This paper compares the mechanisms for process communication, synchronisation and non-determinism in recent language proposals by Hoare and Brinch Hansen, by both qualitative and quantitative analyses. A significant variation in effectiveness with program class is shown.

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.

Tracing the Evaluation of Lazy Functional Languages: A Model and its Implementation

We address the problem of producing a trace of the evaluation of a program written in a lazy functional language. To avoid ambiguities and possible misunderstandings it is essential that the trace structure is defined with respect to a formally described model of program evaluation.

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 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.

Towards an Ada basis for KBSE: Refine-Ada 95 conversion

Knowledge-Based Software Engineering (KBSE) can be facilitated by more accessible enabling technology. Ada95 is now universally- accessible, so the universal accessibility of KBSE will be assured if Ada95 is seen to support it. An automatic conversion from the Refine programming language component of the Software Refinery KBSE environment exposes the strengths and weaknesses of Ada95s support for KBSE. At the very least, Ada95 enables the more widespread distribution of KBSE applications developed with Software Refinery.

Preprocessing first-class functions for Ada

Realisation of the benefits of declarative programming can be acheived by improving its accessibility from other language cultures. Providing the essence of the functional style-first-class functions-for Ada is the example studied here. Its tasking facility provides a raw basis for first-class procedural abstractions, but without the desired applicative interface. This is achieved by staged development involving: multiple instances of the one function type; data transmission via parameter/result; recursion; and lazy evaluation.<<ETX>>