4 comments about The ThoughtWorks Anthology: Essays on Software Technology and Innovation (Pragmatic Programmers).

1. This is a terrific book loaded up with 13 short, concise, golden essays from ThoughtWorks leaders like Martin Fowler, Neal Ford, etc. Each topic covers something pretty vital for those of us who care about being somewhere near the top of our chosen craft. Topics include solving the "last mile" problem between development and release, Ruby DSLs, polyglot programming, single-click deployment, and a bunch of other great reads. Each article is extremely well-written and useful, but I found a subset of the book particularly compelling.
   
   Unfortunately, I only heard parts of Neal Ford's "Polyglot Programming" at his keynote at CodeMash 2008. I was thrilled to get to read his article in this book on how to leverage different languages on the same platform to solve different problems.
   
   Jeff Bay's piece "Object Calisthenics" strongly reminded me of the glorious work The Practice of Programming from Kernigan and Pike in its emphasis on clean, simple, clear code. I'm all fired up to refresh my coding practices with Bay's exercise using nine points for pushing yourself into writing better object oriented code.
   
   "Refactoring Ant Build Files" from Julian Simpson, along with Hatcher's Java Development with Ant, should be mandatory reading for anyone dealing with build files -- regardless of what build environment you're using.
   
   Other big winners for me were the testing articles by Kristan Vingrys and James Bull, Dave Farley's work on one-click release, and Stelios Pantazopoulos's article on project vital signs. Of course, the remaining articles are also winners, it's just that these six or so really struck home with me.
   
   Overall it's a fantastic work and I'm really glad I've got it on my bookshelf!



2. I feel that every techie should take a step back once in a while and reflect on their profession. The ThoughtWorks Anthology: Essays on Software Technology and Innovation by ThoughtWorks, Inc. is one of those books that helps lead you down that path. While there are some good reads in here, the "level of resonance" will likely depend on your language of choice and development methodology...
   
   Contents:
   Solving the Business Software "Last Mile" by Rog Singham and Michael Robinson
   One Lair and Twenty Ruby DSLs by Martin Fowler
   The Lush Landscape of Languages by Rebecca J. Parsons
   Polyglot Programming by Neal Ford
   Object Calistentics by Jeff Bay
   What Is an Iteration Manager Anyway? by Tiffany Lentz
   Project Vital Signs by Stelios Pantazopoulos
   Consumer-Driven Contracts: A Service Evolution Pattern by Ian Robinson
   Domain Annotations by Erik Doernenburg
   Refactoring Ant Build Files by Julian Simpson
   Single-Click Software Release by Dave Farley
   Agile vs. Waterfall Testing for Enterprise Web Apps by Kristan Vingrys
   Pragmatic Performance Testing by James Bull
   
   Based on the type of work that ThoughtWorks does and their development methodology, you'll understand and relate a lot more to the material if you're into things like agile development, Ruby, Ant, and other various open source software offerings. Granted, the argument could be made that *everyone* should be using those things, but the reality is that there are plenty of developers who don't or can't for various reasons. But once you get past that point, there's plenty of material here that should get you to think a bit... Lush Languages does a great job in turning the Java vs Ruby argument into one where you're considering multiple language options based on the problem domain. Polyglot Programming is also very insightful, as it addresses the use of multiple languages within a single project so that you can get the best of all possible worlds. If they are all running under the same JVM, there's few reasons not to take advantage of the various strengths. I also enjoyed the Object Calisthenics entry, as the exercises force you to rethink program design without resorting to techniques that can get out of control very quickly. Many of the other chapters are a bit more focused on topics that might or might not work for you if you're not already using that software/approach. You can always dig out one or two items that are not specific to the tool (as in development tool programming should fall under the same level of control and planning as production code), but you have to work a bit harder to get there.
   
   If you're into the particular tools outlined here, by all means get the book and read it. If you're not at that spot for whatever reason, it's still worth reading. Just be prepared to work a little harder and/or realize that some of the chapters just won't do much for you.



3. One nice thing about collections of short pieces is that you can work your way through them in any order and only read ones that look interesting without worrying about missing crucial information. That's how I read this book, and I enjoyed most of the selections I read. I thought that the one on OO coding was great as it had good concrete exercises to help folks go down that road.
   
   Recommended.



