Customer Reviews

Agile Software Development with Scrum (Series in Agile Software Development)

5 star:		(30)
4 star:		(13)
3 star:		(8)
2 star:		(3)
1 star:		(1)

 

 

SCRUM is a "light weight wrapper" of techniques to manage and guide your software projects. Actually, you could use it on a lot of other types of projects, but software is its best use.

What's unique is that it wraps around the "Design it first" school that I follow, as well as the Extreme Programming (XP) school that follows a proto-typing approach.

SCRUM provides the mechanisms for organizing and controlling the development of your software project. You develop a short list of deliverables for the next 30 days and have a series of daily meetings. Oh, there's more to it than this.

In software projects I have followed a process where the design is fully thought out in advance. I say it is 85 % accurate as I know that mid-course corrections will be made as the software is developed and delivered to the client.

On large projects we typically work in 2 week deliverables, the author suggests 30 day "sprints". We break all the projects up into many packages of deliverables. One advantage to this was the client could see progress, give on course corrections, and you'd be sure to get paid. On small projects we have not followed any formal procedures.

What SCRUM does is give me a better, more thought out process for what the author calls these 30 day "sprints." I wish I had read this book earlier.

I picked up the book at a computer store and bought it reluctantly. I had heard good things about SCRUM, but the book looked too small and a quick read at the store didn't really turn me on that much.

But after I sat down to read it at home, I was very pleased. It is a very well-underlined book now.

I agree with the XP folks on the productivity of 2 person programming teams and have found their "test first" approach to be very interesting. However, I do find that their design-on-the-fly approach to be flawed. When XP works, I think it is because it attracts good programmers... it's not the XP proto-typing approach itself. In fact, I think any methodology that relies on proto-typing wears out the goodwill of the client. The clients time is limited and they value it highly.

I will say that I found many interesting ideas in XP. And, I recommend that anyone interested in the subjec of this book, go to the XP websites and read their books (about 6 or so at this time).

SCRUM fits around XP just as well as the design-it-first approach. What I disagree with in SCRUM (and XP) is the use of open office areas for programming. I believe studies have actually been done on this and closed offices, no windows, white walls, lots of marker boards... wins out. Anything beyond trivial programming requires concentration. Noise and movement kills concentration.

The graphics in the book really suck, as they look like they were printed out in some kind of old 320x200 screen resolution. But there is great depth to this book. It's a smaller sized book with small type (but still easy-to-read). So you actually get a lot of meat.

In the future, I will refer to this great book often and recommend all software people read it.

John Dunbar
Sugar Land, TX

...the book itself isn't really that great. SCRUM has some very interesting ideas about managing a software project, but the book is just OK. I seem to remember him saying that "it was done quickly, just in time for a conference" on his blog at one point. However, if you're going to try some SCRUM, you'll want to read this.

Additionally, you'll need this book if you're going to read his other SCRUM book (Agile Project Management w/ SCRUM) from Microsoft Press, because you'll want the background from this book for that one.

One thing that is not covered in this book is how you get management approval when you have a "process by not having a process," or how SCRUM might scale to more that 7-11 people (other than a SCRUM of SCRUMs.)

This is the book I've been wanted for years. Until this book, the Scrum development process was not very well known and was documented only piecemeal in a couple of papers and websites. Finally, there's a book a that covers everything you need to know to run your software project using Scrum.

Schwaber is the "Godfather of Scrum" and essentially invented the techniques; Beedle was one of the first converts to Scrum and together they definitely know their stuff.

The book covers everything from the theoretical basis for Scrum to how to organize your teams, conduct daily Scrum meetings to keep things moving along, to planning your Scrum project, to tracking the "backlog" of items that need to be completed to finish a project.

Scrum is not a rehash of another methodology. As the authors say, "Scrum is different." Some of the things you'll learn in this book will seem counterintuitive but they work and the authors do a great job of laying out enough information to, if not fully convince you, then at least persuade you to give Scrum a try. (And once you've done that, you'll be convinced!)

