Hardware Components Books

This book saved me so much money! It's great, it works and you don't have to be an expert to understand and follow the instructions.

very good reference guide. Each chapter has some bit of information even for an expert.

Excellent book for understanding basic PC hardware. The book is well written and has many useful "hints". I highly recommand this book to anyone who wants a comprehensive book about PC hardware, upgrading and basic repairs.

Great book. Most repair books are just focused on the A+ exam. This one is wonderful for learning or improving your repair skills. It's not an exam cram its a how to book.

I bought this book about a year ago when I was contemplating stretching the life of my 4+ year old PC. The book proved very useful for me to zero in on the biggest bang-for-the-buck upgrades, and which ones were best to avoid because they yield low performance for the dollar.

About a month ago, I decided to build my own PC. This book again proved useful in helping guide me in making decisions on what equipment to choose.

It's rare that I spend over twenty bucks for a book. This book has paid for itself a few times over in helping me save money by not spending unnecessarily, or spending unwisely.

The instructions are written clearly. There are many photographs illustrating the steps being described, sometimes a few different photos of variations of different types of components. There is plenty of "theory of operation" on how various components work and how different standards compare (IDE vs SATA, for example). There are specific brand recommendations. There are specific techology type of recommendations. And there is just the right amount of humor throughout the book.

You may think this sort of book is only for guy geeks. Well, I'm a woman who's just about to pass the mid-century mark, and I found it to be a valuable reference for building, repairing, and upgrading PCs. You can pay the Geek squad lots of money to fix your stuff, or you can pay a bit over $20 and learn how to fix it yourself. That's a great feeling.

Extending the hand dealt to you by the development package is where the quality programmers are separated from the mere developers; often the difference between an adequate product and a great one. If you are a developer using Delphi and want to advance to a higher level of production, this book contains the necessary boost. Anyone moving into Delphi component creation will find it essential. From properly choosing components from the Delphi Visual Component Library (VCL) to building your own components and interfacing with OLE and COM, most of the major topics are covered in detail, with sections of example code to really drive the message home.
The book starts off with a brief explanation of the models used in Delphi, basic concepts of a component, and the analysis and design of new components. This is followed up by an examination of Implementation Details, the fundamentals of polymorphism, virtual methods, exceptions, RunTime Type Information (RTTI), streaming, messaging, OLE and COM interfaces, and optimization techniques. "Design Time Support Tools," opens with an overview of the Integrated Development Environment (IDE) and emphasizes the interface issues. Danny Thorpe wraps it all up with chapters on property and component editors, and experts and add-in tools.
This book contains many insightful points. The chapter on virtual methods and polymorphism contains the best explanation of the implementation details of virtual methods that I have ever seen. This chapter could serve as a reference in any study of object-oriented programming. I've incorporated many of these points into my own training course. As one whose main approach to OOP has been via C++, I found this material invaluable when teaching a course in advanced Delphi recently. The clear descriptions of the underlying implementation distinctions between virtual and dynamic methods may save you in the area of performance. Knowing and understanding why virtual methods will defeat the smart linking of the Delphi compiler/linker can reduce the size of your EXE.
When I am presenting exceptions and exception handling to experienced programmers, they always ask the following question: "What is the real difference between this and how we have traditionally handled errors?" In only a few pages, the author answers this question and puts forward two lists, "Rules of Thumb for Implementing Exception Handlers" and "Rules of Thumb for Raising Exceptions"; solid advice for both developers and educators who develop developers.
Optimizing code when there is "abundant" stack space (surely a hint of heaven!), multiple threads and different system-defined string types differ from traditional tricks. These topics are all covered in the chapter on optimization. Just because this space is available is no reason to misuse it. Knowing that the stack will never shrink over the lifetime of the thread should force you to rethink overuse. Understanding that long strings are allocated on the heap rather than the stack should cause an occasional re-examination of approach. It is also gratifying to see that there is also a short section on sledgehammer techniques, or put another way, "genuinely useful hacks."
There is also an occasional sweet sprinkle of humor. From polymetamorphicdata (care to guess what that is?) to TypInfo ("tip info") and GUID ("gwid") the jokes are appropriate and blend well into the message. However, they are grains of seasoning rather than the bulk of the flavor.
Delphi is a development environment that provides the opportunity to do many things quickly and efficiently. Add in a copy of this book and you are ready to harness the true power of Delphi by creating your own components and pushing things to the leading edge of software creation. Some sections can be read and appreciated just for their insights into object-oriented programming and design.

Published in Journal of Object-Oriented Programming, reprinted with permission.

This guys are crooks. They advertise a book they DO NOT have, get your money and never reply to your e-mails.

The book is supposed to be great, by the way.

This is purely a Delphi programmer's guide, but it unquestioningly well written, informative, and well-rounded: Anyone seeking to learn how Delphi's VCL component libraries work, how to development components of their own, or how to extend Delphi VCL components already available from Borland or third parties, should read this book. There is simply nothing else that comes close.