4. This book is packed with realworld knowledge and experience, written by people who have more than earned their title of expert. It covers many aspects of the software development world and adresses issues that you have most likely run into at some point, or are about to run into. Being able read how the experts deal with these things is very interesting indeed, it can either give you new ideas to better handle the issues, or it can be a confidence boost to see that the experts do things the same way as you.
   
   For me, the part about the Iteration Manager and the performance testing were particularly interesting because I've had quite a few problems with this in the past.
   
   Keep it up Thoughtworks!

4 comments about Microsoft Office Outlook 2003 QuickSteps.

1. I manage a medium-sized network and support a large number of fairly savvy users. That is, most users know how to do their specific tasks very well and are willing to learn new things. But they are not willing to sit down with a book full of dense text. This is where the "Quick Steps" books come in handy. I keep a number of these books on hand and when a user requests assistance, I give them one of the books with the appropriate page bookmarked. Steps are outlined in full color with lots of pictures and pointers and tips. Additional information is set off in side boxes so users can learn more if they choose. What I have found is that once a user completes a task successfully, they get fairly excited about the experience and browse the book to learn more. The books really stimulate users to experiment with things they would not normally bother to learn. And that is where this book excels. It is a "browser." Users don't feel like they need to start at the beginning and read through to the end. I get lots of grumbles when I ask for the book back so I can pass it on to others.
   
   This book is also great for new users. I tell them to spend a few hours working through the steps, which are easy to follow and can be done at a fairly fast pace. Most users think the full color layout is fun to work through. The down-side is that like any book, space is limited, especially with the fully-illustrated format, so you're obviously not going to find everything in these books, but I do feel they contain a good balance of material and are appropriate for corporate libraries.
   
   Marty and I are fellow writers and that is how I learned about these books. I must say that it has helped my users enormously and relieved my support task. Hey, it's the 21st century. Anyone working in an office should know how to work with operating systems and common applications. Most people can do that if they have easily accessible references and refresher material like these books. Thanks to Marty for developing the "Quick Steps" concept and to McGraw-Hill for publishing this series.



2. I am a real estate agent, looking for the best way to manage contacts. I have Outlook but didn't have a clue how to go about integrating everything without reading a 1000 page book. I thought about Act! but had very mixed reviews on it. So I searched for a book that would quickly get me up and running in Outlook, and therefore would quickly tell me if the software I already have is powerful enough to do the job I need yet easy enough to let me spend my time on my real job -- not learning more software. This book does both; and the quality of the paper and color made it a pleasure to read. I got my answer -- yes, Outlook can do the job quickly and easily, freeing my time to sell real estate.



3. This "QuickSteps" book is largely a picture book: lots of nice, color screen shots of various parts of the Outlook interface, with sketchy text captions pointing to various things to tell you what they are and do.
   
   There's not a single scrap of information in this book that you can't find from doing a quick search in Outlook's own online help. And because of "QuickSteps" relatively thin size (compared to most software manuals), it gives you only the most superficial introduction to the topics it covers.
   
   My advice is to skip this book -- even at the "amazing low price!" as it claims right on the cover -- and use the Outlook online help and tutorials. Then if you still need more information, get one of the real books.



4. Book is written in simple language and in an easy-to-follow format. Excellent diagrams. Very good instructional book for beginners and a good reference for those of us who need a refresher course in Outlook.

1 comments about A Software Architecture Primer.

1. A Software Architecture Primer beautifully describes a small set of light-weight practices that can streamline and systematize your software design process without bogging you down in a beureaucratic process.
   
   Usually when I think of software engineering process, I think of a set of burdensome tasks that drag me down and make it more difficult to explore or change my design. Each design change can result in hours or days updating countless documents, recommunicating those changes in reviews, and so on. At the same time, it is usefult to have a structure for fleshing out a software design and communicating it to your team.
   
   In contrast to most other authors I've read in this space, Reekie and McAdam realize that there is a tension between process (structure) and getting real work done. So rather than going on and on about the minutiae of different software design formalisms and whatnot, they clearly and succinctly describe a set of techniques and exercises that will help you systematically design better software and communicate your design to others without slowing you down. This is the first software architecture book that I will actually put to practice in my next software project, rather than picking and choosing from the huge body of literature in this space.

5 comments about AI Techniques for Game Programming (The Premier Press Game Development Series).