I think this book is especially important for anyone reading any of the XP books that have come out over the past two years. Scrum provides an excellent management wrapper around the techniques of XP.

This book is great because it's only 150 pages but everything is succinct and clear--very different from some other books on project management techniques that are needlessly long.

After reading this book you will know everything needed to get started with a Scrum project--and most likely that project will be more successful with Scrum than with whatever process you're using currently.

Schwaber and Beedle are the co-developers of the software project management methodology known as SCRUM. This book was their first on the subject, and it did a worthy job of convincing me that this particular flavor of agile project management might help ameliorate some of the problems I see on a regular basis with my projects.

Although the writing style can be disjointed and opaque at times, the essence of SCRUM comes through in every chapter: Team responsibility and project controls that react to reality instead of attempting to define it. The authors point out that even highly specified software projects quickly escape any pre-defined project plan as development exposes issues and complexities that could not be anticipated. The SCRUM practices they describe are a method of running a project based on required outputs, rather than intermediate steps.

The general rules and methods described here all seem reasonable and well thought out, but at times the insistence on strict adherence to every detail of SCRUM seems oxymoronic. If we are running a project that is supposed to constantly react to the reality of where we are, who is to say that we might not find that 45 day sprints are more appropriate than 30 day sprints? Why not have a full day of planning for each sprint, or just a few hours? The important concepts - like time boxing certain activities - might be lost if the details don't mesh with the environment in a specific company.

There is also a certain assumption of dysfunction inherent in the concept of Product Owner, Scrum Master, and Team. The Product Owner is solely responsible for the backlog - that is, the requirements to be met by development. Well and good, but where is the standard meeting where the Owner receives feedback from the developers? SCRUM insists that outside of certain pre-defined meetings the Team is to be left strictly alone, so we can only assume that such wisdom is not meant to be passed. This is symptomatic of organizations where Product Managers think they know exactly what is to be done, and pass it directly on to the development team. But such a knowledgeable Product Owner is rare, and even when it happens, the transfer of a vision from a single person to a team is not easily accomplished in a short meeting. It seems to me that the Owner should be intimately involved throughout the sprint, rather than only at the beginning at end.

In a way, this points out the major gap in SCRUM. There are three roles, and none of them is the Customer. The Product Owner should represent the customer, but since he or she is not involved in day to day development decisions, and since interactions between him and the team are at a minimum, it seems that it is responsibility only in theory. Interjecting a more robust form of customer feedback than the Sprint Review would, in my mind, be a welcome change.

But ultimately these are all nitpicks. As an introduction to a light-weight and tested project management process, this book is invaluable. It lays out many of the pitfalls and nearly all of the necessary ingredients necessary to let a team of developers produce good work on time and without driving them crazy. As a product owner or project manager, that makes it worth its weight in gold right there!

This is a good book with lots of valuable information around the empirical nature of Scrum. For someone who was central to creating Scrum, the book doesn't offer much more.

It's broken up into three parts: Overview of Scrum / Why it works / Case studies.

The overview of Scrum is poor at best. There are much simpler ways to communicate it. If you don't know anything about Scrum then this book probably won't help get you started.

The "Why it works" chapters were much more interesting and valuable. It takes you through the epirical nature of scrum and why previous methodologies have failed. The most interesting part is the brief exposition around the psychological, anthropological and systematical viewpoints around Scrum. Like much of the book, this could have been written better and with more indepth information, but still meets a basic need.

The case studies and ancillary information in the last few chapters feel hasty and are of little value. Many of the examples (although based on actual events) feel contrived and are simplified so much that they aren't highly illuminating.

Overall the book wasn't the greatest but it did provide me with some value. The editing is quite poor and there are numerous mistakes throughout. The general layout of the page is also problematic and makes it difficult to read.

Most laughable however are the images and graphics. They look like they were made in MSPaint and screen capped into the book.

