The denotational basis for software execution tracing

Software execution tracing is a popular and effective technique, used to support a range of software engineering activities. Nevertheless execution tracing has rarely been the focus of study in its own right, although many case studies and applications have been described. Existing formal notions of trace in computer science are shown to be based implicitly, and then explicitly, on an operational semantic basis, and the limitations of the resulting trace monoid structure for many practical tracing tasks is highlighted. Justified by the category theoretic notion of duality, this paper introduces the denotational basis for software execution tracing, to address these practical limitations. An example of a language with denotational trace added is presented: A simple program in that language, its denotational traces, and their subsequent analysis are shown to support complex tasks such as specification recovery and reasoning about correctness, as well as simple, informal proofs of space and time complexity - techniques and results of immediate usefulness to the practicing software engineer. While both the theory of denotational trace and its consequences are in an early stage of development, initial results suggest uniquely useful, practical results can be derived from denotational traces

Higher-order catamorphisms as bases for program structuring and design recovery

Catamorphisms ("foldr" on lists, but generally applicable to any regular recursive datatype) are not just useful but are an effective basis for a recursion-pattern-based discipline of program design. A new presentation for catamorphisms makes it clear how they provide functional semantics for symbolic datatypes, with the capacity to expose significant variations in program design. A further development of the new presentation exploits the higher-order capabilities of functional languages. This is the key enabler for a comprehensive replacement of symbolic data and their interpreters, either implicit or explicit, with direct functional representations. These extensions, of the applicability of catamorphisms and of their presentations, make them even more attractive as bases for program structuring and design, and likewise as targets for software reverse engineering and design recovery

From computer science to software engineering – a programming-level perspective

An important step from computer science to a true discipline of software engineering is to impose discipline upon the behavior of practitioners. At the programming level, this is manifested by the constraint to use catamorphisms as the basic pattern of recursion/iteration. Catamorphisms exist for all regular recursive types and discipline (and simplify programming) to the selection of recursion pattern parameters. Reasoning about programs (for verification, transformation and optimization purposes) is similarly simplified. Catamorphisms are just one of a range of programming patterns explained by and understood in terms of mathematical category theory. The proposition that category theory provides the theory of programming (design as well as coding) is reinforced by the ability of modern programming languages to represent categorical abstractions in source code