1. This book IS my Masters thesis. I built a multi layered combative system driven wholly by neural networks evolved using genetic algorithms. The learning of agents was unsupervised and they existed collaboratively and adversarily. If all of this made no sense, dont worry! Read this book and it will.
   The book covers these techniques (except for multi layered architectures) to a level understood by anyone with a basic knowledge of C++. It totally demystifies NNs and GAs. Other books on these subjects actually put you off the entire concepts of AI by feeding you fear and confusion.
   I have completed the book and have read it numerous times. It is going to be invaluable for my development of PHd stuff - his writing introduces areas for potential research.
   Im would definately buy other books from this author. I hope he covers other areas of AI soon and puts 'em into print.
   Be jaysus, tis mighty I tell ya!!!



2. This book is a little jewel hidden in the usually trashy prima press
   game development series.. it gives a great, clear, non-formal introduction to genetic algorithms and neural networks in the context of game programming.. and gives you example code in good C++ (brainy aliens storming towards you, a genetic algorithm controlled lunar lander.. tanks that move around avoiding obstacles....) that actually works and is simple enough to be understandable for a newbie. The writing style is lively but not annoying. I recommend this title to anyone who has an interest for the fun side of programming....



3. You know when a subject is finally becoming stable when simple books like this come out and explain in layman's terms.



4. Although other reviewers have already pointed out everything positive about this book, I felt I also had to praise it because it's so good. It's a great introduction to neural networks and genetic algorithms. By the way the author should be congratulated for his "never include any code that you don't throughly explain" philosophy. Although it's over 400 pages because of this philosophy, you can skim/skip around 150 of them if you know some win32 programming and basic high school math/physics. The book is so concise and easy to understand that I went through it in a night and came up having a firm idea about the subject. There are also a lot of good ideas to try out throughout the book(i.e. tinkering with the source included etc.)
   
   To put it shortly, this is a great book, it's really worth the money you spend on it.



5. As mentioned above, this is THE book for AI. It uses plain language and explains different topics using real life examples. If you need/want to learn AI programming, this should be the first book of your collection.

5 comments about XML Schema.

1. This book had potential to be a definitive guide to XML schema. This is not the kind of book you can pick up and read cover to cover (unless insomnia is a real condition for you, in which case this book may help). It is, by no means, a tutorial of XML schema - or even a reference. It's more of an exploratory academic walk of the W3C recommendation and all of its foibles and nuances. There is wealth of information in this book, if you can glean it out from inbetween the droning prose and historical diatribe.

   O'Reilly should be shamefully embarassed for ever letting this book go to print in the condition it is. It is replete with errata, typos, and slopped together examples. This book is destined to frustrate those new to XML schema. An uncharacteristicly poor level of quality for O'Reilly.




2. This book is very dry and terse. It has all of the required content but it doesn't provide much perspective of how it should be used. You could use it as a reference, but I recommend the XML Schema Companion before this one.



3. XML Schema is used almost everywhere (in connection with XML documents, Web Services, SOAP etc.). So I as other people needed to master XML Schema. There is not a great choice of XML Schema books. Specification is already quite getting old. The book is not easy to read. I read it sequentially chapter after chapter and I mastered a lot of basic rules. The main problem now I see is, XML Schema itself does not give you too much of design freedom. Sometimes you need to define a structure (data type) according value of other elements. So now I know mainly what is not possible to do in XML Schema.
   After all I have to recommend the book. You have to read it twice. So I have just bought another XML Schema book from Priscilla and I hope I will get to know XML Schema from other point of view.



4. This book tells you what you need to know. However, it is a bit of a hard slog because it doesn't tell you why you need to know it. It also throws in obscure acronyms and not only expects you to know what they stand for, but what those protocols/standards/programs imply. Yes, you can learn all you need to know about SQL schema, (and more than you need to know - without telling you why you need to know it, you don't know what to skip), but it is a little more painful than it has to be.



5. A real need for further editions on this book. As others have commented, it's very poorly constructed, poorly indexed and you'll be hard-pressed to quickly find accurate definitions. As other posters have suggested, O'Reilly should be worried that this one got published in this state.

5 comments about Beginning Java EE 5: From Novice to Professional (Beginning: from Novice to Professional).

1. The book is very good until you reach chapter 9, i think the authors made this book with a no ready version of ejb 3.0 spec's.
   When i tried to run the examples i couldn?t. I prefered to start the jboss ejb 3.0 tutorial and i think im going to give just a glimpse to the
   next chapters to see if something works.
   
   It was good... until chapter 9



2. This book was published too early. By that I mean, Java EE 5 was not finalized so the code examples starting in chapter 9 don't work. Another example is chapter 10 titled EJB Entity Beans. According to the Sun tutorial, Entity Beans have been replaced by the Java Persistence API.