Mr. Thorpe's writing style is clear, concise, and does a great job of exploring the topic at hand. Any competent Delphi programmer will be well capable of undertaking VCL development on their own if they have this book at their side. One point to note about this book is what used copies go-for on Amazon.com (and elswehere): I typically see prices of between $50 and $100, even though the book was first published about 10 years ago. How many other technology books, particularly for a specific software technology, remain in such high demand after such a long period of time?

"Delphi Component Design" was written for the VCL [Borland's Acronym for "Visual Component Library"] as it was implemented in Delphi 3.0 - back in the mid to late 1990's: the implementation of VCL it describes is still the foundation underlying VCL as implemented in Delphi today, and is close enough to the modern implementation to still be a very useful text. However, since Delphi's product direction is to pursue .NET as opposed to enhancing the older VCL, the book's usefulness is limited to those who are seeking to maintain or enhance existing Delphi VCL-based applications. Even though I no longer work in Delphi, I still find myself called-upon often enough for Delphi support that I'm not going to give up my copy of "Delphi Component Design" quite yet - even despite the used copy prices I see!

The book is a breath of fresh air and covers a good basic foundation: attitudes of programmers, basic structures of OOP with objects:- various virtual methods, basic construction of building blocks, streams, other forms of communication and a few peculiar things to watch out on. I personally have no interest in databases were some may have. 32 bit is the way to go as I can now see access to the windows API with the assistance of the book and Delphi Pro.
Danny points out its not necessary to understand every base object behind the object you are building off from.
This is true if you wish to add a minor adjustment to a component. But this I believe this is a major miss conception if you are building a new and different component. And for this purpose the book dose not begin to address threading, what is happing in TObject, as TObject is not in Delphi Pro to view and is the fundamental object that every object is built from!!!!!!. This is no different than the Pascal 7 days when every one wanted to read the OOP code for them selves at an enormous cost for a copy.
I'm not saying the book should cover the windows API as that's another subject on its own, but how a action is handled through the Objects, or how a windows event is managed though OOP:- draw, mouse button.....
I need a book that should cover enough to be able to install an object into a base object like a speed button into an editor or a listbox connected to a speed button so something like TCombobox or TGraph is understood how each piece interacts and is constructed together as a unit. When the OOPer's get hold of this understanding the tools for Delphi could become available will become limitless to the users. VB definitely has this advantage over Delphi today because we do not understand enough to create something different or new. Give it another go Danny with an extra book, as it is easy to understand what you have written, be cursus to get such a difficult subject right. And you have made a breath of fresh air already into the subject that is very useful to those that have read your first book but some of us need to go further.

This book is all about what goes behind the curtains. If are a crazy developer like me and interested in knowing how Delphi designers implemented different mechanisms such as WIndows messaging OLE COM this title is a must

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!

Independent Component Analysis is a young and interesting topic that gained attention and still receiving more of it.

Until now this is the best introduction that has been written.
It is comprehensive, clear and unbiased.

I think that the book is a step toward making the subject not only a common field of research but also a reference for those looking for new challenging topics.

What worths mentioning is that the authors are very envolved in the development of the theory of ICA ,other books are good but are deviated by their author's own approachs and this is normal but unhealthy for a first book on any field.

What constitutes a great help for understanding ICA are the relatively easy concepts if one just intend to pick an algorithm(ex:FastICA), but this is not the case regarding its theory.

One colleague once argued that ICA should have emerged long before the begining of the 90's, claiming that Gaussian forms
(Central Limit-Theorem) killed the idea of dealing with other kinds of distributions and therefore the signal processing community went assuming every thing was gaussian (noise was gaussian,signals are gaussian),but the emerge of HOS relaxed the gaussian restriction and ICA became possible and no longer 'blind' .

I think this should prepare researchers to deal with coming challengs more intelligently and efficiently .That is why I recommend this book since it tries to give a broad view to the subject .

This is a nice and self-contained book on the subject of independent component analysis (ICA). The authors start with relevant mathematical and statistical background (in Part I) to prepare readers for the derivations of ICA (though seasoned researchers may want to skip the first part of this book). The authors discuss the motivation behind ICA and present several ways to derive ICA (since this subject has been approached by several communities). The authors also compare and discuss the pros and cons of these approaches. The authors discuss several applications using ICA in Part III.

Compared with other ICA books, this manuscript has much depth and completeness. I highly recommend this book to any reader interested in this topic.

A very well written book about Windows programming and object component technology. The authors are very concerned by making you grasp how things are supposed to work when doing Windows programming and the plan they chose to show all aspects of Windows programming is in my opinion very good.

With the book, you have a CD with all the examples they refer to. The examples are very well done and this definitely plays a major role in understanding all the aspect of Windows programming.

One thing which contribute a lot to the clarity of the book is the usage of the Eiffel language and its Windows Eiffel Library that make you concentrate on the useful part, ie Windows programming.

I definitely recommend the book to all newcomers to Windows programming or people who have some Eiffel experience that wants to do Windows programming. To finish, you don't need to know Eiffel to understand the book and this is definitely a plus.

This book is exceptionally well written and presents both novice and expert topics using an example driven approach that stimulates and motivates the reader. Both authors stress the most important lessons to learn in each chapter clearly and the reader comes away with expert experiences that other books just do not capture. The examples are in Eiffel which is another bonus as not only do you learn Windows development principles, but you also gain an indepth understanding of object-oriented principles that are lacking in many other languages. Eiffel is not a prerequisite at all as I had not even heard of the language before reading the book, and I would definitely recommend the book to those wanting to discover an experts opinion on Windows programming with the added benefit of learning object-oriented principles at the same time.

This is a software package where everything comes on a single CD. It is NOT a hardcover book.

VHDL (Very High Speed Integrated Circuit Hardware Description Language) has been a standard PC based tool since the mid-1990s. Originally designed as a way to document ASIC designs (by the Dept. of Defense), it has evolved into a means for simulating such devices. It is a subset variant of the Ada programming language and has some programming requirements that require specialized training. Visual tools, such as the ones in this package, use diagrams and schematics to run the simulations and can create the code for the engineer.

VHDL is a boon in today's multi-vendor environment. When working to a standard, it becomes much more efficient for companies to work together and over time. This package includes a block diagram editor, code2graphics, HDL editor, the ability to convert schematic designs to vendor independent HDL, source revision control interface, and state machine designs.

It also has tutorials for VHDL and Verilog, an overview, and trainings for various tools.

A good student package to get a solid understanding of this important industry standard. This implementation will get the student prepared for working with the key elements of VHDL so that learning new tools will be much easier.

I want to explore the processor archeticture and instruction set

Thompson is an expert in the field. I stumbled upon his work a couple years ago in a fairly short Discover magazine article and pursued his website to read his other papers. This work is really interesting and is pioneering a new generation of evolution on a medium other than flesh. Thompson is a professor at the COGS school of Cognitive Sciences at Sussex University at Brighton. Another expert in this field is Inman Harvey. If you are interested in research in this field - buy the book, but if you are just curious to read bits of his papers and get a grasp of what all this is about see Thompson's personal website - http://www.cogs.susx.ac.uk/users/adrianth/ade.html -Good book, worth the research book bucks if it's a career/research step

This book took me from a 20 year maintenance background, with only minimal exposure to automation controls, to a solid basic understanding of the concepts, and applications of this field. In places it was a bit tough reading, but all the information seemed to be there for the reader, and none of it went completely over my head. Someone who hasn't been exposed to various industrial processes may have a tough time with some of the application examples, but I have been fortunate to see many different proccesses in my field of work. (crane repair)I ecspecially liked the introduction to computer oriented number sytems (binary,octal,hexadecimal) and was able to commit these to memory with little effort. I havn't selected a follow up of this beginners text yet, so I cant tell you how it will dovetail into my continuing education, but it has given me the ability to read manufacturers specifications, and make intelligent decisions on theoretical applications. I suspect that the knowledge I've gained from this publication will serve me for quite some time, and will likely be used for refference on occasion.

Over 30% of today's designs implements embedded memories and continuously consumes more and more die area. While embedded memory presents significant system performance and cost reduction advantages, it brings its own testing issues. Test vector style tests are not suitable for verifying embedded memory arrays because it is too costly. This is because the time spent in the manufacturing tester grows exponentially as the embedded memory die area increases. Sometimes it is impossible to create a set of vectors that can detect all possible types of memory defect.

Implementing embedded memory built in self-test (BIST) can alleviate these problems. In simplistic terms, memory BIST is an on-chip utility that enables the execution of a proven set of algorithmic style verification tests directly on the memory array. These tests can be executed at the design's full operating frequency to prove the memory array operations and identify errors caused by silicon defects.

Embedded memories are the most dense components within a system-on-chip (SOC), accounting for up to 90% of its real estate.1 Memories also are the most sensitive to process defects, making it essential to thoroughly test them in the SOCs.

Because memories are used as test vehicles for monitoring the silicon process and improving its yield, extracting additional diagnostic data to determine the causes of failures now is required in the testing strategy. In addition to diagnosis, many embedded memories are designed with built-in redundancy, which provides spare rows and columns that can replace failing locations. Redundancy enables the manufacturer to repair a number of otherwise defective devices to ensure maximum production yield.
Characteristics of today's SOC designs include the following:

1. Typically more than 30 embedded memories on a chip.
2. Memories scattered around the device rather than concentrated in one location.
3. Different types and sizes of memories.
4. Memories doubly embedded inside embedded cores.
5. Test access to these memories from only a few chip I/O pins.

A deep-submicron test strategy will have to handle all of these memory issues.
These issues are being addressed by the use of built-in self-test (BIST). BIST is the methodology of choice for testing embedded memories within SOCs. It offers a simple and low-cost means to test for failures of embedded memories without significantly impacting device performance.

While it has been used primarily for production pass/fail testing, BIST can be extended to provide the diagnostic data required for process monitoring and repair. Although the area overhead required by the BIST circuitry is increased, designing the diagnostic circuitry into the BIST provides many advantages in terms of time for both setup and test.

This book will take you intensively through all the memory BIST algorithms and ways to test them. I consider this as the bible for mbist testing.