Customer Reviews

Extreme Programming Adventures in C# (DV-Microsoft Professional)

5 star:		(10)
4 star:		(5)
3 star:		(1)
2 star:		(3)
1 star:		(3)

 

 

I am the author, so I'm rating the book three, not because that's what I think it is, but because it's in the middle. I'll see whether I can get a comment added as author or otherwise update the page when Amazon gets back to me.

It appears that the online content isn't what at least one reader wanted it to be. It's chronological by date, so that readers can follow along which files changed as we went forward, and it sounds like at least one reader wanted the final version. My mistake: I wasn't expecting that.

I'm not sure why -- the point of the book is to follow along on how we develop, not really to provide a handy-dandy XML editor -- but if this reader or any other wants a final snapshot of the files, they should email me at ronjeffries at acm dot org and I'll gladly send them along. And I'll see whether we can add another batch of files to the online content.

Thanks for the feedback.

First, what this is not:

1. This is not a textbook on eXtreme Programming
2. This is not a textbook on C#
3. This is not a textbook on .NET

This book is, instead, a narrative trip through developing a software project using the techniques of eXtreme Programming, writing in the C# langauage, in an effort to learn the .NET environment.

Ron Jeffries has been a leading advocate of (if not the founder of) the eXtreme Programming concept. Rather than talk more about eXtreme Programming itself (he has several books on eXtreme Programming listed on Amazon) he is using a new format in this book to get away from the heavy tutorial/lecture approach used in the other books.

He, pair programming with Chet Hendrickson some of the time, first goes out and buys some C# text books. The first step is to learn a bit about C# so he starts working on some of the examples -- I was glad to see that the first attempts (like most of my own) didn't work, and he got a not very helpful diagnostic -- this sounds like my learning a new language. Then as he says, "I fumbled around in Visual Studio a fair amount." Yup, I understand. A few dozen pages later, "Well, it almost worked, but it didn't." Been there, done that. Another few dozen pages, "Found a bug, Write a Test. But we don't know how to test that particular bug."

I suspect from this you get the idea about this book. It's got a friendly, chatty, open writing style and along the way passes along some pretty deep messages about the subjects of XP, C# and XP. I like the style, it may or may not be your cup of tea.

I learned to program back in the dark ages before books came with CDs or websites where you could download the author's code. Back then, if you wanted the author's code, you typed it in from the book. I typed in the code from many wonderful books and I learned to code that way. As I typed, I was paying attention to the code, not just mindlessly hitting the keys. While this taught me what a great programmer's code looked like when it was done, it didn't teach me how that programmer arrived at the solution that was in the book. What I always wanted was to see the author's thought process as he arrived at the finished code presented in the book.

With Ron Jeffries' "Extreme Programming Adventures in C#" I finally have that opportunity to watch over the shoulder of a great programmer and watch not only his code but, more importantly, how he thinks. I love that the author is willing to show his dead ends and false starts. And then how he recovers from them. The book is really language agnostic. It's in C# but the lessons are more about programming and thinking about programming than about a specific language. I highly recommend this to all programmers, not just C# programmers.

This is a hard-to-come-by book. I think it's especially useful for someone programmed for less than 10 years or not ever get trained by computer science. The book uses C# which I am very happy with, but it's more like "Extrme Programming Adventures" in any lanaguage.

