5 comments about The Best Software Writing I: Selected and Introduced by Joel Spolsky.

1. loved the easy read style, interesting topics, down to earth, quick discussions on numerous software development topics. found this to be both enjoyable and informative and of course opionated.



2. There are a core set of principles about software development that can either be learned from years of making painful mistakes or by learning of the mistakes of others. If you've read Fred Brooks or followed Joel Spolsky's writings, you know what I mean. The writings Joel collects here are diverse and interesting; a must read for anyone looking for clarity on a variety of subjects. This book was better than I expected; and I expected it to be pretty good.



3. There really are some good essays in this book, though a few of them are a little boring, and a lot of them really don't have anything to do with software development.
   
   Joel's ego-driven introductions and blatantly obvious footnotes make me wonder what the intended audience for the book is.



4. This book is less to do with Joel and his own writing, but more to do with the wonderful writing of others.
   
   A well researched and nicely put together collections of interesting historical articles on software development. If you enjoy getting into the thoughts and minds behind some of the greats, then this book is certainly for you.
   
   Put together with brief introductions by Joel, this book takes you on a wonderful journey through wonderful writing.



5. Lot of my friends have already said enough about this book. So, don't hesitate to add this to your cart!

5 comments about VBA Developer's Handbook, 2nd Edition.

1. This book has gotten me out of many scrapes. It is a rare book that can be read from the beginning, while trying out the sample code, as a way to learn the language, or as a reference book, to look up how to use a certain function effectively while writing code. Don't let the title fool you, this book is for those coding in VB just as much as it is for those using VBA. If you are going to buy one book on Visual Basic, let this be the one. If you are going to buy one book on Visual Basic, and see one movie this year, then buy this book and see Amelie. ;)



2. In the introduction the authors state : "To make it possible to stuff as much code into this book, we've had to dispense with material specifically geared for beginners"
   
   I like that - a lot of 'reference' books I've purchased waste many chapters devoted to topics that I would expect to find in 'Inroduction' or 'Beginners' - titled books.
   
   This tome however (all 1073 pages of it!) is totally dedicated to useful code snippets and sound programming principles.
   
   Despite its size I find the book logically structured and very easy to locate the information I need, very quickly - the "Contents at a Glance" page helps immensly.
   
   I'd definitely recommend this book for any VBA developer as an essential resource.



3. This is really the best book i ever found. I have bought several books for Excel VBA. Non of them will explain as detail as this book. Besides, for those people who really interest in VBA, this is really a good book where you can start solve more complex problem.
   
   Non of the books so far i found will teach you how to create data structure using VBA e.g binary tree, linked list, queue and stack thru VBA implementation. it is worth while to keep this book for your future reference...



4. but I wanted to calculate an average cost per day. Obviously the number of days in a month depends on the month.
   
   No problem. Pop in the CD included ... copy ... paste into your VBA Module ...
   
   Locate your spreadsheet's cell ... type "=dhDaysInMonth(Month)" ... done.
   
   If you've written any macros at all or even recorded one ... you will appreciate the amount of work you're buying for a little over thirty bones.
   
   Highly recommended. As page 196 says, 'You'll get better performance (and fewer bugs) by taking advantage of the work that's already been done.'
   
   This book is a bargain.
   
   Mange Takk!



5. I have been a developer ever since VB1 hit the streets, and I have never used a book so much as I do this one. By far the best of it's kind ever.

4 comments about JasperReports: Reporting for Java Developers.

1. There is such a dearth of documentation on JasperReports. This is a very nice explanation on how to use it, there a good set of examples.



2. I was looking for complex examples on crosstab reports but found only basic examples. I wish they had a chapter on Dynamic reports and a section describing the jasper report object model.
   
   Otherwise it is a good introduction into Jasper Reports as it goes through all the features (rather than searching through the jasper report forum).



