Product Description

This book is based on the premise that starting with a high level programming language is not the best approach. The reason most students are unsuccessful using a programming language when they encounter it in their first course is because, they are forced to memorize a lot of technical details without having any idea why these details are necessary. That is, they do not understand the basic underpinnings of how a computer works. From this basic notion evolves the motivated bottom-up approach found in Patt/Patel's "Introduction To Computing Systems", now in a second edition. The text starts with the logic structures and architecture of a computer and moves up to the application software that runs on it. Every treatment that purports to start at the bottom and work up begins with some abstraction. For Patt/Patel, that abstraction is the switch level behavior of an MOS transistor. From a very short treatment of that abstraction, the book covers in turn: Logic Gates, latches, logic structures (MUX, Decoder, Adder, gated latches), finally culminating in an implementation of memory. From there, the book moves on to the Von Neumann model of execution, then a simple computer (the LC-3), machine language programming, assembly language and how an assembler works, and then assembly language programming of the LC-3. The LC-3 treatment concludes with a substantial treatment of Physical I/O, including both polling and interrupt-driven I/O, the nature of traps and subroutine calls/returns. The book then moves to the high-level language C, covering recursion, pointers, and finally elementary data structures. The book establishes a foundation that every subsequent course in the computer science or computer engineering curriculum can benefit from and build on.

Product Details

• Amazon Sales Rank: #1503740 in Books
• Published on: 1999-08
• Original language: English
• Binding: Paperback
• 518 pages

Customer Reviews

Intro to CS the way it should be done
This book is the implementation of what I have been trying to impart to my beginning students for years. It contains explanations of all of the ideas that make up the foundation of computer science. The first sections deal with the fundamentals of binary data, how numbers are represented, how arithmetic is performed, how the bitwise operations are executed, followed by the basics of digital logic. These ideas are then expanded into a simple assembly code with many control instructions. Staying at the assembly level, I/O operations, subroutines and stacks are demonstrated.
In chapter 11, the transition is made to higher-level languages by the introduction of C. It is then used to illustrate variables, operators, control structures, functions, pointers and arrays; recursion, I/O in C and simple data structures. The explanations are all very well done and the topics are what should be the first set encountered by a computer science major. While the level of abstraction that most programmers work at has dramatically increased over the years, there is still no substitute for being well schooled in the fundamentals. Not only does this make it easier to move up the abstraction ladder, it also makes it possible for a programmer to function at the lower level, should the need arise.
I strongly recommend this book for adoption as a text for a first course in computer science. While it is not designed to fit into the traditional mold of a first semester programming class, it will provide a much stronger foundation for the student taking their first course in CS.

Much improved 2nd edition
Everything that was good about the first edition is still here, and what was not-so-good has been improved--production values (page layout in particular), explanations.... If you're interested in an excellent bottoms-up approach, here it is!

This is what I said about the first edition:
... a good introductory book.

I'm a tech writer with a background in the sciences, and used this book in a "Computers from the bottom up" class. We had an excellent teacher, and without her the obscurities of presentation would have defeated several class members.

On the minus side: From a writer's point of view, what is needed is another editing pass to get rid of poor sentence sequences and poorly explained exercises. Also, it's sometimes difficult to follow examples with illustrations on one page and verbal description on another: production values need to be rethought. From a student's point of view, much of the essential information is buried in small print sections, which make the book frustrating to use.

But-- on the plus side, the book, used with the excellent Power Point slides provided online, is the best thing available for a true bottoms-up approach. It discusses the basic logic components and their relationship to Boolean logic, instruction sets, and programming at a basic level. Personally, I found the LC-2 simulator great fun to use, very helpful to my understanding of "how things work".

Clear, easy-to-understand goodness.
I started out knowing next to nothing about Computer Architecture, and yet I was still able to, by myself, read and understand most everything in this book. The chapters are laid out intelligently, with each one building on what was taught before. The diagrams are clear and helpful, and there are plenty of tables and example problems (very clear, thoroughly worked out examples!) spread throughout.

While there is a chapter or two in the middle that people who already are familiar with C might find tedious, they're pretty clearly marked and easy enough to skim through.

I definitely recommend this book to any beginner wishing to learn about computer architecture.