3. I bought this book to learn the newer concepts introduced as part of Java EE 5. This book did'nt meet my expectations, the example code described in the book has already been deprecated and just don't work on Glassfish. The code on the book may be tested to use beta version of Java EE5 reference implementation ! I could'nt figure it out.



4. Not happy with this book. The author does not provide enough details on environment configuration, unless you use JBoss. I would stick to Core Servlets by Marty Hall.



5. This book was a plethora of useful knowledge. However, it wasn't a jump in and get dirty type of title. When starting the path towards EJB/J2EE coding, one needs to do less messing around with devshed pre-coded examples, and learn by doing.
   This text references proprietary JAR packages from the authors. It is my feeling that APress let down the beginning J2EE/EJB programmer here. This book is not for the beginner java programmer -
   Repetition goes far when learning a new area of any language.
   
   Bottom Line:
   If you want to get up and go and are good at installing all the pre-defined jargon (or are highly skilled with guesswork) and just want some great examples, this book is great for You. If you prefer the repetition route, look elsewhere.
   - Hope this helps.

3 comments about Distributed Event-Based Systems.

1. Caveat: I have not finished reading yet, but since no one has posted yet, wanted to share my impressions so far.
   Springer has made a name for itself with books that appeal to both academics and professionals with a little academic edge. This book is no exception. It provides a very precise and thorough treatment of event-driven systems. If you are afraid of Greek letters this is probably not for you - Chapter 2 "Basics" uses temporal logic to define the precise semantics of event-based systems. On the other hand you gain in-depth insights into some of the design challenges and options when implementing your own event-driven system.



2. I think it is a good read. I had to refresh some math to better understand the presented material, but it was interesting. It is theoretical and far from practice, but was what I was looking for in the book so I am satisfifed. I enjoyed the objective view i which the material was presented.



3. I found this book an excellent read, with very good balance between theory and technical information -unlike what the previous reviewer thinks- (by technical information I m not implying source code, but rather systems design exploration). I ve gone though almost all of it and I was only a bit confused in a couple of parts (and when I contacted the authors they were very helpful to give me clarifications). The only reason I m not giving it 5 stars is because I am not an expert in the field

5 comments about Cocoa Programming for Dummies.

1. A decent introduction - but it starts off assuming you already know C (like most intro to Cocoa books -- When will someone write a learning to program with Obj-C/Cocoa for beginners new to programming?).

   The book could use more detail in describing why you do certain things in Obj-C/Cocoa instead of just saying do it this way.

   But the worst part is the huge number of errors and inaccuracies in the book. Every chapter contains multiple errors - usually with missing steps or method names changing between steps or being differnent in the pictures. The editing is HORRIBLE. This really should be .5 Edition - it really is too error ridden to be a 1st edition.

   If you are looking for a book to get you up to speed on Project Builder and Interface Builder (based on the Dec. 2002 Developer Tools) then it is a decent introduction. But don't expect this to get you started in programming for OS X if you don't have any real programming experience. And the constant errors in editing are pretty bad; you have to keep on your toes to make sure you account for them or sometimes the examples won't work.

   Finally, to the cocoa book writing community in general -- please address the market for new programmers who want to learn to program in Obj. C/Cocoa and who do not have any extensive (or any at all) programming experience in C.




2. I've been trying to teach myself Cocoa for over a year now. OS X is an absolutely stunning piece of software, and I love the idea that Apple includes in the box a full set of developer tools I can use to create my own little OS X masterpiece.

   The problem, however, is the learning curve. For a first-time programmer, Cocoa is one tough nut to crack. There are lots of third-party books out there now. Unfortunately, they are all geared toward experienced programmers. Every book assumes fairly extensive C or OOP programming experience, and none cover basic programming or Objective-C in sufficient detail for the complete programming newbie.

   While this book isn't really an exception to the rule, the approach is definitely more newbie-friendly. I purchased the book on a Thursday, and finished it on Sunday evening with a much greater appreciation and understanding of Cocoa technology.

   What made the difference? For one, by the time this came out, I already had some exposure to the underlying technologies: I trudged through Apple's Objective-C documentation (hard-going for non-programmers, but after a couple of read-throughs, the material starts to gel). I did the Currency Converter tutorial, which got me familiar with Project Builder and Interface Builder, the two most important tools in Cocoa development. I read various other portions of Apple's on-line documentation, and looked at some tutorials available on the web. As noted, I'd also taken a crack at some of the other books available on the subject, throwing in the towel on all of them before hitting page 100 or so. None of this taught me how to program in Cocoa, but it gave me enough background to tackle this book and understand just about every topic covered.

   If, and probably only if, you've at least looked at Cocoa and Objective-C before (or have significant experience in C, Java, Smalltalk, or other OOP), you will be able to not only work through, but understand, the exercises in this book.

   And the exercises are very practical and clearly explained. Rather than build a book-length, professional quality application, the author builds small, toy applications to demonstrate Cocoa patterns that you can actually use to build your own software. For example, the chapters on text handing, window management, and file and folder management, are clear and concise, allowing the reader to work through them quickly and without complication. This fast and dirty approach, at least for me, had the added benefit of allowing me to get through the book in less than a week, take a step back, and appreciate how all I learned could be used to start building my own, more complex project.

   I'd like to thank Mr. Tejkowsi for being first to market with a Cocoa beginner's book that actually works for beginners. His effort gave me a taste of the power of Cocoa, and the confidence to return to other, more advanced texts that I'd walked away from before. Thanks to him, I'm not ready to give up on Cocoa just yet!