3. Heffelfinger's book meets all my tests for excellence in technical manuals. First, it addresses a development problem I am having today; and it is the only book on the market - including books and articles published by the vendor - that does so. Other favorable attributes include these: the book is less than 3/4ths of an inch thick, weighs less than a pound; cost less than $50 bucks; and there is more white space than dense text.
   
   Some authors of technical books must think we buy their books in order to better understand and appreciate their verbose writing styles. I did that sort of thing in my literature courses. When I am under the gun to produce bullet-proof code I want the insight and keyboard sequences that get me to user acceptance with the shortest time, and the least grief.
   
   Finally, maybe most important, the book is full of brief, readable, complete, and relevant code. When compiled, the code actually works on my ratty old development machine with a minimum number of obscure error messages. There are many references to needed downloads and sources of information relevant to the topics discussed. The error messages can be resolved with some careful re-reading and re-thinking. Thus do we get through our learning curves. Unlike some technical books, the error messages generated by the code in this one are not black holes where hours of time disappear without ever regurgitating a solution to the problem that caused the error.
   
   My first programming opportunity in college had me using machine language techniques to write a five card inventory program on an IBM 1620 with 4K of magnetic core memory. I followed that up with a couple of years on a Displaywriter. In recent years I've had better equipment, and I've learned how to make Agile XP and use cases a part of my daily life, but youthful and sophisticated users who have grown up with the web want lots of tricky stuff on their pocket-size devices. The problem for old guys like me is that the tricky stuff and the devices themselves were never dreamed of in the late 20th century when I was trying to get my programmer chops, but today's users want the stuff, and they want it now.
   
   So, since I enjoy trying to make this stuff, I have been recently engaged in a massive struggle to figure out how to drag my decades of programming experience with Basic, Visual Basic, MS Access, and client-server architectures into the brave new 21st century world of n-tier, the web, java, open source, and mobile, disconnected data gathering.
   
   On page 25 David H told me, the reader, that I was required to use ANT in order to work the examples in his book. This was not an option. By doing so he has shined a light on the yellow brick road to the geek promised land, and this old geek is now going happily down that road. Five stars for "Jasper Reports for Java Developers."



4. This is a pretty well written book, but it's lacking in two respects:
   
   1) The index is terrible. You literally have to thumb through the book to find what you're looking for. For a technical manual, this is inexcusable and greatly reduces the usability of the book.
   
   2) The examples are far too trivial and it never ups the ante so you can see JasperReport examples that are closer to "real world."

