scientific article; zbMATH DE number 4050933
In this book we attempt to shape the way students think about programming by presenting, justifying, and illustrating a cohesive doctrine. Our principal tenet is that abstraction and specification must be the linchpins of any effective approach to programming. We place particular emphasis on the use of data abstraction to produce highly modular programs. Chapter 1 discusses the problems that arise in constructing programs and provides an outline of our approach to program development. The remainder of the book is organized in a bottom-up manner. We begin by discussing the various kinds of abstractions that are the basic building blocks of our method and then go on to discuss some of the issues that arise in putting these blocks together. Chapter 2 contains an overview of the programming language CLU, one of a growing number of languages that contain facilities supporting data abstraction. Most of the sample implementations in the text are written in CLU. Chapters 3-6 focus on three kinds of abstractions: procedures, types, and iterators. We discuss what these abstractions are and how to specify, use, and implement them. Some of the discussion about implementation is CLU-specific, but most of it is not. Chapter 7 discusses how to use our programming method in conjunction with Pascal. Chapter 8 reemphasizes the role of specification in our programming method. It supplements the material in Chapters 3-6 with a more careful discussion of the meaning of specifications and presents some hints about writing good specifications. Chapter 9 deals with testing and debugging, chapter 10 formalizes the specification language used throughout the book, and chapter 11 introduces the key concepts used in program verification. Chapters 12-14 provide an overview of various aspects of the program production process. Chapter 12 discusses requirements analysis, chapter 13 program design, and chapter 14 design reviews and program development strategies. Chapter 13 is the most detailed of the three. It emphasizes modular decomposition based on the recognition of useful abstractions. Chapter 15 deals with the relationship of our programming method to programming languages. It covers much the same ground as chapter 7, but in a more general context. Most chapters of the book conclude with suggestions for further reading, and each chapter contains a set of exercises.
- Applications of coarse-grained dataflow in computational mechanis
- Specification and verification of object-oriented programs using supertype abstraction
- Applying abstraction and formal specification in numerical software design
- Stepwise refinement of heap-manipulating code in Chalice
- On assertion-based encapsulation for object invariants and simulations
- Introduction to programming by abstract data types. Incl. 1 CD-ROM
- Abstraction strategies in practice
- Synchronizing model and program refactoring
- Program development with control abstractions.
- scientific article; zbMATH DE number 41037 (Why is no real title available?)
- scientific article; zbMATH DE number 46740 (Why is no real title available?)
- scientific article; zbMATH DE number 54048 (Why is no real title available?)
- Interactions of abstractions in programming
- Alias burying: Unique variables without destructive reads
- Abstract contract synthesis and verification in the symbolic \(\mathbb{K}\) framework
- Specifications can make programs run faster
- First order data types and first order logic
- Verification of concurrent systems with VerCors
- Calculating modules in contextual logic program refinement
- Modular verification of multithreaded programs
- Type classes with existential types
- A general framework for architecture composability
- Towards imperative modules: reasoning about invariants and sharing of mutable state
- Observational purity and encapsulation
This page was built for publication:
Report a bug (only for logged in users!)Click here to report a bug for this page (MaRDI item Q3787422)