3. I must echo decker's complaint about the editing, which really is horrendous.

   But my criticism of the book is deeper still. On pp. 55 - 56 in discussing the use of number formatting for output in the interface, the text describes the "bug" as resulting when "the count of digits in the decimal protion doesn't match between the two numbers". This is a material misstatement, and neglects any attempt to explain the real cause of the problem that the formatting is intended to solve: The inexact representation of (most) decimal fractions in machine representation. Yes, this is an advanced programming topic - and may not be of interest to beginning programmers; but there is no excuse for giving an incorrect explanation instead. Why does this book waste pages and pages on repetitive explanations, yet remain incapable of providing a sentence or two on one of the most fundamental facts for computer programmers. This insults the intelligence of even a beginner.

   Chapter 6 (for example) contains repetitions of very basic material introduced in Chapters 3 and 4, some it word-for-word duplication of passages on outlets and actions and their connections in Interface Builder (pp.117-128). Where was the editor during the production of this material? This whole repetition seems to be for the benefit of introducing the Objective-C keyword "id".

   Later, on p. 121, the author misses a golden opportunity to introduce the reader to the benefits of Cocoa's naming conventions for accessor functions in classes. The method that returns the value of an instance variable can (and should!) have the same name as the instance variable. Many advanced features of Cocoa (especially in Panther and Xcode) become much more usable if one follows this convention. It couldn't have taken more than a page or two to introduce the subject, yet the book repeats itself annoyingly on several other topics. One suspects neither author, editor, nor reviewer knows anything about many important Cocoa topics. What a waste!

   Then, further, the inclusion of some material seems inappropriate for this introductory level. For example, why waste several pages digressing on the use of the File Merge utility. No beginning programmer needs to worry about this, and there are far less risky ways of modifying the interface after files for it have been created.

   "Cocoa Programming for Dummies" finds its way to the top of my list of "Worst Programming Books Ever Published." I felt after finishing it that the reader would know EXACTLY as much as the author about Cocoa programming - no more, and no less. In other words, Tejkowski "holds nothing back"; he's told us EVERYTHING he knows about Cocoa programming. Perhaps I should be more sympathetic: Why did the acquisitions staff for the Dummies series rope a RealBasic programmer into writing a Cocoa book? Couldn't they find someone more qualified? The Dummies series generally handles its material in a light-hearted and clever fashion; how did it sink so low in this fiasco?




4. The number of errors in the code and processes in the book make it very frustrating for beginners. I think with a good rewrite and update for Xcode, and more careful editing (some errors were obviously a result of the production process, missing lines of code that were included in the online extras files, missing steps in development instructions, and such) this would be a useful beginner's book.



5. This is not a very good book for learning Objective C and Cocoa. The author programmes in Basic, and it shows. Get the much better introduction called Cocoa Programming for Mac OS X from Aaron Hillegass.

5 comments about Business Objects: The Complete Reference (Osborne Complete Reference Series).

1. As a reference guide, the book is extremely valuable. I have seen other books on this subject that are essentially a copy of the help guide. Not to mention that the pricing is 2 to 3 times what a normal book would cost.

   The examples are good and the index is pretty complete. A test for a good reference book is that you can readily find the solution to a particular problem. Ms. Howson's book certainly fits the bill.

   It would have been nice to have more how to descriptions and practical solutions to common business problems.




