Students taking an undergraduate course in computer organization that is part of a liberal arts program (similar to the course CJ203 of the ACM/IEEE-CS Curriculum 1991) are the primary targeted audience for this book. Topics mentioned in that course begin at the level of data representation and move to the machine language level, the symbolic assembly language level, and the system level. This book assumes that students have taken one year of a high-level programming course and one year of college-level mathematics.
The book is divided into six parts and 16 chapters. Part1, “The High-level Language Model,” covers a Pascal-like, high-level language called “Hill” and discusses data types, executable statements, control structures and program flow, modularity constructs, and the high-level language as protector.
Part 2, “The Assembly Language Model,” contains four chapters: chapter 2, “Overview of the Assembly Language Model,” chapter 3, “A Short Guide to Programming in Assembly Language,” chapter 4, “Numeric Representation and Computer Arithmetic,” and chapter 5, “Structures: Data and Control,” which includes pointers, arrays, loops, and parameter passing.
Part 3, “The Machine Language Level,” consists of two chapters: chapter 6, “The Machine Language Model,” which includes the fetch/execute cycle, the bus, and jumps, and chapter 7, “The Assembler and Related Software,” which includes the assembler, symbol table, and linkers and loaders.
Part 4, “The Digital Logic Model,” contains three chapters: chapter 8, “Logical Operations,” chapter 9, “Digital Circuits,” which includes decoders, the multiplexor, shifters and adders, and chapter 10, “Memory,” which includes primary memory, cache, and memory hierarchy.
Part 5, “The Integrated System Model,” contains two chapters: chapter 11, “The Computer as a System,” which includes process termination, virtual machines, multiprocessors, and virtual memory, and chapter 12, “Input and Output,” which includes I/O logic and ports; interrupt-driven I/O; and buffers, direct memory access, and random and sequential access devices.
Part 6, “Extensions,” consists of four chapters: chapter 13, “Debuggers, Debugging, and Antibugging,” chapter14, “Real Arithmetic,” chapter 15, “Variations on the von Neumann Model: Microprogrammed and RISC Machines,” and chapter 16, “Alternatives to the von Neumann Model: Parallel Machines.”
A set of exercises follows each chapter. The book includes an appendix on assembly language structure and style and a list of term projects.
Although almost all books in this area cover the relevant material on high-level assembly and machine language features, this book emphasizes these languages and their constructs, features, programming style, and debugging. Including 300 pages of languages and programming before only 60 shallow pages of digital design, followed by 190 pages of operating systems and extensions seems unbalanced.
In order to avoid using existing languages or machines, the author introduces his own high-level language and assembly language constructs. Unfortunately, these end up being used inconsistently and incorrectly (see the discussions and usage of loops on pages 14, 121, and 180). Other types of errors can be found on page 481 (“an emulator is a program that simulates,” and a dangling abbreviation, “ml machine,” which I guess stands for “machine language model machine”) and page 315, which gives a strange analogy (multiplexors “may merge many signals into one”).
Scragg addresses his readers with enough warnings, signals, and leads, providing recurrent themes. Unfortunately, this made the book at times extremely repetitive, chatty, or meaningless. An example can be seen in the following superfluous paragraph:
After completion of a loop, control is always left at the syntactically next statement.…That is, each iteration construct is treated as a single statement within the (default) sequential organization of the language. After completion of an integral number of iterations, control is always left at the (syntactically) following statement.…The loop can be treated as a single (powerful) statement. As with the conditional statements, iteration constructs can be viewed globally as single statements and simultaneously as locally control statements. (p. 16)
I was excited by the title but found myself disillusioned by the book’s problems.
