Rating: 
Summary: Inspiring Reading
Review: Having worked with numerous development process models, this book cuts through the bureaucracy of traditional models and introduces an inspiring alternative. None of the process steps are actually explained in detail. Read Rational's Unified Process, if you need details. Extreme Programming Explained concisely covers just enough to inspire - nothing more, nothing less, and it does it well.
Rating:
Summary: Good Book for Conceptual Knowledge
Review: My goal upon buying this book was to gather a good "solid" overview of what XP is and some back round regarding this methadology. This goal was accomplished. However, this 166pg book could be a narrow 30. My suggestion is to skim the book in a book store for about 30 minutes.
Rating: 
Summary: Poorly written
Review: The book is a summary. Too many assumptions are made of the components involved in the XP model to give the readers a good base to use. There are some good ideas but not enough to actually implement the process.
Rating:
Summary: Where's the beef?
Review: Chapter after chapter I kept thing that the author would get to something substantive. He never did. Not one example. Not one piece of concrete evidence. He had some good common sense ideas, but they are all presented in such general terms that they are self-evident. The author makes grand assumptions and goes on to explain (in generalizations) his theories which are based upon these assumptions. I often envisioned the author standing on a street corner proclaiming the end of the world or espousing the "scientific" basis of creationism while exposing his complete misunderstanding of science and his willingness to ignore facts that disprove his assertions. This entire book is written as if it were an introductory chapter. It reads like a psychology text - a lot of verbiage which hides the fact that the text has almost nothing to say.
Rating:
Summary: A new approach to software development
Review: This approach to programming was much bandied about and a little controversial at a software engineering conference I recently attended. Beck's premise is to take proven good practices in software development and max them out:- if code reviews are good, do code reviews constantly by having another programmer look over your shoulder. - if testing is good, write your test plans first and then test each time you implement another feature - if integration is good, integrate almost constantly so that the system always works The underlying premise is that the old, familiar cost curve that says it costs a thousand times as much to fix a mistake in the testing phase as in the requirements phase is no longer accurate: we have much better tools now than when that curve was formulated, we're living in Internet time, and the customers don't know what the heck they want anyway. So we might as well go ahead and try to give them something, then fix it up later, rather than trying to divine their goals now. The problem I see with this is that there's not much time allowed for doing analysis and design. Beck specifically counsels against trying to anticipate capabilities, but if you know what you're doing, anticipating capabilities can save you a lot of time down the line. (His rejoinder is that it can also cost you a lot of time in implementing and debugging features that don't work and may never be used.) No matter how clever you may be, doing design as you code seems to me to be one cut above the worst sort of hacking. Still, there are some marvelous ideas in here: pair coding sounds intriguing, writing test plans first is a must-have, and I've always held the position that the system should be constantly integrated, that there should never be a big push at the end to get all the pieces to fit together. He also has other, related advice: developers should not work overtime for more than one week in a row (that's a way to become less productive, not more), you should have a customer representative onsite with the programming team to answer lesser questions about how to implement capabilities, and so on. In summary, this book is very worthwhile for anyone who wants to improve their software development practices (and who doesn't have problems with their software development practices?). It's particularly good if you're in an environment where the customer wants a quick response to what they want when they want it even as they're not sure what they want. I wouldn't recommend adopting the approach wholeheartedly and automatically (and neither would Beck), but take what makes sense and go from there. As Beck himself says, figure out where your biggest problem is and adopt XP practices there first.
Rating:
Summary: Excellent Thought-Provoking Ideas
Review: This is one of the most thought-provoking, interesting software development books I have read. At its heart is the idea that the traditional exponential software lifecycle cost-of-change curve doesn't necessarily have to be, and if we "embrace change" as the book's subtitle suggests, we can roll with the punches, flatten the curve and deliver solid software sooner and in a much more satisfying way. Kent Beck's style is very easy and enjoyable to read, and very practical and realistic. He knows programmer psychology and it shows, with the whole methodology working with the programmer, not against him/her. Even if you don't want to or can't follow the whole extreme programming model, you will certainly be able to pick up pieces of good advice to improve the way you currently development software.
Rating: 
Summary: Only the pair programming concept is new
Review: Anyone with a decent Software Engineering background will see there is really not much new in this book. Sure you should write test cases before coding. But for a complex program you can never try out all the possible user inputs with a few hundred testing cases. It's more important to start with good object oriented designs. Find a book on OO or UML from Booch, Coad or B. Meyer.
Rating: 
Summary: An excellent but nontheless limited methodology
Review: In an ideal world almost any methology will work and I can't help but feel but that this methodology is also suited to such a world. Extreme Programming concerns itself with the minutae of code development and appears largely to reject the notion of having an overall design. This approach dangerously weakens the concept of a there being a 'Big Picture' into which a system fits and overemphasises the idea that everything can be broken down into small independent units. Unfortunately it does't follow that if the parts work then so will the whole. Whilst the methodology is at its best in dealing with these small units it is weak on how best these units should be assembled and the combined constructs tested. Unfortuately it is rare that coding level problems affect a project as much as system level ones. Another problem with this methodology is that it generally ejects the customer from the development cycle. It's all very well going to the customer initially but, if you then pull the shutters down and only seek feedback whenever there is a new version, customer confidence will rapidly drain away. Frequently asking a customer "How does this version look?" doesn't garner confidence. There are good ideas put forward in the book too. The princple one is that of 'pair programming'. This can be useful when new ideas are being tackled, less so when dealing with the 'mundane' coding. Overall, the best ideas advocated in this book (forward planning, frequent testing, better communication, etc) are actually independent of the methodology itself and when applied as intended with any methodology would produce improvements.
Rating:
Summary: Post-modern software development
Review: In this slim volume Kent presents a framework for software development (XP) that values the individual, and asserts that this framework actually builds better software faster than the alternatives. Based on my experience using XP I have to agree. It's often been popular to have software development methodologies the present software development as completing a number of stops. These high-dogma methodologies produce a lot artifacts at each stage. They have been designed to handle an environment where the cost of change was high, and we needed to do all our thinking up-front to avoid later change. But what if the cost of change wasn't high? How would that affect our behaviour? And do we now have development environments that can radically change teh cost-of-change curve? It turns out that we do have tools and practices that can radically alter the cost of change curve,<i> provided we change our mindset as well</i>. We can create flexible, adaptive software in environments where both customers and developers are respected and enjoy the work. "Extreme Programming Explained" is a starting point for anyone interested in embracing this paradigm shift. It discusses the core practices of XP and gives you enough material to start your own XP project. We've done that where I work. Other books will provide more details on XP, but the XP philosophy says introduce something simple and see how it works. "Extremem Programming Explained" is that start. If you're unhappy with your work environment and think that there must be a better way then you should definitely read this book. But read it even if you're happy as well - things can always be better!
Rating: 
Summary: A different kind of book
Review: Some books have the ability to get us to think about things in an entirely different light. I found Extreme Programming so. Whether you decide to adopt XP or not, the book will help you think about programming in a new light. You might call it meta-programming. Why do you do what you do? Is there a way to do it better? Books like this are rare.
| 
