Preface:

Fundamentals don't change very often. Intent == book that explains fundamentals
clearly.
If fundamentals are mastered, there is no limit to how high you can soar, if you
have talent and focus.

Why The Book Happened:

EECS 100 at University Of Michigan, happened because Engineering and CompSci
Faculty were dissatisfied with student comprehension of basic concepts like pointer
variables and recursion.

Conventional Wisdom = start with a high level programming language, had

shortcomings. Students didn't 'get it' because they were forced to memorize
technical details without understanding the underpinnings.

This book's approach - memorize only when absolutely necessary. "Information

Hiding" is a bad idea for learning/teaching.

(KEY) *once* you understand what is going on, information hiding is a useful
productivity technique.
(KEY) Top down design works *when* you understand the fundamentaly building blocks.

Major changes in the Third Edition

The LC3
hallmark of book == LC3 ISA - small enough to be described in a few pages, so
mastered in a short time, but rich enough to convey what exactly the essence of an
ISA provides.

the LEA instruction no longer sets condition codes. LEA loads an address into a
register, and for this, the condition codes don't provide any value. (?)

the TRAP instruction no longer stores the link back to the calling program in
R7. Instead PC and PSR are pushed onto the system stack, and popped by the RTI
instruction - renamed RTI = Return from Trap Or Interrupt as the last instruction
in an RTI routine.

TRAP routines now execute in privileged memory, (x0000 to x2FFF). This allows trap
routines to be re-entrant. It does not affect old code, *provided* the starting
address of the Trap Vector Table is in privileged memory and the terminating
instruction of each trap routine is RTI instead of RET.

Appendix A specifies the LC3 completely.

Addition of C++

concern == many language features of C++ are too far abstracted from the underlying
layers to fit our approach.
== C++ is such a vast language that any adequate coverage would require
another 1000 pages.

approach == cover 'common core' of C and C++ in chapters 11 through 19.

in Chapter 20, serves as a transition to the core concepts of C++,
illustrating the what changes were made to boost programmer productivity.
 == specifically, classes in C++ as an evolution from structs in C. We
discuss classes as a compiler construct, how method calls are made, and the notion
of constructors, *touch* upon inheritance.

Other Important Updates

chapter 2:
Expanded coverage of the real floating point data type.
Conversion Of Fractions Between decimal and binary numbers.
DeMorgan's Laws (moved here from chapter 3)

chapter 3:
completely overhauled descriptions of state, latches, flipflops, finite
state machines, example of a danger sign (??)

chapter 4:
better introduction of the LC3, including a different set of
instructions(?)

chapters 8,9, 10 - overhauled for clarity. stacks, queues, character strings

introduced as soon as students have moved out of machine language programming, so
they can use these data structures in their programs, and see how these data
structures are actually organized in memory.
discussion of subroutine implementation moved into chapter 8. Main treatment
left to second half, but this change enables implementing recursion in assembly
language before getting to C.

chapter 9 covers all of I/O in one place, including polling and interrupt
driven IO
coverage af system calls (trap routines invoked by the TRAP instruction) (and
the 'privileged' concept)

chapter 10 - a comprehensive example, a calculator, that requires 12

subroutines, that are laid out in complete detail. + two enabling concepts - stack
arithmetic and ASCII/binary conversion.

chapters 11 through 19: All examples reworked to clarify concepts like

pointers, arrays, recursion, pointers to pointers in C

In chapter 16, additional sections on variable size arrays in C and multi

dimensional arrays.