Customer Reviews

Computers as Components: Principles of Embedded Computing Systems Design (The Morgan Kaufmann Series in Computer Architecture and Design)

5 star:		(1)
4 star:		(0)
3 star:		(1)
2 star:		(1)
1 star:		(0)

 

 

This book was used as a text book at a graduate level class in embedded design at University of St Thomas, Minnesota. I am also a professional embedded engineer (both hardware and software). What this book does the best is to provide a framework for embedded design. There are various examples in the text on the embedded design process via the requirements/specifications/hardware architecture/software architecture/component design/test process.
This has definitely impacted both my understand on a theoretical level as well as my design process at work.
Highly recommended!

I have tried to teach a course on embedded systems using this book. While the effort of the author has to be honoured to cover such a wide range of topics, practically all topics are treated in a rather shallow way, and some information, for instance on UML notation, is wrong. To get an overview, the book is too big; to get into any of the topics in a serious fashion the book is not big enough.

In a field (Embedded Systems Programming) where there are few, if any, good textbooks from which to learn the art, Computers as Components from Wayne Wolf is a good start. However, I do not feel it goes far enough.

This textbook is useful in an undergraduate class, with plenty of accompanying hands-on exercises. Reading the book alone is not enough. The book covers the basic architecture of embedded systems and uses UML throughout for design purposes.

Chapter 2 covers the basic instruction sets of the ARM and SHARC processors. Chapter 3 discusses CPUs. Chapter 4 describes the hardware platform.

Chapter 5 covers Program Design, and Chapter 6 covers Processes and Operating Systems. Although Chapter 5 covers compilation techniques, I, as a practicing professional felt that there was insufficient material to guide the reader in writing code that would be compiled in the most efficient manner. Chapter 5 also covers Performance, Power Consumption, and Testing issues in a rather introductory fashion.

Chapter 6, dealing with Operating Systems, covers Processes, Priorities, Multitasking, and Scheduling, but the coverage is primarily theoretical in nature. Once again, the material is suitable for classroom instruction, with accompanying lab exercises, but is not a useful reference.

In closing, I give the book 3 stars, for I, as a professional, was looking for a suitable reference text to help me on the job.

However, I can see the book getting a 4 star rating for classroom use in an introductory undergraduate course in embedded systems. This book is best used in conjunction with lab exercises in designing and programming embedded systems. I would not recommend this text as a reference for professionals already in the field.