2. I was thrilled when I heard that a book was being published on Business Objects! After getting a copy of Cindi Howson's book, I was even more pleased!

   It is truly a very comprehensive guide on how to use Business Objects. It does a good job of explaining the concepts behind business intelligence as well the the different Business Objects products.

   I think every person who uses Business Objects would benefit from owning this book! I recommend it through our local user group and to all of my clients!




3. I found the sections on the history of Busines Objects and the background on Business Intelligence very helpful. The only missing component is a CD for the report exercises.



4. I have to say I was really excited when I picked up this book but now that I am almost through the book ...... I wonder how the hell did I have to patience to read the entire book without tossing it into the bin ..... well may be I wanted to to get something out of it for my money's worth ..... This book is not bad its just not what you would expect from the complete refrence series .... ABSOLUTELY NO MEAT ..... hell I could have written a book by copying and modifying the language from the USER Manuals ........ You don't learn something when the author just tells you "OK drop this menu and select this option" unless you are going to tell me why am I selecting this option ..... sry but I have to be harsh on this .... when you are writing a book a such a good software you need to be in really top form with an excellent command on everything ........ In the end "READ THIS IF YOUR COMPANY BUYS IT FOR YOU AND DON"T SPEND MRE THAN 2 DAYS ON THIS"



5. I have not gotten through the entire book yet but so far it has addressed all my needes. I found it to be more than just a reference manual. It takes you through eash aspect of the product in a fair amount of detail. It also give you best practices, the kind of thing I would hope to get in classroom instruction.

5 comments about A Discipline for Software Engineering (SEI Series in Software Engineering).

1. This is an excellent textbook for software developers with sufficient experience and discipline to produce professional software. It is not a philosophical treatise or a book on skills. It is not to be read casually before bedtime. In order to get something out of it, you must carry out the assignments.

   The PSP training is an iterative process, slowly enhancing your process. The PSP is all about gathering data, devising improvements, and seeing the improvements through. The assignments in the book are challenging enough to require some design and have enough lines of code that you can gather data.

   Over the course of the book, you'll make up to six enhancements to your proces, to the point that you have the experience to develop your own processes. If you carry out the book assignments, you'll also have some basic tools for measuring your software (lines of code counters) and process (statistical software).

   In order to be effective with the PSP (or software in general), you need to follow good software design practices. The PSP enables you to capture the data that show this. Good design, though, is outside the scope of this book.

   This book was the textbook for a PSP course for engineers I just completed. The course was a lot of work. In order to get something out of it, I had to be disciplined. In order to get something out of the book, you'll need to be very disciplined because you won't have the structure of a class to ensure you carry out your assignments. The PSP does not work without discipline to capture good time and defect data and to follow the process improvements.

   If you have successfully learned the PSP process, be it in a formal classrom setting or through this book, you will be able to give estimates of size and time that are +/- 10% with a confidence of 70%. Of course large projects require larger processes than the Personal Software Process--those are outside the scope of this book. For an industry that is plagued by over-estimates, this is an excellent first step for engineering at the individual level.




2. I have read the book and implemented the processes both in and out of a school envirnoment. I have seen measurable positive results in my skills. I recently learned that an instructor I had over 7 years ago still refers to me as the best programmer he has ever met, and I owe this entirely to this book.

   If you think you are already good, then chances are are that the book won't change you. If you want to find out how good you are, or more importantly become the best you can be you will most likely be enthralled by it.




3. This is not a software engineering text. The author does not talk about how to write better programs. Instead he addresses how engineers might produce better numerical data to give management more control over the software development process.
   
   The book readily admits that the methods only work well when an identifiable customer is able to provide an accurate and detailed problem statement. Perhaps in some isolated cases this may be so.
   
   The author relies heavily on statistical methods. This may be comforting to management schooled in 6 sigma methodology. However it is bound to make an experienced engineer feel like a production unit on a software manufacturing line.
   
   The book is extremely dry and tedious. The author does not know how to hold the reader's attention. He tends to ramble on for many pages before getting around to making a very small point.
   
   The material may be useful in some isolated cases, but for most, the evidence isn't abundant that the benefit justifies the effort.



4. I have now been using PSP for over a year now, and as it says on the tin, it has improved how I develop software. My estimates are better, my code has fewer bugs and the others take less time to remove. I recommend following his instructions and don't worry about the theories. His instructions work and deserve 6 stars.
   
   A word or warning, TSP is not an optional extra for most people. PSP is hard to learn and most people give up without the support of a team.



5. Uhm... I had to buy this book because it was a required text for a required course. Who would buy a book like this otherwise? Duh!