5 comments about MySQL Pocket Reference: SQL Functions and Utilities (Pocket Reference (O'Reilly)).

1. It's handy, but a little old and too brief with important parts left out. It needs to be updated and improved. Ie: The admin commands are poorly covered. Do not use this book to help you use Grant or Revoke. The Grant All section is simply wrong.



2. MySQL has gained a lot of functionality after this book was done, but if you are a infrequent developer and like to have a quick reference into basic MySQL functions this book is great.



3. Reese hits a solid triple to start the inning off and scores easily on the wild pitch thrown by the reader who says that the GRANT section is wrong. This book works easily and appropriately at your deskside. I found the book to be a very simple, easy-to-navigate reference text that presents the most important aspects of MySQL in the quickest, most logical manner. It is very easy to thumb through with every possible random page landing at a topic of interest. In a way, it was like working with a familiar dictionary, you know the kind, where you just kind of naturally crack it open near the word you're accessing and flip a couple of pages either direction to arrive at the exact reference location. In that vein, I'd perhaps recommend that the margins contain "bread crumbs" telling us where we are in the book, but it isn't necessary since thicker sections often obviate themselves with just another page turn. Each page does have the chapter title in the margin, so my point is really one of nit-pickieness rather than a true critique. To its credit, the layout of the book presents the content in a manner that follows the O'Reilly "risen bar" standard. It is easy to scan through the entire reference flipping pages as quickly as possible so that you are able to arrive at your sought information within as much as a second or two. The bold text draws your eye to the page and the size of the page allows one to capture everything in a single glance. In my usage of the book, I found it very accurate and useful. I am a regular MySQL user and the formatting is very familiar to me. I highly recommend this book. If you are already familiar with SQL and the basics of database schema design, this is the perfect reference. I found it amazingly faster than loading the MySQL PDF manual and searching through potentially dozens of hits for the keywords sought. Even at the full cover price, this book is a value-added service at my side. The sections on operators, functions, stored procedures and triggers make this book an invaluable tool for the DBA or programmer who knows the material, but fails to remember every single aspect about the syntax AND who is tired of seeing that familiar: "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near..." The text also finds welcomed complement from the numerous examples of using commands and SQL keywords. They are invaluable for immediately deciphering the sometimes too-numerous options of a command. I don't know that the book has taught me anything new at this point, but it certainly makes finding the details of what I already know much easier. Because of its brevity and its ease-of-use, it has made me want to play around with some of the various features of MySQL that I do not regularly use. That alone is going to teach me something new sooner or later! If your budget is constrained to a single reference item on MySQL, you can't go wrong with this very portable pocket reference. The back cover says: "When you reach a sticking point, but have to get to a solution quickly, MySQL Pocket Reference is the book you need." I agree completely.



4. George Reese's MY SQL POCKET REFERENCE 2ND EDITION covers Version 5.1 and provides SQL statements, functions, and insights into its variations and utilities. Explanations are accompanied by tables and examples for maximum efficiency.



5. I've always liked O'Reilly books, and this is no different. It's a small no-fluff reference that makes for a good read as well. The book is physically small enough to fit unobtrusively in your laptop bag without causing too much of a bulge.
   
   Since it is written as a pocket reference, it of course doesn't have all the commands or even all the variants/options for commands. What is does have are the commands and syntax that you are likely to use the most with some good examples.
   
   Just know what you are and are NOT getting. It's not a bible, a step-by-step, or a cookbook. It is (as it is labeled) a pocket reference, at which it excels. Highly recommended.

5 comments about Murach's ASP.NET 2.0 Web Programming with VB 2005.

1. When I received the book I had a hard time putting it down. It hit the nail right on the head, as to what I was looking for. Detailed information is great, and can be used as a reference also. You don't have to waste time sifting through page after page trying to find what you need. One page has the details and the other is reference!



2. It seems to be just what I was looking for in a training and reference book.



3. I've spent hours and hours on Amazon, on messageboards, sitting on the floor at Borders reading thru every ASP.NET book available, and it seemed none came close to this book for real-world, comprehensive teaching and practice. I have not been dissapointed, as I am almost finished and the book has helped me get up to speed after a long layoff (I last programmed Classic ASP years ago). Each example builds on the previous one to build a completed application. Awesome.



4. I thought it was a good reference book - not one you could read cover to cover. It seemed to jump around a bit more than I liked. It covered most of the need-to-know topics.
   
   I tend to work in the source code window more than the design window, and this book tends to do the latter. It's not a bad thing, it's just different.
   
   All in all, it's a good book, but some of the topics/concepts seem forced into the application you are creating throughout the book.



5. I don't where the other reviews about this book being good for beginners is coming from.
   
   I have solid programming experience in C and Visual Basic 6 and two semesters of Java. I have also 10 years experience with regular HTML.
   I have even worked through all the exercises in Build Your Own ASP.NET 2.0 Web Site Using C# & VB by Cristian Darie and Zak Ruvalcaba.
   
   Thank goodness I had that going for me, because I would have been lost otherwise in chapters 2 and 3.
   
   The example in Chapter 2 should have been about the Order.aspx page which is used in the remaining chapters of the book. Instead the authors go off on a tangent using as an example a different webpage which isn't ever used again later on in the book.
   
   The first 2 or 3 chapters are critical, and I strongly believe that the authors need to SHOW how to go about creating the Design views of Orders.aspx and Cart.aspx pages that they discuss extensively in Chapter 3. They basically just throw the screen captures up thinking that the discussion in Chapter 2 would be useful and helpful. Not!
   They also put up the code for both Product.vb and CartItem.vb without specifically telling the reader which should go where. A no-no for beginners.
   
   I also agree with a previous review which said that the dual-page approach is a great waste of paper because much of the text was redundant.
   
   I am not saying it's a bad book, but it is not as good as it could be.
   It is for people who have some programming and HTML experience.

5 comments about Java How to Program (4th Edition).

1. Most people who purchase Deitel books do so because it is the required course material for their CS (pick a number) class. Deitel book are needlessly saturated with filler material that do not justify their extremely high cost. You could easily save your money and learn Java by going through the Sun tutorials which are FREE, not to mention the countless online Java tutorials out there (just do a Google search "Java Tutorials"). Stay away from this book! If you have to buy it, then please save some money by purchasing a used book.



2. I learned Java solely from this book. I had learned several languages prior to turning to Java. With the help of this book, I was able to become quite proficient very quickly. It has also served as my only needed reference ever since. The intended audience seems to be the novice or even completely new programmer, so the more experienced folks may need to do a little skimming. In any case, I have and will continue to highly recommend this book.



3. You will be able to write Java prgrams, but you will not UNDERSTAND and KNOW object oriented programming language Java. Avoid Deitel's books. They simply do not know Java.



4. This book is simply amazing. I had an incredibly difficult time with the "other" book I used to attempt to learn Java for class. This book absolutely walks all over it. It teaches in a style that I easily grasp. The authors went to great lengths to specify the "why" of each new line of code, and give very detailed explanations of the methodology of programming, along with "good practices" for programming. I recommend this to ANYONE with a desire to learn their first programming language, as well as those who are looking to learn more.



5. You can see examples, the API, methods, etc, etc. Really nice book if you are begginer or advanced

5 comments about Microsoft .NET XML Web Services Step by Step (Step By Step (Microsoft)).

1. I found it to be a very good intro for beginners in XML Web Services like myself. Highly recomended.



2. As the suffix title suggests, this book _does_not_rush_ things; very obviously catered for novice developers, it slowly oozes out information a step at a time. The authors exhibit their virtuous patience by going into great lengths to introduce the technology concepts that support XML web services, complete with comprehensive diagrams. These base explanations facilitate a firmer foundational understanding that no developer of XML web services should do without.
   
   Accompanying this conceptual theory are practical-driven chapters, each demonstrating a facet of web service development in the .NET Framework and Visual Studio .NET. The instructions are so minutely explicit and clear, virtually taking the reader by the hand (so much so might annoy more seasoned developers), that building the examples listed are exceedingly easy tasks. And I do not mean that in a blind copy-and-paste manner; the baby steps are enriched with proper explanations to ensure readers have sufficient knowledge of why such a piece of code exists somewhere. Even the asynchronous and multi-threading chapter, a topic that most developers tend not to have a good grip on, is written with amazing clarity. The book's 16 chapters are incredibly easy to read and digest, possessing little (if not none) of that confusing wordy fluff that delivers nothing; this one goes straight to the point, short and sweet.
   
   Sometimes however, short can also mean _truncated_. There are places where it simply stops and closes shop on the chapter when more demonstrations are expected. Take for example the fifth chapter, where it is supposed to show using web services with HTTP requests along (without SOAP). It explains alot about HTTP-GET and HTTP-POST, but only walks through a HTTP-GET practical. I felt omitting HTTP-POST would not fair well in the light of educating novices.
   
   While on the flow of novice practices, it also strangely presents a mix of good and legacy (not necessarily bad) examples. The use of the StringBuilder class to append strings together is a good one, but continuing to code with "" and string.ToLower() show an affinity to past platforms. string.Empty and CaseInsensitiveComparer are respectively preferred choices in the .NET Framework practice.
   
   Almost needless to state, even with the "Advanced" part of the book, one should not be expecting any serious deep topics or design patterns revolving web services here. But I couldn't help but feel it waste for such fantastic writing style not delivering something more that is usually arcane in other books. Who should be blamed for desiring more out of a delicious meal?
   
   Great book to get developers started and up to speed with XML web services. But those looking to become _masters_ should read something else.
   
   Good: Crystal clear explanations; easy following; great beginner material
   Bad: Little to offer beyond the beginner; odd omissions; few legacy practices



3. The book can be read in a day and half and at the end you'll really know something useful.
   
   The topics covered are well thought out, though I thought the credit card example was pretty tedious; after a while I just started skipping over it to read what was on topic.
   
   My background is C++ and I came into the C# and XML Web Services with no experience in either; by the end of the book I was comfortable authenticating users, enabling sessions, keeping things in cache and hitting the database.
   
   The book is a fine read and does a good getting you up to speed, one of the best I've read in a while; 4 stars (instead of 5) (-1) for not refactoring the credit card example.



4. This book was a fantastic overview of how XML Web Services are encapsulated by the .NET platform and the services provided by the numerous APIs. It offers step-by-step examples that lead you through the various facets of producing and consuming Web Services. It does not delve too deeply into many of the services provided by .NET for bettor or worse.
   
   Four years ago I would have rated this book a 4 star or higher, however, the examples are based upon legacy .NET 1.1 and Visual Studio 2003. Like myself, I would presume that the majority of developers are at least working with .NET 2.0 and VS 2005 now. In addition the current release of both is at 3.5 and 2008 respectively.
   
   The core material of the book is still very much relevant. The examples for how to configure IIS, setup and copy web projects, and manipulate code in the IDE have changed significantly between product releases though. I didn't mind that much because it forced me to have to figure out how to apply the same task in the newer environment. For me that was OK, but beginners may be frustrated by that.
   
   A few notes on the content and examples:
   
   1. In the code exercises, I found that it would have been much more helpful to put the steps for importing classes (C# using / VB import statements) at the beginning of the code exercises instead of at the end so the person typing in the code could better make use of Visual Studio's Intellisense feature.
   
   2. There was a lot of rote copy / retyping the same material from chapter to chapter. The author tried to minimize with copy instructions in each chapter. I felt as though the examples could have been modularized and reused better.
   
   3. The Microsoft UDDI site that chapter 9 discusses no longer functions as described in the text. I skipped it completely.
   
   4. Chapter 15 about consuming Web Services asynchronously was the one that probably had the most version differences between .NET 1.1 and 2.0. The way that callbacks are handled changed dramatically. This was once again a good learning experience for me to figure out how to make it work in 2.0
   
   5. Code examples were generally good, however, the authors coding style for variable names was not all that intuitive. Maybe a short mention of naming convention would have been nice (e.g. what the 'p_' and 'x_' prefixes meant)
   
   Overall, it is a good book and I would recommend it highly if you are still developing on .NET 1.1 / VS 2003, but less so if not. Hopefully, the authors will publish a newer edition sometime soon.



5. I've recently readed this book while travelling to and from work, and my goal was to learn more about Web Services, and precisely those that gave XML responses, so this book was a good candidate.
   
   The book contains what it says: all about web services in .NET. This is good, because you can always have it as a reference book whenever developing web services. It covers SOAP, HTTP POST and GET protocols, ASMX web services and WSDL-created proxy classes, UDDI and DISCO files, state management, caching, session and state management, and even asynchronous examples.
   
   The only "bad" thing about the book that I've found is the "STEP BY STEP" sub-header... At least in this book it means "complete examples in every chapter".
   The book is 373 pages long (apart from the appendixes), at least one third of that being code examples. And of that 100+ pages of code, the majority is trivial basic WS code that seeing one is ok, twice maybe, but the third time you just skip to the bold part that marks the "important" code.
   
   The authors could have avoided full samples from later chapters, instead only showing the relevant code snippets.
   
   But anyway, as I started saying it is a recommended book to learn (or get deep into) .NET web services development.

5 comments about Programming Microsoft Visual C# 2005: The Base Class Library (Pro-Developer).

1. If you have C# skills of no less then an advanced beginner, and want to find yourself securely in the intermediate range, then you have found the right book. Read it once and you will find your skill set drastically improved. Read it twice and study it thoroughly, and you will find yourself getting turned to for help from your more senior developers. Quite the ego booster.
   
   It's well written, has appropriate examples for the target audience, and doesn't get bogged down in beginning C# material. It has plenty of advanced material, if that is what you are looking for.



2. I sought and purchased this book for the purpose of moving to C# 2005 from 2003. I have an extensive library of language and class references, guides and detailed texts for .NET 1.1. Much of that information will, of course, serve me well with the newer language, so what I sought was a good, basic introduction to C# 2005 that covered the important differences in the base classes. This book seems to have been written exactly for me!
   
   Balena has an easy style of writing, also, that just seems to allow the information to jump right into your brain. There are other authors whose technical expertise is obvious to me, and whose books I regularly look to buy, but whose writing have quirks that can distract me at times. Balena is not such an author. Clearly, he knows how to make proper use of the IBrain.InputInformation(T info) method, rather than using the older, weakly-typed IBrain.InputInformation(object info) method. OK. Bad joke. But I hope you got my point!



3. Francesco Bakena is a well-known author, the book is good.
   The themes and the examples are clean. The same line as Visual Basic. I recommend.
   Manoel de Assis - Brazil - [...]
   
   Programming Microsoft Visual C# 2005: The Base Class Library (Pro-Developer)



4. I have read a few programming books and I can honestly say that no single one has had more positive impact on my level of programming skill and knowledge than this one. Let me preface this by saying that this is not a beginner book. That is, if you have never programmed with C# before, this is not the book for you. However if you have just finished a "beginner" book and are looking for the next step, then I highly recommend this book for you. Whether you are planning on getting into ASP.Net development, WinForms, SOA, or even XNA, this book will provide you with a firm grasp of the language fundamentals that will make jumping into any or all of the above much easier. The book is broken down into several chapters, each one covering different key topics of the C# language such as basic data types (what is boxing? How does the compiler handle value types vs reference types and why should you care?), Generics, Serialization, Reflection, and COM Interop, just to name a few. Mr Balena also maintains an online blog at the Code Architects site and has even been kind enough to personally answer a few of my questions that I had about the topics covered in the book. I can't recommend this book more, it really did make the difference for me between being a C# enthusiast and a professional C# developer.



5. This covers C# and the most basic .net pretty well and is easy to understand. I just wish it covered more framework, but I guess its got to stop somewhere.

5 comments about Java Programming: From Problem Analysis To Program Design 3e.

1. This guy is unbelievable, beginner book my ass, he starts off with basic, basic crap then starts techno blah, blah, blah, is there a road to recovery for this technocrat who can't teach to the rest of us working on our first programming language, just would like to meet the person who picked this for a beggining java course, found more helpful explainations on the web!



2. this book is absolutely terrible for a beginner. it has no perspective of what programming or java is like from a beginner's viewpoint. it assumes almost right away that you know a lot about programming and java. its explanations are few and far between, and not well written either. moreover, it has a fair number of typos and errors in the text. the person who wrote this book is by undoubtedly a genius, and he definitely knows his stuff; however, he's not a writer and he's not a teacher, and he should be banned from ever writing any kind of beginner programming book ever again. i highly suggest anyone interested in programming or java use another book, as this one is terrible.



3. 
   The book is ok - but I am using it as a reference to Java. I find it horrible whenever I need to look up anything - rarely is any topic listed in the index - so I have to look at the table of contents, guess which chapter my topic may be in, and then skim the chapter! I'm using the 2nd edition, hopefully the third has repaired this huge oversight!



4. If you're new to programming, then maybe this book will work for you. If you're an experienced programmer, don't bother with this text. Given it's now in its 3rd edition, it still has misinformation, and typos. Including the index, it contains 1055 pages, but only covers Java through basic OO (inheritance), some GUI, and exception handling. There is no mention of threading, network programming (which are covered quite well in Core Java, Volume 1 at a much lower price). By the time you've reached Chapter 5, the book is still discussing "control structures", ie: if statements, for and while loops. One would think that 315 pages of such is more than sufficient. The pictures help fill the book, and are nicely done. If you're just starting out, buy the book. But if you're wanting to learn what Java is about, start with Core Java instead. At about 1/3 the price, it's fun to read, easily understood, and will get you to your goal much faster.



5. Another great "Introduction and continuation of computer programming using *" book from Malik, Java in this case.
   
   The style is always the same, why fix it if it isn't broken!
   
   This is the defacto standard for college high-level programming language courses in Java.
   
   This book is for anyone new to programming and wants to get started with Java, or anyone who likes to skim through a thorough Java book, even if experienced. I use this to learn Java, even having completed in detail via 3 CS courses the C++ Malik text. Programming syntax only books have a tendency of leaving important gaps, and lack even basic examples that are a tiny yet necessary glue for the mind.
   
   The book includes a CD with the necessary software and an appendix in the book to get started programming hands-on as you go through the book.
   
   The is book is far better than its nearest competitor, Deitel's Java book.

3 comments about Intel Threading Building Blocks: Outfitting C++ for Multi-core Processor Parallelism.

1. There are many views of how best to implement multi-threading and with multi-core processors now common the topic is becoming ever more relevant. Of course the best implementation method really depends on what you are trying to do. Are you implementing something that waits for a price update message from a derivatives exchange, parses the message, updates cached data, writes a log and forwards the message on to an algorithmic trading engine? If so, you'll probably be attracted to techniques different from someone calculating risk, bond prices etc. There is no one technique that suits every job.
   
   Anyone working with multi-threading (and parallelism in general) keeps an eye on what techniques other people are using to see whether they may be useful. That's why I bought this book (Intel Threading Building Blocks) and TBB certainly looks like it will be of use for some multi-threaded applications that I develop, although not for all.
   
   Starting with the most important question - have I learnt anything from reading this book. Yes, and I've learnt a couple of bits from reading the TBB source code too (downloadable from the web). Now for the detail...
   
   Having read the book, am I now about to start using the Intel Threading Building Blocks library (downloadable from Intel)? The answer is yes, for some applications on some hardware architectures, but not for all of my multi-threaded applications. Importantly in terms of this book though, the first reason I looked at the TBB source code was to answer questions raised when reading the book, and that is my main issue with this book. For a developer who already has extensive multi-threading experience, this book raises quite a few questions that it doesn't answer.
   
   Even some of the things that this book does answer are tucked away in the text a long way into the book. Here are three examples:
   (1) The book tells you to create tasks, not explicitly work with threads. Where is the best description of a task? Page 267. It's not even in a glossary, but tucked away in the examples chapter. Somewhere in the first chapter would have been more useful.
   (2) Personally, if I am told within the first few pages that TBB is based on the idea of developers implementing their systems as small tasks that are scheduled by the TBB scheduler I am immediately going to ask how that task is handled at a technical level. Ok, we're told quickly that it's written as a functor, and that functors may be executed on different cores, but does that mean that a thread is chosen from a thread pool to execute each functor, that (on Windows) fibers are used, that there is one manager thread running per core (with processor affinity set?) with each manager pulling tasks from its own queue, what are the performance implications of context switching and locking, etc? The author may think that the reader doesn't need this level of detail, but if somebody is going to the trouble of writing multithreaded code to improve performance I would think it very likely that they will want to know what is happening beneath the surface to ensure that they are using the best techniques. Some details of the scheduler are provided much further into the book (for instance we discover that last-in, first-out deques are used), but not enough and far too late.
   (3) On page 133 there are two paragraphs discussing when task-based programming is inappropriate, a bit late in my opinion for those people for whom it does turn out to be inappropriate.
   
   I also have issues with some of the things presented as absolute fact in the book. For example "Race conditions are less catastrophic than deadlocks". I disagree. With a deadlock your program stops, you know about it very quickly, you investigate and you sort it out. If it happens, it'll probably only happen once. With a race condition you may not even realise it exists, the application produces subtly incorrect results and hence your functionality goes awry. If that means your algorithmic trading engine decides to buy a million shares instead of doing nothing (or selling) then you are going to lose a lot of money very quickly. Possibly not just once, but day after day until you realise the race condition is there.
   
   Then there are the bits that are just plain confusing. Here are two examples:
   (a) We are told on page 271 that Task stealing is "Terrible" and "will disrupt cached data", but are told on page 283 that TBB is "unique because it rests on a few key decisions" including "Use task stealing". Hmmm...
   (b) The code comment on page 231, "2 = 1 for SideShow and C". I know what it means, but adding a verb phrase would prevent the moment when the reader wonders just which proof is about to be presented that "2 = 1".
   
   On the plus side, the book does discuss the split/join pattern, pipelines, atomic operations, benefits of working in user space, issues with the standard new operator (and hence libraries that make use of it), caching issues etc. There is also a chapter on general "Keys to Success" which is useful. There are also some reasonable examples towards the end of the book (although some half way through would be better replaced - demonstrating a point is one thing, but demonstrating it with realistic code is better).
   
   Possibly outside the intended scope of the book, it might have been useful to briefly describe grid computing and whether Intel have plans to add a layer above TBB for use across grids instead of just on one machine, or whether Intel's plans for grid computing simply rely on a completely different model.
   
   So to summarise, the TBB library from Intel looks like it could be very useful, this book will certainly get you started using it, but have no doubt that this book could have been better. Buy it if you will be using TBB, but until somebody writes a better book be prepared to read the TBB source code to find the answers to your deeper questions, or simply ask questions on Intel's web-site.



2. I agree with Hardman's review as far as it goes -- the book cannot go into as much detail as he would like since it is designed to be cross platform (and surprisingly also applicable to other similar chips e.g., AMD).
   
   On the other hand, this book opens you up to an important area: how can you use a small number of cores to speed up your program, including those programs that appear serial at first (and maybe second) glance e.g., the cumulative sum of a vector.
   
   The book has a lot of depth on the algorithms used and works through applications of differing complexity and varied domains.
   
   As an extra bonus it provides annotated pointers to its intellectual predecessors, albeit not as extensive as Hillis' book.The Connection Machine (Artificial Intelligence)



3. I bought this book with the hope that I could find the answers to solving a couple of problems.
   
   The first problem being writing parallel threaded code in a standardized way.
   
   The second problem being writing the OS threads and associated message queues in a way that is abstracted from the OS.
   
   In the end I have not used the lessons from this book yet. After reading it I was left with the impression that the inventors are on to something novel; however, the implementation is not yet complete. I find myself asking if this winds up being like Sony's Betamax.
   
   Only time will tell.