Embedded Books

Have some kleenex handy. A very well written book. My husband loved it, too.

As an amputee for the past 4 years or so, I know a few things about the story told by this book. But I was unprepared to be as moved as I was. Michael not only tells the story of how, but he digs deeper into the demons that made him and Pete so much more real.

I don't have war experience, I just had a simple accident. The demons these men fight to get to a place where they can accept the things that happened make this a very powerful story. I highly recommend it to anyone. And I've recommended it to several close friends in hopes they might better understand what it's like to loose part of yourself.

Mr. Weisskopf writes a truely remarkable account of what it is like to go from the battle field through the medical, recovery process. As a surgical technician & Vietnam vet I found his story to be inspiring and very moving. The medical aspects were right on the money!!
Thank you, Mr. Weisskopf, for a wonderfully touching story. I hope you have been able to put to rest the "Why & What If" questions. As far as I'm concerned the motivation doesn't matter. You're a HERO!!!

Michael Weisskopf is a well known journalist for TIME magazine. During a trip to Iraq as an embedded journalist with an Army unit, the HMMWV he was riding in had a grenade thrown into it. Weisskopf apparently went to pick the grenade up before it detonated, but was too late, losing his right hand in the explosion.

Weisskopf uses this tragedy to document his and a several soldiers with amputations in their roads to recovery at Walter Reed Army Medical Center's Ward 57, the amputee ward. Weisskopf does a good job of capturing the many aspects of recovery that he and the soldiers go through.

This short book captures very well the processes of recovering from combat wounds, dealing with the traumas both to yourself and those around you, including fellow soldiers who did not survive their accidents.

I highly recommend this book.

What Michael Weisskopf has done with this story is truly amazing. It was a very emotional book for me, but it is a book that every American should read.I plan on passing this book around. It is a book that you cannot put down.You just want to cheer these guys on, cry with them, and you feel their frustrations. I would love to meet Michael and the men that he writes about to thank them personally for their sacrifices.
I am a Troop Greeter from Maine where most of the flights that are going over and comming home stop for re-fueling.We are soon to have welcomed 500,000 troops. I often wonder how many that I have met that will not be returning home or have been injured. I say a prayer for them after every flight and pray that they will be comming back through our halls.
I can't thank Michael Weisskopf enough for writing this book. It is truly an excellent book.
cakelady2@adelphia.net

I bought this book because I started thinking of building a cluster in my basement just to experiment with parallel programming. Over the past few weeks reading and rereading sections of the book I've developed the confidence to get started. This won't be the only book I'll need. The author is very clear and unapologetic about that. I still need a good book on Linux and programming with MPI. I don't know everything I'll need to know, but I know far more about what I DON'T know and what other work I need to do.

All in all an excellent and very readable overview.

This book provides an exhaustive step-by-step examination of all of the elements that need to be considered for architecting a Linux cluster. The coverage is application neutral: High Performance Computing (HPC), Web load-balancing clusters, Enterprise computing centers; no matter. The details common to all clusters are thoroughly discussed.
As a Linux cluster developer of 7 years, I was able to expand and improve my own design processes to better cover all of the issues necessary to architect my designs. I heartily recommended this book to anyone designing a cluster of any size.

* a little bit too chatty (e.g. on page 162 he starts lecturing you about the meaning of 'freedom' after using the book's and your minds real estate telling you on page 36 about disposing of packaging hardware, ... @@, ;-))
* still using RH for 'serious' Linux work?
* pg 172, statement about Debian not supporting AMD "as of this writing" (?!) Could have just included the sentence. "check as of your reading of the book"
* no mention of transmeta's technological hardware advances (company itself may very soon go south) but their 'ideas' are really promising (for servers with very low power comsumption)
* pg 209, problems with RAID and root filesystem and things. You could just run Debian from a Live CD and leave all writable RAID disks along

The book describes in simple reproducable steps how to build a medium to medium big sized cluster. It also devides the clusters into the three main types,

HPC *High performance computing,
High Throughput and
High Availability cluster

and describes their usages. The book is describing cluster projects more from a bird view and gives a whole sight overview including budget calculations, comparing several architectures also by their technology and environmental conditions (Power usage, Cooling requirements etc.).

The book is not only hard to beat but also the perfect companion to the Linux Enterprise Cluster from Karl Kopper. While Karls book is a bit more practical it concentrates only on the technical configuration of "small" clusters.

Here is where Lubke comes in and extends that knowledge by the many environmental factors *Budget, technical considerations, Calculations, Estimates, Planning what to expect from your hardware *Performance, Weight, Heat, Flooring considerations etc.

After you read the book, you will have learned all necessary steps to build your own clusters. The "only" thing left to you is to put the ship to water ;-)

