Ron Jeffries
1 Chatty, Witty Style that Teaches Several Lessons
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.
2 Really a good book for programmer of all levels
If you want to learn How C# works, just to buy another book about the syntax. But if you want to lear how to program, especially how to program with intention. I strongly recommend you to buy this book. It is the right book that a master programmer teaches you what programming really is and how to program efficiently.
3 Don't buy this book!
This book is the story of the author LEARNING HOW TO WRITE IN C#. This book will only teach you what went on while the author was learning. If you're going to buy a book, especially a how to book, buy one that is written by a professional in the field or discipline that you're trying to learn. While this author may be "Famous" in his own right, that doesn't make him the most qualified C# teacher. Bottom line -- Don't pay for this author to learn how to program in C# -- don't buy this book!!!
4 Very Frustrating Inputting the Code
I want to start out by first saying that the topic is wonderful.
Since I'm not currently working I thought I would actually put the code in and really learn these new techniques. To my dismay, the code is riddled with problems. So don't expect the code to work.
I've made it to chapter 7 and I'm extremely frustrated. I end up having to flip through the book to find other references to a method to see if it might help solve the compilation problems. This would all be fine, but the author has stated that he expected readers to put the code in as we went. That's why he didn't provide the final files.
Here are some examples of what I'm talking about:
1. page 31: image It's showing a menu. No menu has been created.
2. page 44: XMLKeyDownHandler method. Refers to textbox. It should be txtbox. (occurs 4 times)
3. page 45: First line of code. It's wrong. It is right in Chapter 5 but it doesn't work here.
4. page 46: same as #2.
5. page 63: Code won't compile. InsertControlPText is crashing. I decide just to comment it out.
6. page 63: Code won't compile. Problem in NewSelectionStart. I decided to move on because I see it's getting reworked later.
7. page 67: current code sample.
a. InsertControlPText has appeared but with no code.
b. LineContainingCursor has changes that were never talked about.
c. Appearance of Enter() method (find out why in Ch. 6)
d. Appearance of TestText method (what is it?)
e. Appearance of TestLineContainingCursorDirectly method
8. At the end of chapter 5 I still have two NUnit tests that are failing and I'm not exactly sure if they should be failing or not.
What I am very surpised about is that Microsoft would publish a book with so many mistakes in it. I'm also surprised they would allow references and links to restaurants (see page 76).
The theory is wonderful. I will finish the book but I'm going to stop trying to type in the code. It's just taking to long to work through the bugs in the book.
5 I'm giving the best advice I have
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!
6 A very good book!
If you want to learn C#, don't buy this book. If you want to become a better programmer, this book can probably be of considerable help to you. This book is about Extreme Programming. The only way it can be really shown how XP works is of course in practice. In my opinion Ron Jeffries has succeeded in coming very close to letting the reader be an observer of a real XP project. You get a good feeling for how things should be done, what to avoid, etc. We know some of those things already, of course, because there's no black magic involved, but Jeffreys at the very least makes us more conscious of them. After having read this book, I've become convinced that all those people who are shouting on top of their lungs that XP is just a fancy name for something very shallow, are probably wrong and that they should at least give it a serious try before condemning it.
7 This is a good book, which makes it's point
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.
8 Private lessons from 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.
9 How to Learn while Producing Useful Features
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.
10 Enjoyable and informative (from the XP perspective)
This is a quality book that took a bit of getting used to. This isn't necessarily a bad thing, I read a lot of boring and straightforward trade publications and this was a bit different. Ron does a good job explaining the XP methodology while picking up the basics of the C# language. Initially, I was a bit frustrated as I have been using C# for years; however, the book picks up after the first quarter and becomes genuinely interesting -- a phrase I do not often use in regards to technical publications.
Areas I found particularly useful included: Unit Testing, nUnit, refactoring and XP in general. I would recommend this book to anyone who has some experience with C# but is new to extreme programming.
11 wordy
I bought the book for 3 reasons:
- C# (I was a VB.NET developer)
- eXtreme programming
- Unit Testing
Only Unit Testing did fulfill my expectations.
The book itself doesn't read easy. It contains a lot of text without telling much. I think the book could be reduced to 250 pages without loosing the strength of it.
The references in the book and some chapters were interesting.
They inspired me to test some new ideas.
The author knows his profession without any doubt, but I didn't get used to the way he wrote this book.
12 Extreme Programming Misadventures in C#
In spirit, the book covers Extreme Programming, but please don't expect the code to hold up. I would say if you want to learn C#, don't write a book to do it. Why should I pay Mr. Jeffries to learn the language (and it is evident that he did not learn it well), and get the same old comments about Extreme Programming that other books have given me?
I did find it comical that he states that he likes to keep things simple but when it comes to Xml, he would rather write an Xml parser / validator himself than to use what the platform provides. I guess the next thing we will see now that we have the editor, is a new operating system built from the ground up to prove that we need the editor :).
Save your money and buy another book in the series, and Ron... you owe each of us $50 for teaching you C#, but I will take $25 since you didn't seem to get a lot out of it.
13 Very engaging and useful
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.
14 Great book about how to think about programming
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.
15 Disappointing!
First perusal implied this might be a fun read. The book is certainly chatty and easy to read - very much like reading your young nephew's diary (not that I've read my nephew's diary, but you get my drift!). And that's its biggest problem - the rather juvenile "enthusiastic" style soon pales when you realise how low the "signal to noise" ratio of the content is. It seems ironic that this is part of a series Microsoft are calling "Microsoft Professional" when it seems so... well amateur! What you're paying for here is effectively the diary of someone completely new to .Net starting to write code (an XML text editor) without so much as a basic training course, documenting every tedious little thing he learns as he learns it. The author tries to convince us he is the customer, the designer, the trainer, the developer... and occasionally he consults his friend because after all Extreme Programming talks about developers working in pairs, but it all comes across as very Mickey Mouse and incredibly naive. If you've just taught yourself C# as your first programming language this "diary of a .Net newbie applying extreme programming methodologies" might be a fun read, but if you're an "enterprise developer" I suspect you're going to be pretty disappointed at how "amateur" the development project is and at how tedious the documenting of every little code change becomes when it goes on for page after page after page.
This may be an unfair review because it's written without having finished the book. I'm afraid that by Chapter 10 I'd realised that life's too short to spend time on so much "noise" for so little "signal". It seems odd to have released this title at about the same time as its "companion" series book "Object Thinking" as they are as alike as chalk and cheese ("Object Thinking" is a far better book for the enterprise developer in my view, albeit one with shock! horror! no code in it).
16 and I'll try to even things out
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
17 Online Content
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.
18 Abysmal Failure in Content
It would be nice if the content that is provided on the Website would actually include all the files necessary to validate the final version.
It's missing so many files that it took about an hour to recreate manuall from the book.
I just don't get it. All that time spent on the book and to put shoddy bits out for the readers. I question the author's ability and his whole approach to XP if he fails in this one great measure of quality - making sure it works when it gets to the users.
