Well, a lot of Pooh Sticks have passed under the bridge since then. I can hardly believe it, but this little scamp — The Design Warrior's Guide to FPGAs (Devices, Tools, and Flows) — finally rolled off the printing presses and arrived in the warehouses just a few short days ago.

I have a copy in front of me as I speak, and I keep on opening it to random pages just to bask in the glow of how well it came out. Truth to tell, the end result is just about as good as I could have wished for, not the least that the publisher — Newnes — created an ultra-cool cover featuring a samurai warrior that is way better that anything I expected.

So what's it all about?

Well I'm glad you asked, because — as with my previous books — this one leaps from topic to topic with the agility of a mountain goat! One thing I hate is rooting through a shelf full of books and still not finding the fact I was looking for, so I try to squeeze every last tidbit of info I can into my tomes.

Another thing that really annoys me is being presented with techno-weenie books that assume I already have a black-belt in their subject, so they kick things off at a level that would bring a gaggle of professors to their knees. For my part, I prefer to start off by explaining the fundamentals and building from there (call me foolish if you will, but there we are).

Any yet one more thing that disgruntles me to the extreme is the fact that the majority of technical books are so mind-numbingly boring (did I miss a memo dictating that this should be so?). Truth to tell, I rarely read any manuscripts of a technical nature anymore, because they make my brains want to leak out of my ears in a desperate attempt to relieve the tedium. So I tend to festoon my works with tidbits of trivia, such as why we do things "this way" rather than "that way," and where things came from, and who did what to whom (and why).

In addition to all of the above, I aimed this book at a wide-ranging audience; from the folks in technical sales and marketing, to editors and analysts, to students, to ASIC engineers who are moving into FPGA space, to "black-belt" FPGA engineers who need to keep abreast of the latest developments in the FPGA arena.

To cut a long story short, the first section of the book focuses on the fundamentals, such as what exactly are FPGAs, where they came from, and why they are of interest. We also look at the various underlying flavors of FPGAs such as antifuse versus SRAM-based versus flash devices, including their associated programming, security, and process technology-related issues.

Next we consider various architectural concepts, such as multiplexer versus lookup table (LUT) implementations, and using hard and soft embedded microprocessor cores. And of course one thing we tackle head on is the concept of what FPGA folks actually mean by the term "system gates" (don't ask; the truth will make you cry).

One point worth noting is that this book does not focus on particular FPGA vendors or specific devices, because new features and chip types are appearing as we speak. Similarly, this tome does not focus on particular EDA vendors or tools, because such companies and applications are in a constant state of transmogrification. Instead, there is a "Who are all the players?" chapter that introduces who does what and gives their web addresses. When we actually come to consider different design tools and flows, the book primarily focuses on concepts (the chief proponents of various tool types and methodologies are mentioned in footnotes).

Speaking of design flows, we start off by considering differences between ASIC and FPGA design styles. Then there are a whole raft of chapters covering schematic-based flows (still used in the case of legacy designs, for example), HDL-based flows, silicon virtual prototype (SVP)-based flows, different incarnations of C/C++ (including SystemC)-based flows, DSP-based flows, embedded processor based-flows, and the list goes on.

But wait, because we're only half way through the book! Next we plunge into a plethora of topics ranging from modular and incremental design, to virtual logic analyzers and virtual wires, to high-speed design and other PCB considerations, to migrating ASIC designs to FPGAs and vice versa.

In addition to fighting our way through the morass of languages (Verilog, VHDL, SystemVerilog, SuperLog, SystemC, Sugar, PSL), we also introduce the core tools and consider how they perform their magic, from simulation to synthesis to formal verification.

And still there's more, because we hurl ourselves into the realm of gigabit transceiver blocks, the use of independent design tools, creating a design flow based on open source tools, and some of the more esoteric devices like field programmable node arrays (FPNAs).

Good grief! No wonder my brain aches! At the beginning of this project I was bright-eyed and bushy-tailed; towards the middle it felt like wading uphill knee-deep in molasses; and now that the little rapscallion has been let loose on the world and is roaming wild and free, I'm gamboling around with an ear-to-ear grin on my face. So taking everything into consideration, I think it's only fair to give myself a big pat on the back and award myself an official "Cool Beans". Until next time, have a good one!

Clive (Max) Maxfield is president of Techbites Interactive, a marketing consultancy firm specializing in high-tech. Author of Bebop to the Boolean Boogie (An Unconventional Guide to Electronics) and co-author of EDA: Where Electronics Begins, Max was once referred to as a "semiconductor design expert" by someone famous who wasn't prompted, coerced, or remunerated in any way.