Software engineering 1. Abstraction and modelling. (Q1773139)

The book under review is the first one from a series of three volumes that provides a compelling framework for a more comprehensive understanding of both formal and practical concerns of software engineering. The major feature distinguishing these textbooks from other current ones on software engineering is the natural manner in which the formal techniques smoothly glide from software design towards the requirements prescription phase and beyond to domain description. This first volume sets the stage for the entire series. In Part I, ``Opening'', the author defines a so-called software engineering triptych as a unified approach describing the relations between the three main software development phases: domain descriptions, requirements descriptions and software design. Domain engineering deals with the methodologies used to describe that area of human activity where the need for intended software arises from. Requirements engineering focuses on the contractual relation between a client and a software deliverer. Software design deals with concerns of software architecture, component composition and design, software development methodologies and so on. In a rough characterization, domain descriptions are viewed as having an indicative role, the requirements prescriptions are putative, and software specifications are imperative. Part II, ``Discrete mathematics'', contributes to the self-contained feature of the series by supplying the reader with the main basic notions of the mathematics that a software engineer has to be familiar with. The central approach of this part is the treatment of types (Chapter 5, ``Types''). The very basics of type theory and practice (abstract types, concrete types, atomic types, type constructors) are introduced in a systematic manner using the discrete mathematics foundations from Chapter 2, ``Numbers'', Chapter 3, ``Sets'', and Chapter 4, ``Cartesians''. Further topics on types are then developed using functions (Chapter 6), \(\lambda\)-calculus (Chapter 7) and algebras (Chapter 8). This way the reader is invited to an introspection of type approaches starting from simple types and going further to function types and quantification (Chapter 9, ``Mathematical logic''). This preparatory introduction into type theory aims at a better understanding of the RAISE Specification Language (RSL). Part III, ``Simple RSL'', covers the basics of this main specification tool. The author motivates his option for RSL mainly because it is closest to discrete mathematics and includes the most important expression facilities of other specification languages, as for instance the imperative style of VDM-SL, algebraic specification style of CASL and CafeOBJ and modular design. Besides, RSL allows for expression concurrency. The presentation does not follow the reference manual style, the author inclining instead towards a more pragmatic approach by acting the topics according as they are needed in a real abstraction and modelling activity. Chapters 10--11 cover the very basics of RSL, namely the atomic types, values and functions. Chapter 12, ``Property-oriented and model-oriented abstraction'', gives a review of the notion of property-oriented abstraction, introduces the concept of model-oriented abstraction and relates these two ideas. The next five chapters (13--17) deal with a number of model-oriented representations and operation abstraction techniques and tools based on sets, cartesians, lists, maps and high-order functions. The RSL type constructs are summarized and further developed in Part IV. Chapter 18, ``Types in RSL'' introduces the type concepts of constructors and destructors, union types, variant types, record type definitions and subtypes. Part V, ``Specification programming'' focuses on illustrating a spectrum of specification programming which spans from functional (Chapter 19) and imperative (Chapter 20) specification to parallel specification programming (Chapter 21). Here, the Communicating Sequential Processes language (CSP) is used as a tool for expressing parallelism. Next, CSP is extended to a RAISED version (RSL/CSP) and the presentation focuses on principles and laws for modelling concurrent behavior in RSL. All chapters are supplied with a long list of consistent exercises. The book also contains a rather complete Glossary containing 788 software engineering specific items. By its consistency and rigor, the book is, undoubtedly, remarkably useful to professional software developers.