An incredible book and a real eye opener !!

This book is a very straightforward, clearly written and valuable introduction to Linux clustering. Geared toward system folks, it also provides numerous `on-ramps' into the basics of clustering to accommodate quick, relevant review of supporting technology for the reader. It is essentially a map for getting from start to finish in any Linux cluster project. Specific situations, conditions, and expectations differ across projects, of course, and such points are identified well in the text with pointers to additional information provided.

Scientific computing (HPC) is addressed well, and is more of the topic than any other cluster flavor, though the others are discussed as well (after all, who wouldn't want a side order of high availability with their HPC?). My cluster background personally was mostly high availability (Microsoft Wolfpack), so I appreciated the HPC overview, especially since I was already building a Linux cluster for my bio-algorithms that depended on HPC. This book helped me get every gflop out of my admittedly 2ndhand student hardware.

If you are getting involved with a cluster project or have one potentially on the horizon, and need a clear overview of what may lay ahead, pick up this book. For its measly sticker price, you get two solid discussion weeks with an expert. Go calculate that one:)
5 stars

I confirm all that has been said.

It is the first source I have found that explains building the linux kernel in a way that makes it easy to understand. While you might be able to find this information on the net, this makes it easy to get an overall view of what is going on.

It is easy to read, and has great references. Well worth the price.

This book is very well organized, and provides a good level of detail of the topic. I do recommend it.

I am an experienced embedded developer that just inherited an embedded Linux-based project already in progress. As there happens to be no one else at my company with any embedded Linux experience, I automatically became the de-facto Linux expert and I needed to come up to speed on a lot of topics very quickly. I found this book to be an excellent survey of the must-know topics for the embedded Linux developer. It also contains many references to the most definitive sources of information on the various topics. Highly recommended for coming up to speed on embedded Linux.

For those engineers who start their first embedded Linux project, this book is a must have. The book is not for those who want to understand how kernel runs but it gives you the most important concept and work flow to bring up the OS on your development board. The author also provides a useful further reading list in case you want to dig more. A very practical and clearly written book and I would recommend it to those who have solid experience in embedded development but just start to explore in Linux.

This book, the CALAO SYSTEM USB-A9260 card, an eeePC and a cross over cable is all that you need to study embedded system everywhere (even along the Seine river in Paris - yes I did it !).
The chapters about the U-BOOT bootloader, the BUSYBOX embeded Linux and an extra piece of information on the JFFS2 file system are welcome. If the cross-development environment chapter had been about BUILDROOT, this book would have been THE BOOK for the present embedded Linux based systems designers.

As a relative beginner to the world of embedded systems I was very pleased with the readability and accessibility of this book. From coding examples provided in so many languages, anyone with coding experience can find one they identify with, to real world usage examples that make sense. This book is a great place to start for anyone looking for information on how to use, integrate, or program for, the Rabbit processor. It's also a great place to start for anyone looking for information about how embedded processors can be used.

It's extremely rare for me to find a technical book that is as captivating as this one. I'm truly shocked at how well written it is and how inspiring the words are. I literally can't put this book down. Strongly recommended.

The book has been written by people with a lot of experience in the industry.... in various sections, it goes beyond just building hardware or writing code and offers practical advice that one gains only after a couple of decades in the industry.

Although the title may lead the reader to think the book is focused only on the Rabbit microprocessor, there is useful and practical advice in there for just about any embedded systems designer.

Excellent reference on all there is to know about the Rabbit 3000. I found the chapters on interrupts and interfacing to the external world especially usefull resources. Overall, the book is well researched and written and enjoyable to read. I wish all technical books were this good.

I have been using Rabbit microprocessors for years. I started out with the Rabbit 2000 and now use the Rabbit 3000. This book addresses a lot of the problems I came across while developing software and integrating hardware for the Rabbit. I truly appreciate the authors taking the time to put together such a great book. The CD that came with the book includes all of their project's sample code and compiles the first time (unlike other publishers which require modification to compile and run properly). This book is also a great reference and will not collect dust on my bookshelf!

FYI: My last robot was powered by a Rabbit 2000:

http://www.robotdirectory.org/details.cfm?id=194&cat=4

Have fun developing for the Rabbit 3000!

I just bought this book and managed to read through it over a few days. I must say that I'm very impressed by it! The book covers programming the PIC24 in C using MPLAB's C30 C compiler. It covers the PIC24 architecture and peripherals in as much detail as required by a C programmer as well as various non-ANSI C PIC24 specific addons available in the C30 compiler. It also includes a myriad of cool interfacing projects with minimal additional hardware (SPI EEPROM , 3 resistors for the video example flash card, PS2 interfacing e.t.c.) Finally it also introduces all the debugging tools available in MPLAB such as the simulator/logic analyzer and stimulus generator. This book is not for the absolute microcontroller / programming in C beginner however. Its target audience is embedded systems programmers considering to switch to Microchip's PIC24 family and EE students/hobbyists with some background in embedded systems/ microcontrollers / C programming.

This book pretends to be a programming book on the PIC24 16-bit microcontroller family from Microchip. And if it were only that, it would easily earn a 5 rating. But the author has gone way beyond his calling. He turned this into a real insider's view of what gcc is doing under the covers with this MCU. This is better than good because there are so few good books on embedded C programming, and none of them do a good job of showing both sides. As a C programmer you normally don't care what the computer is doing under the covers. But as an embedded C programmer this is critical information! So I'd like to give this book a 10: 5 for PIC24 coverage and 5 for under-the-cover info on what gcc is doing. Even if you don't use the PIC 24, you need this book!

I already had a problem to solve in my mind when I statred to read this book. The book worked out for me in two ways: First, the topics of the book cover my problems very well, and secondly the code in the book worked well as I tested them project by project as a learning process. Also, I agree with the points other reviewers made before my review. So, no need to repeat them. I am not an EE and new to microcontroller. To understand a topic of the book I still need to cross-check some sections in the data sheet of a PIC24 and its corresponding C header file. This slows down my reading, but turns out to give me a better understanding. I completely recommend this book.

David W. at Ferndale, MI, USA

I've bought several books on microcontrollers, and most of them have been poorly written. This book is exceptional: the writing is clear, it has been professionally edited, and the audience focus is clearly stated. It contains a lot of valuable background that only someone who works at Microchip would know.

I have to take off a star because the book does not mention the numerous hardware problems these microcontrollers have. All microprocessors have some issues, but the errata for PIC24F parts is unusually lengthy. Jasio neatly sidesteps the hardware minefields, for example by using an SPI communication protocol rather than the more elegant I2C. Don't get me wrong: I'm a big fan of these parts, and I think everyone who designs with microprocessors should look at them seriously. Still, I can't believe that someone could write a book like this and not mention the errata.

I have thouroughly enjoyed reading and using this great publication. It is absolutely the best introduction to PIC24 in particular and C30 as well. This book makes a great companion for the Explorer 16 development board from Microchip.
I look forward to a follow up edition with a few more projects and peripheral code segments.

Very Well Done Lucio

Helped me in my undergrad (older version). Helped me when I gave subject GRE recently. Covered Pipelining superscalar, out-of-order execution processors, caching and secondary storage, combinational and sequential ckt review etc real well. No computer architecture book covered them all so clearly, and in one book.

A clearly written book, which employs a simple language. Another beauty of the book is that all loose ends are tied up. As sentences unfold one will realize why a particular phrase was used earlier and so on. That makes a big difference for an engineering text book.

It is the best book that I know for fundamentals. Hence, it will be useful for years to come.

Must have for all embedded systems people.

This was the assigned text for my junior year computer engineering course on computer organization. I loved it. The explanations are clear, progress logically, and are clearly presented. I find myself picking it up from time to time, both to read the more advanced chapters out of personal interest and to look up details needed in more advanced coursework.

After reading this book do not believe you'll know everyting about computing , but you'll know more than others do.

I had a chance to recommend this to a colleague just last week. It is easily twice the price of the "competing" books on the market, but you get what you pay for. With this book plus (perhaps) a hands-on course in the microprocessor laboratory--interfacing various logic families to output devices, e.g., or whipping up a robot of limited capabilities--the student gains the ultimate understanding of what makes computer systems "tick," from the loftiest levels of software, through the details of instruction set implementation (microprogrammed control, prefetching, cycle-stealing DMA transfers) and even the detailed digital logic circuits that underlie the CPU.

I dare say the student who aces this course is all but prepared to build a simplistic CPU on his own--"simplistic" because, though the concepts can be understood quite completely, it's an intricate challenge. Notably, the book has kept pace with the times: while the PDP-11 instruction set is didactically wonderful--clear and easy and even sporting reasonable opcode mnemonics--you don't see lots of PDP or LSI (or, for that matter, VAX) minis floating around nowadays. So, HV&Z moved on to the 68000, the Power PC, perhaps even the Pentium in the latest (of five or six) editions. (Good move, gentlemen: you've actually done your homework rather than just changing "happy" to "glad" and reprinting with a new version number!)

I used this book as a junior, but (a) I went to Cooper Union, which operates at an extremely high intellectual level [let's put it this way: I took a number of graduate-level computer science electives--compilers, OS, etc.--taught by Bell Labs MTSs as a junior and senior; and some "doctoral" courses that I took at Case were--honest Injun--watered-down versions of similar courses I had taken at Cooper], and (b) I graduated more than twenty years ago, and requirements always creep downward: a few credits fewer, a few tangential courses eliminated, perhaps one fewer humanities elective necessary to matriculate, etc. By 2006 standards, I would reluctantly have to reclassify HV&Z as a postgraduate text.

(A little puzzle for the reader: we had to build--from NAND gates--a microcomputer featuring two three-bit registers, and my squad was the only one that implemented an "exchange registers" function that required only one cycle and used no auxiliary storage registers. How did we do it? Tick ... tick ... tick ... time's up! The circuitry compared corresponding bits from both registers. If they matched, it did nothing; if they differed, it flipped both! So, there was no literal "exchange" operation: rather, each was simultaneously reset to the value of the other.)

That's an exciting and useful book in all synthesis manner: almost no gate-level circuits inside, as in modern EDA tools it don't need to.

A lot of algorithms (eg. log, sin, sqr...) which is beyond fast adders or one-cycle multipliers that can be easily found in many DSP hardware books. In fact, we make and sells a DSP state-machine chips in almost a million pcs that certain arithmetic circuit blocks is inspired by the book.

This book is quite original in its presentation. The selection of implementations is of interest.
The theoretical foundations are sound and presented in a well organized way.
The applications cope with the actual technology: especially in what concerns programmable devices.
It is a good book for advanced students and a must have tool for the professional designer.

The presentation of arithmetic theory and applications is innovative. Some of the topics are inedited; they present new approaches for both algorithmic and implementation aspects. It is a very interesting reference book for what refer to computer arithmetic in general and special purpose arithmetic circuit in particular.

In the part dedicated to general algorithms, very interesting new presentations or generalizations, made this work attractive at the theoretical point of view. Extensions of booth algorithms and generalizations to base B operation make the work innovative at the mathematical point of view. At the implementation level there is very good and innovative ideas towards special applications in FPGA (mainly Xilinx oriented). It would have been desirable to cope with some other technology, but the book may be considered self containing anyway.

There's a lot to like here. It goes over all the low-level stuff you could hope for, including creative number system, carry-lookahead, Booth encodings, and SRT division. It addresses some of the needs of crypto people, with discussion of finite-field arithmetic. It even gives enough intro to residue number systems for the desperate developer to gain a toehold - 10,000 digit addition or subtraction can be done in a few-digit time, as long as the expense of getting into and out of RNS are amortized.

That's all good for someone who can't trust their synthesis tools for good carry chains, or for someone headed way into the weirdness. The ranges where I live get distressingly little attention. If you need a dot product of two vectors, this will do a great job on the multiply and add steps as long as you can work out all the pipelining implications for yourself, but those were never the problem - it's the parallelism (how many multiplies can you run? how deep is your adder tree? or do you have something better?). It's the memory bottleneck (what do you mean you read "a word" from memory? I want 100). It's the numbers that number-crunchers use, i.e. IEEE 754, which get a moment of mention at the beginning and at the end. Those start turning strange with NaNs, signed zeroes, and denorms, then go totally off the rails when things like Intel (not always IEEE) compliance arise from the deep.

This could be a good text for a mid-level practitioner or student, fluent with logic design but blissfully ignorant of numerical analysis. If that's your trajectory, you'll spend some amount of time where this book lives. Then you'll advance, and it will no longer serve you. That's not a criticism, since every level has its own needs, but the prospective buyer should weigh needs to be met against needs that this meets. Not all readers will find a match.

-- wiredweird

Very easy to understand. Mr Liming provides all the tools (or lets you know where they can be procured) that you need. This book fulfilled my needs perfectly where I am developing an embedded processor on a device with flash memory as the boot and disk drive.

This book, along with the online documentation at MSDN will get you up and running with your Windows XP Embedded image. And the book is applicable as a first book also. The author is a very responsive contributor on the MSDN (and, I think, other) web forums. Since the book was written the practice of importing your .pmq file into Component Designer instead of Target Designer has become the preferred practice as the author, himself, has stated in the web forums.

The CD material is now available through the author's website.

I have been asked a few times already about this book and support for XPE SP2. Windows XP Embedded advanced is still a good starting point for those getting started with XP Embedded SP2. All the XPe development basics are in this book, and the steps are good for SP1 and SP2. There is a new toolkit (Windows XP Embedded Supplemental Toolkit) available that covers the new SP2 features and other topics such as EWF API .NET programming, USB Flash boot, security, HORM, etc. There are a few new tools that also help with development. See my websites for more information: www.seanliming.com or www.sjjmicro.com

Sean Liming

I purchased this book after spending days trying to find information about Embedded XP on the web, before reading this book I was struggling to get a working XPe image. The book arrived and by the next day I had the image booting and running.

If you need to create images as I did that run on Flash memory then this book is a requirement. Everything is explained in a detailed way and the common error message section has saved me hours of work trying to find out what is wrong.

Great Book

Having been a programmer for 20 years or so, I have a solid background regarding computers, and computing systems. However when faced with using XPe, it was a matter of learning the development studio and tools ASAP. This book did just that. Within 6 hours of recieving the book, I had my first XPe OS in the target system running. This book is a "hands-on" adventure that reads well; it's not too simple that it doesn't get you where you need to be, yet not so techi intense that it puts your to sleep. My complements to Mr. Liming on a job well done!

Very Long Instruction Word (VLIW) architectures are efficient because they replace costly and power-consuming consuming hardware for detecting and scheduling Instruction-Level Parallelism (ILP); with that functionality supplied by a smart compiler. Furthermore, such smart VLIW compilers and architectures can achieve levels of ILP and power efficiency many times that from hardware schedulers alone. Fisher, Faraboschi and Young's book explains -- skillfully covering software, hardware, theory, application, and business factors -- how such architectures can enable enormous increases in the capabilities of embedded systems.

It's a fabulous read, engagingly styled, with generous research and practical perspective, authoritative with Fisher being responsible for this paradigm of simultaneously engineering the compiler and processor.

Practicing engineers -- both chip architects and embedded system designers -- will find the techniques they will need to use and develop VLIW-based systems. Instructors will value the rare juxtaposition of advanced technology with practical deployment examples, and students will enjoy the unusually engaging and mind-expanding chapter exercises.

That reader has a pretty strong idea, already, of how computers and compilers work, and is ready for a different kind of view. There are a few valuable differences here, compared to most discussions. The first is its emphasis on embedded systems. Loosely speaking, that's any computer that doesn't look like a computer: anti-lock brakes, iPods, microwave ovens, or the processor[s] internal to disk drives. Ignoring the tiny fraction with keyboards and screens, that's pretty much all of computing. The second distinctive feature of this book's viewpoint is it emphasis on the computer as a whole, including cooperating SoC components, operating systems and such, power management, and the instruction set processor itself. Programmers from the Windows/Unix world may be startled by the idea that the instruction set and processor data paths are variables, adjustable to the task at hand. The book's emphasis on close system integration follows the consequences of custom instruction sets out through the simulators, linkers, and compilers that put the processor to work. The authors offer wide-ranging and hard-won insight into optimization techniques, giving glimpses at the scars these project-hardened veterans have picked up along the way.

The book's most distinctive feature, however, is its emphasis on Very Long Instruction Word (VLIW) processors. These come in many flavors. One classic structure comes from TI's DSPs with 8 ALUs controlled in every cycle; standard superscalar and Intel's EPIC are also noted, for contrast and variety. The book is thick (over 600pp) and dense, so no summary can do it justice and still fit here.

The book's personal note is part of its charm. The authors aren't afraid to take on widespread opinoins in their "Flame" sidebars. One in particular struck home for me: the polite diatribe against "smart" assemblers that hide the machine from the people who really need to see it. Amen, brother! My worst experience of that sort was in the 90s-era TI C5x family. It had delayed branches, with two words in the delay slot. You could put either two one-word instructions or one two-word instruction into that slot. After annoyance that you can imagine, I discovered that the compiler was putting a one-word instruction in the branch shadow followed by a two-word instruction. It was executing one and a half instructions in the branch delay, with un-helpful effect. That second instruction was the one the assembler was "helping" with. If the immediate operand had been smaller, it would have been a one-word instruction and would have been fine. The immediate value was too big, though, so the assembler converted that same opcode into a different two-word machine instruction with a larger immediate field - kaboom!

It's a good survey and a good introduction for people who want a wider view of what computing is about. Given the rise of reconfigurable computing, it's also helpful in putting readers in the frame of mind needed for defining their own computers as a matter of course. The breadth of coverage means that, despite the book's mass, its coverage of some topics lacks depth. I can't really fault the authors, though, since there's so much to say and since different readers have such different needs. The depth is there, but it's in the exercises and copious references so readers have to dig into it on their own. This isn't a book for every reader, but it's a helpful compendium for people with many kinds of needs a bit away from what computer science usually offers.

//wiredweird

This is the first technical book that inspired me to read it cover-to-cover in many years. It was well-written, and covered a lot of material. I really liked the breadth of material, and enjoyed reading the lessons from personal experiences. Also, the choice of material validates one of the lessons I learned from my graduate advisor, many years ago, that architecture, software, and applications should all be studied together.

There are two ways to learn more about your country: you can study it directly by travelling around in it, or you can study it indirectly by leaving it. The first method yields facts and insights directly in-context, and the second by contrast.

Our tradition in computer engineering has been to seldom leave our neighborhood. If you want to learn about operating systems, you read an OS book; for multiprocessor systems, you get a book that maps out the MP space.

The book you are holding in your hands can serve admirably in that direct sense. If the technology you are working on is associated with VLIWs or "embedded computing", then clearly it is imperative that you read this book.

But what pleasantly surprised me was how useful this book is, even if one's work is not VLIW-related or has no obvious relationship to embedded computing. I had long felt it was time for Josh Fisher to write his magnum opus on VLIWs, so when I first heard he and his co-authors were working on a book with VLIw in the title, I naturally and enthusiastically assumed this was it. Then I heard the words "embedded computing" were also in the title, and felt considerable uncertainty, having spent most of my professional career in the general-purpose computing arena. I thought embedded computing was interesting, but mostly in the same sense that studying cosmology was interesting: intellectually challenging, but what does it have to do with me?

I should have known better. I don't think Josh Fisher can write boring text. He doesn't know how. (I still consider his "Very Long Instruction Word Architectures and the ELI-512" paper from ISCA-10 to be the finest conference publication I have ever read.) And he seems to have either found like-minded co-authors in Faraboschi and Young, or he taught them well, because Embedded Computing: A VLIW Approach is enthralling in its clarity and exhilarating in its scope. If you are involved in computer system design or programming, you must still read this book, because it will take you to places where the views are spectacular, including those looking over to where you usually live. You don't necessarily have to agree with every point the authors make, but you WILL understand what they are trying to say, and they WILL make you think.

One of the best legacies of the classic Hennessy and Patterson computer architecture textbooks is that the success of their format and style has encouraged more books like theirs. In Embedded Computing: A VLIW Approach, you will find the Pitfalls, Controversies, and occasional Opinion sidebars that made H&P such a joy to read. This kind of technical exposition is like vulcanology done while standing on an active volcano. Look over there, and see molten lava running under a new fissure in the rocks. Feel the heat; it commands your full attention. It's immersive, it's interesting, and it's immediate. If your Vibram soles start melting, it's still worth it. You probably needed new shoes anyway.

I first met Josh when I was a grad student at Carnegie-Mellon in 1982. He spent an hour earnestly describing to me how a sufficiently talented compiler could, in principle, find enough parallelism via a technique he called Trace Scheduling, to keep a really wild looking hardware engine busy. The compiler would speculatively move code all over the place, and then invent more code to fix up what it got wrong. I thought to myself "so THIS is what a lunatic looks like up close. I hope he's not dangerous." Two years later I joined him at Multiflow and learned more in the next five years than I ever have, before or since.

It was an honor to review an early draft of this book, and I was thrilled to be asked to contribute this foreword. As the book makes clear, general-purpose computing has traditionally gotten the glory, while embedded computing quietly keeps our infrastructure running. This is probably just a sign of the immaturity of the general-purpose computing environment (even though we non-embedded types don't like to admit that). With general-purpose computers, people "use the computer" to do something. But with embedded computers, people accomplish some task, blithely and happily unaware that there's a computer involved. Indeed, if they had to be conscious of the computer, their embedded computers would have already failed: antilock brakes and engine controllers, for instance. General-purpose CPUs have a few microarchitecture performance tricks to show their embedded brethren, but the embedded space has much more to teach the general computing folks about the bigger picture: total cost of ownership, who lives in the adjacent neighborhoods, and what they need for all to live harmoniously. This book is a wonderful contribution towards that evolution.

As a former student of Professor James Peckol and having read portions of this book in my spare time, I can assure any prospective students looking for a secondary reference that this is book to get!

This book provides the design processes and methodologies used in the real world (I am now in industry so I can attest to this) with some great examples. If you can take his class this is the next best thing...

I used portions of this text during several embedded systems courses with Dr Peckol and it truly is an excellent resource and tool for an embedded engineer. It is a current, detailed, yet easily understandable look into all the aspects involved with embedded systems. I highly recommend this to anyone interested in this field or actively studying or working with embedded systems as you will no doubt benefit from Dr Peckol's insight.

I have used this text as reference to design and implement numerous embedded systems - from a simple numbers game to a wireless glove guitar.

The materials presented in this book walks you through the entire hardware/software thought process that is applicable to any engineering design. The book stresses the importance of developing a modular high-level design before any implementation - and to consider things such as use cases,extreme cases, scalability, performance, and safety. The book also goes over the importance of documentation - how to properly read and write design specifications/requirements, block diagrams, timing diagrams, etc.

In addition, the book covers the nitty-gritty details of digital implementation - from basic boolean algebra to complex kernel programming. The book also covers debugging/testing processes and common mistakes to avoid in embedded system development - backed with real-life examples. Finally, sample projects included in the book allow the reader to see and implement projects on their own.

The writing style makes the text an easy-read and the numerous diagrams and examples solidifies the concepts presented.

I highly recommend this book to any embedded systems engineer.

This text book is insightful and extremely useful for faculty, graduate students and undergraduates alike in computer sciences. Up to date with much relevant information, presented in a detailed and articulate manner.