Colin J. M. Kemp

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.

Formal Methods within a Totally Functional Approach to Programming

Taking functional programming to its extremities in search of simplicity still requires integration with other development (e.g. formal) methods. Induction is the key to deriving and verifying functional programs, but can be simplified through packaging proofs with functions, particularly folds, on data (structures). Totally Functional Programming avoids the complexities of interpretation by directly representing data (structures) as platonic combinators - the functions characteristic to the data. The link between the two simplifications is that platonic combinators are a kind of partially-applied fold, which means that platonic combinators inherit fold-theoretic properties, but with some apparent simplifications due to the platonic combinator representation. However, despite observable behaviour within functional programming that suggests that TFP is widely-applicable, significant work remains before TFP as such could be widely adopted.

Software Engineering Foundations of Zoetic Data and Totally Functional Programming

Traditional higher-order functional programming is validated by how its logical conclusion in the shape of a “Totally Functional” style is consistent with and indeed determined by some fundamental principles of Software Engineering. The key to Totally Functional Programming is the notion of “zoetic” representations of data which embody the behaviours that we hypothesise to underlie all conventional symbolic datatypes. These representations minimise the interpretation of symbolic data at each use, and thus embody the principle of reuse. Further, we develop a scheme for formal synthesis of generator functions for zoetic data which entirely avoid the need for a separate interpretation stage. This avoidance allows us to achieve a clear separation of concerns between the creation of zoetic data objects on the one hand and their use in various applications on the other. Zoetic data are thus validated as the key enablers of the fulfilment of functional programming in its “Totally Functional” manifestation, firmly grounded in the language design consequences of software engineering principles.