This book is a strange mixture of trendy agile methodology and dusty corporate management. My guess is that it has been hurriedly re-edited based on an old draft to try and catch the Extreme Programming (XP) bandwagon.

Scrum is fundamentally a management technique, aimed at getting the most from development teams. As such it shares some principles with the new programming methodologies but, tellingly, many of the things which can lower the stress and help make software development fun are absent. There's no "40 hour week", developers are encouraged to put in whatever is necessary, even if it means working all night. There's no "Pair Programming", and mere programmers are actively discouraged from contacting the customers or users to get instant answers and decisions.

Where Scrum scores is in heavyweight, bureaucratic organizations, and its team isolation techniques can help to get a more extreme approach off the ground. Be prepared to abandon it like a first-stage booster if you do want to get XP into orbit, though.

The production quality of this book is poor. The illustrations are laughable pixelated screen dumps, and the same information could have been got across in a book half the size.

If you are a team leader of a project in chaos, and need a way out, this might be just what you need. But don't ever forget that your team are people, not just "resources".

It does get the point of scrum across.

I'm now a convert.

But it could have been done in about 10 pages.

The figures are laughable. They look like poorly enlarged bitmaps and rarely convey anything useful or intelligible. They will make you angry.

The formating of the text is confusing and short on structure. It's as if the editors had never heard of bullets.

Finally, the cost of the book is absurd for what could be condensed into a pamphlet.

In summary, you can learn all you need about scrum from browsing the internet.

ASDS is a very good book, but only for the few who want to be Scrum experts. The material is thorough, and not necessarily easy to get through, in part because the Schwaber and Beedle walk through every part of Scrum in detail, as well as cover situations that likely don't apply to most, and they even go through philosophical views that some may care little about. To be sure, there are gems in the book, and I learned a few important points, but I have been to ScrumMaster certification training, read two other agile books, and been mentored by a CSM/PMP. I feel the book only moved me from 80% comfort level with Scrum to 85%. If you are a consultant managing projects, or you want to teach, coach or train in this area, read the book. If you a internal project manager,product manager, or IT manager, I recommend you get Agile and Iterative Development: A Manager's Guide (The Agile Software Development Series)and read the section on Scrum. It's simpler, cleaner, and the rest of the book gives good background to agile and options you may want to consider. If you are a team or development lead, or the senior developer, get Agile Project Management with Scrum (Microsoft Professional). It's an even easier read, focussed solely on Scrum and gives lots of enjoyable stories of real situations the author went through, good and bad.

A very practical guide, with easy to follow steps, great motivating arguments, and a logical presentation style make this book really work, especially given its short length. I also really enjoyed the examples given of team transitions. SCRUM itself is a very useful methodology for certain types of projects, and this book makes it clear what those projects are and how to adopt it for them.

On the bad side, the style change is pretty obvious and jarring when they switch authors, and some of the other-author chapters are interesting, but not necessarily as useful.

Missing from the book is a description of how to get buy-in and how to convince folks using a current process to switch (i.e. how to make and express a logical decision between two processes). It also neglects a bunch of the people issues, such as how to prioritize in career development, training, or even team-building / morale events. The book claims to be about the people and energizing them through shipping products, but I really think that's only one part of making your developers happy. A very important one, mind you, but not the only one.

If you've survived software projects that have gone schizophrenic after doing a lot of up-front planning, you may find that chapters 2 and 5 are worth the price of the book. Those chapters compare two process control models: the "defined" model, which is the basis for most methodologies, and the "empirical" model, which is the basis for SCRUM. Knowing the difference between these process control models, and their implications when applied to software projects, is essential when trying to understand why so many projects fall apart under pressure, and why Agile techniques, including SCRUM and XP, are improvements on the way we've been doing business.

Ignore the few faults this book has (it could have used a thorough copy-edit pass, illustrations that weren't low-res screen shots, and a complete index), and you'll be rewarded with a book that dense in timely, useful information, with case studies to back the theory up.