I learned a lot from the technique delivered by the author, ex. test,test,always write a test before coding (Don't be lazy,it'll bite u back sooner or later if you don't). I can't appreciate this more after three days of practicing that I feel more comfortable to continue my three and half year fluid dynamics project now. Before doing this, I do test but I always test in "kinda of" state. Check it out, see if you code in that state, lol.

Futhermore, the way to write test for GUI application enlightens me too, 'cause I never actually write test for GUI and don't know how. If you have the same problem, the book has a solution for you.

Personally, the nice thing about the book is that the way he wrote the book makes me think he's no better than me when he's coding :) XP is not about how to design and setup the project( which I thought what it was, maybe there's another book for this), but several ways that can help you to code with more confidence without being a master.

It's a pleasure to watch a master at work. It's human nature to enjoy identifying with experts, whether you're picking up tips or just validating your own experiences. If you're a golfer, you probably love to watch golf on TV. If you (as I do) build furniture in your spare time, you'd love Fine Woodworking magazine. And if you are (as I am) a developer using the Extreme Programming methodology, you'll love this book.

In "Extreme Programming Adventures in C#", XP guru Ron Jeffries lets you pull up a chair next to him as he takes a small programming project from concept to delivery. Along the way, Ron learns the C# language, pair programs with several partners, makes mistakes, hurts his arm, and writes clean, well-factored code. In short, he acts like a real programmer with a real life that you'll be able to identify with easily. You'll see Test-Driven Design in practice, and watch as a complete customer-test tool is developed as an organic part of the project.

The most amazing thing about this book is that Ron checks his ego at the door. He doesn't try to hide his mistakes, but instead celebrates them as learning opportunities. The review at the end of each chapter examines what went wrong and what went right. This book validated many of my own experiences in using the XP methodology. If you're interested in how XP and TDD work in the real world, buy it now.

Ron's intention with this book is to show that iterative and incremental software development works. And that it works especially well on projects where requirements are evolving and/or the technical or even the business domain is new to the people doing the work. He refers to this way of working throughout the book. However, I think probably the only thing that I sort of disliked about the book is how profusely he apologizes for this seemingly simplistic, risky way of programming without any Big-Design-Up-Front. That irritation is likely due to the fact that I also consider this a very good way of creating software so it gets a little tiresome reading those same apologies over and over.

The book is written in a very conversational style that makes it an easy read and even though it kills a lot more trees I found it good that the code gets repeated throughout as it morphs into being. The writing is quite good and the way he tells his story is very captivating. One is able to feel frustrated, relieved, gloomy and victorious along with Ron because he makes you feel that this is your project too and almost as if you have a say in its implementation.

Ron has a lot of good advice to offer and he drops numerous great tips that any programmer would benefit from reading. These tips concern general design of software, programming techniques, planning, learning, estimating and listening to yourself and the code.

On the whole I feel a better software developer for reading it and I highly recommend it.

I've just read many of these review and can side with only a few of them. People who read this book to learn C# will be disapointed. Also people who read this book for a manifesto on XP/agile will be upset. But, if you read this book, looking for insight into a programmer's mind and how to develop good code and recover from unexpected (often self inflicted) problems, then this book is for you. I know C# pretty well, and I had the pleasure of reading David West's book before Ron's, but I must say that I think Ron did an excellent job. Proving his point -- that simple design, test driven development, and plenty of refactoring without expensive and time consuming up-front planning will work and work well. I learned alot. The only reason I gave it a 4, as opposed to a 5 -- and I would have loved to give it a 4.5, was because I thought there were a couple of chapters that could have been thorough, plus the author would sometimes go off and do some things and then clue you in by and oblique reference or say, "I was testing this yesterday yada yada". I would have liked to know up front what was done since the rest of the book was like a project diary. In all fairness, I suspect Ron left it out because it didn't add much value, but I want the whole picture when I'm involved in something. He could have provided a small sidebar that essentially said..."while you were out" and explained anything that had to do with the project that wasn't in the text. This would have been helpful. I would also have liked to see actual work times documented. In other words, how much time did it take to get story one done complete with Programmer Tests and Customer Tests, etc. It would be great if he chose to be more granular than that -- like how much time coding, testing, and planning, but that might be too much of a burden.
I'd highly recommend this book.

Ron provides the reader with a unique experience: pair program (albeit, silently) with one of the pioneers of extreme programming. For better or worse, the reader gets to watch Ron stumble (with tiny little steps) through developing a Windows application with an unfamiliar language.

I would not recommend this book to someone who has not already bought in to test-driven development and refactoring. Ron's narratives are quite verbose (which I enjoyed) and unless you already believe in how he is working, it might require a good portion of patience to wait for him to deliver his discoveries.

If you are someone who has tasted the power of simple design, iterative development, and refactoring, this book will deepen your understanding of these practices. I greatly appreciated the opportunity to see how Ron operates, it helped me better understand my own programming styles and habits.

This is an excellent book - it does what I believe it was intended to do. The walk-through of a full project using the test driven approach is a very unique insight into this practice. You can read methodology books for weeks - but this book actually shows you how to apply the methodology. It gets a little terse at times, but is otherwise a technical book you can actually - read - and get lots out of. It's definately not a reference, but that's not the intention. It's also not built to provide source code to an XML Editor, it's designed to show you how the code was built over a lengthy amount of time to arrive at an XML Editor. These reviews should be on the content and intended goals of the book. Good job, Mr. Jeffries

Ron Jeffries often provides the line "I'm giving the best advice I have.
You get to decide if it's true for you." as a signature for his many newsgroup posts.

And the same is true for this book. Ron is giving you the very best advice he can based
on his experience as a both a programmer and advocate of XP.

I would describe this book as "quietly looking over Ron's shoulder" and is about as close
to getting inside Ron's head as you're probably going to get without actually working along
side him.

I did not find this to be a specific "learn C#" book and I suspect that if that is what you
are wanting that you may be disappointed. If your are new to C# you may need a C# reference
book or two close at hand. I did find it to be a good book illustrating "how to learn C#",
or in fact how to approach learning any new language.

I actually work in Java and so applied the principles to a Java application instead.

Another thing I liked about this book is that Ron makes mistakes! And he left them in print!
And although he may come to regret that later :-) it is of tremendous value to the reader.
All too often programming books show code going from A to B to C and the reader is left to
guess what lead the author to take the direction that they did. With this book you get to
closely follow Ron's thought processes and see the results. You sometimes see the results
refactored, and sometimes refactored again. But you are never at a loss to wonder "why he
did that" or "how did we just get to here from there".

One of the key techniques used in XP is Test Driven Design and of the examples used in books
so far I have found it somewhat difficult to get a feel for how the practitioner applied their
"design sense". In most cases this is because the book is focussing on the technique alone.

What I really got out of this book was how Ron uses his sense of design coupled with the
techniques of XP (as they applied to this development situation). A great read!