Rating: 
Summary: Develop Good Habits
Review: There is nothing worse than sloppy code! You can dress sloppy, you can speak sloppy, you can live in a pig's sty, but please don't develop sloppy code for other's to take care of.Read this book and follow the suggestions, and you will place yourself on the elite side of the bell curve with respect to your programming skills.
Rating:
Summary: A Gem to add to your library...
Review: Incredible. It is true, experienced or newbie - this book is a definite must read for the serious software developer. Practical advise from obvious gurus in the industry. These men are serious about giving you real, solid and invaluable knowledge about bettering yourself as a professional. The information can be applied to whatever language, platform or design you are using.
There are a few reviewers here who rated this book low. To these individuals I say "Hey, I think you missed the point by a mile!". This book is meant to give you some solid development "food" to digest. Every single page is worth the read from top to bottom. In a single summary, you are only doing yourself GOOD by reading this book. Don't agree with a particular point? Well, fine! Turn the page and continue on to the myriads of other valuable points and lessons. A waist of time or harmful, are two statements that do not even belong to the most general reference of this publication...for shame.
Trust me, take the time to read this book and add it to your collection, you'll be glad you did.
Rating: 
Summary: mostly a waste of time
Review: The very first tip of this book is worth reading "tip 1: care about your craft". From there it goes down hill, never really focusing on anything in particular, it tries to be a general guide to good programming practice, but also teeters dangerously on the edge of a self-help guide. "tip 5: be a catalyst for change", "tip 10: its both what you say and how you say it".
The carpenter analogy is so old and tired. Technology and software development are based on scientific research at the university level, and a lot of really smart people outside academia. If you want to be great, read what they have to say, (and not 2 dweebs who tell you to think about your editor as a plane or saw) There is something disturbing about this book thats hard to pin down. If you're a serious developer you might know the type of programmer this book appeals to. Its usually the sweaty perl programmer with a flannel shirt on in your shop with a lot of philosophies about development. They write 8 lines of impossible-to-maintain hieroglyphic and call it an application. If you're a serious developer working in a current platform like J2EE, don't get this book...its harmful, coming up with pointless new terms like "orthogonality" which just add more junk terms to the programming community. They also recommend you learn a new language every year, as if it weren't difficult enough to keep up with one enterprise level platform. This book has a very dated quality in that respect. It does get to some current development issues like refactoring, but glosses over them completely. If youre new to programming maybe its a good idea to give it a try. There are a few points that make sense, but if you're not completely hopeless you should eventually discover them on your own.
Rating: 
Summary: Nicely done
Review: Most software engineers don't have the opportunity to spend time with their colleagues and just talk about the craft of software development. While you can't have a conversation with a book, Andrew Hunt and David Thomas will talk if you will listen--and listen you should.
The Pragmatic Programmer is a collection of ideas, observations, and recommendations for software developers. Throughout the book, they highlight these notions in a set of numbered tips, about 70 of them, which are collected on a single tear-out card situated in the back of the book. Just reading the tips, without reading the text of the book, might make these gems seem trite, empty, and obvious. But, they're not!
Many of the tips actually build upon previous ones, like tip 4: "Don't live with broken windows", which urges programmers to fix problems and clean up messes, and tip 20: "Keep knowledge in plain text." With some books like this you can skip around--but this one is better read from beginning to end.
There is plenty of ideas to consider, agree with, and, perhaps, disagree with, too. You can also feel a little passion. "Conventional wisdom says that once a project is in the coding phase, the work is mostly mechanical, transcribing the design into executable statements. We think that this attitude is the single biggest reason that many programs are ugly, inefficient, poorly structured, unmaintainable, and just plain wrong." Hooray for authors who take a stand and then back it up with well reasoned arguments!
Reading this book isn't a substitute for having that conversation with a colleague about the craft. But, The Pragmatic Programmer is worth listening to in the mean time. It is a good, solid, fun read.
Rating:
Summary: An enjoyable read--makes you _think_ about how you work
Review: When I first came across this book, I'd been a professional programmer for four years. In that time I adopted certain habits, styles of coding, that just seemed to make sense. But this book brought those techniques into sharp, formal relief. It showed me why they were right, and, in some cases, why I hadn't taken them far enough. After reading this book I understood my craft better. I learned to think not just about the work itself, but the assumptions I had made in diving in to it. I learned to think about and improve my approaches to the work. I was able help the team breath more quality into our software. It's a year later, and I've purchased a copy of this book for each member in my development team, paid for from our training budget. I was desparate for them to understand the idea of 'writing shy code' (a.k.a. separation of concerns), and of fixing 'broken windows' (don't let defects go! fix them before they accumulate) among other practices of experienced programmers. This book delivers a powerful dose of common sense for anyone who creates and successfully delivers software for a living. As a bonus, you get a pull-out sheet of the authors' tips and tricks. You won't regret adding this book to your library.
Rating:
Summary: Practical reminders of solid experience - it is a classic
Review: Based on the reviews here, I bought this book . I have programmed for over 20 years, in multiple languages, multiple operating systems, from mainframes, client server environments, and on personal computers both text based and GUI based. Programming has always been a craft to me, and I have always enjoyed someone who could explain it clearly in simple terms, as it envokes a pride in the work I do. And helps everyone strive to do their best. Repeatedly reading the book, I thought, "Yes, this is the way it is done, and should be done - what a great way of saying it". This book does state things that should be obvious to someone whose career has been built around programming, and it restates those understandings in a clear fashion that others can grasp and use for their understanding. They are things that need to be said, and are very practical reminders from solid experience of how to go about the craft of programming. The bias to text only systems, perhaps due to the authors UNIX background(?), left me feeling a little left out. Otherwise this book would certainly be 5 stars. The book encourages programmers to strengthen what they know and broaden their horizons and skills. Examples are in C/C++ and Java, and if someone did not have a background in those, they might be a little lost. I would say that any beginning to intermediate programmer could certainly benefit from this books message. If someone has been at the core of package development, yes, they should already know this - and this book is a great reminder of the principles of being a great programmer. Reading the book may help someone get there. I did feel that there are things I learned from this book that with the cross references helped me to explore areas that I have not been exposed to, and for me programming is a constant learning experience - which is one of the principles the book reinforces. We are always looking at new ways to be more effective - and learning what is the best of what is available is part of that. It does not hurt to have a reminder of what is a good practice. The Pragmatic Programmer is a classic programmers book for programmers of any age,language, or operating system.
Rating:
Summary: A unique treasure - real substance with a breezy, fun style
Review: There are hundreds of books out there about computing - most of them so dry that reading them is like reading a dictionary, and about as narrow in scope as the manual that came with my lawnmower. Those other books usually expouse a shallow perpsective that has one answer for everything - one answer that truly works for almost nothing. This book is radically different. Andy Hunt and Dave Thomas bring strong professional histories and a sparkling style to their book. This makes for a unique viewpoint on computing - a holistic one, where there isn't one pat, tired answer, but instead there's a rich, tested philosophy. They value pragmatism, as you might expect from the title - and that pragmatism is woven with a diverse and sometimes surprising set of very practical "tips". Unlike other "philosophical" works, this one has just the right amount of granularity - enough detail that the reader is sure to "get it", but not so much as to prescribe a specific coding solution. The authors respect their audience more than that. On top of the richness of the content, the very best thing about this book is the sheer fun of reading it. They have a fantastic sense of humor, and a clever, breezy style. I laughed out loud more than once reading this book, and smiled most of the rest of the time. This book has gotten rave reviews here and on other sites (slashdot, Dr. Dobbs, etc.). It is no wonder. The only bad review I've noticed made me seriously wonder if the reviewer had even opened the book. He suggested that Hunt and Thomas are too stuck on the tired benefits of up-front design. Nothing could be more incorrect. In fact, one of their strong philosophical tenets is built on refactoring - redesigning as you go, when needed, and letting design be "good enough". I seriously doubt that reviewer ever read this book - he certainly missed a great deal of its content. I'd have to agree with the vast majority of reviewers on this one - Pragmatic Programmer is already becoming a classic, and that honor is well deserved for a book which bestows a great deal of honor on this profession. Buy it - and actually READ it.
Rating: 
Summary: very disappointing!
Review: this book sat on my "to read" list for months and i finally picked it up based on the strength of reviews here on Amazon. what a disappointment!! the world really doesn't need another book extolling the virtues of thorough upfront design and intense testing without any specific (or even vague) plans for overcoming the traditional difficulties in realizing both those objectives. yeah yeah we know, if we dont design enough up front, we will pay in the long term anyway. enough, already. i was hoping for some creative and interesting ideas and was utterly disappointed. this book is no more than a crude compilation of half-baked ideas from any number of other similar books. if you're looking for something interesting, "the mythical man month" is a lot better, even though its dated. "inmates are running the asylum" by alan cooper is also great in that it creatively and productively challenges many of the old saws that books like "pragmatic programmer" trot out time and time again (i particularly like Cooper's rant against letting customers dictate design decisions and product paths).
Rating: 
Summary: Worth a read
Review: This is a decent but not spectacular book, which is written as a series of 46 five to ten page articles on various programming topics, such as "Orthogonality", "Design by Contract" and "The Requirements Pit". The segments are quite heavily cross-referenced (which I didn't find very useful).
The authors dole out a lot of solid advice, which is the book's strength. I found myself disagreeing with very little. There are memorable tips and some good stories. The writing style is also very accessible and conducive to diving in at any page.
The book seems a bit lightweight. The exercises are a little simple and I don't think you'll find yourself going back to this book a lot. Also, the typeface is annoyingly large.
I'd recommend this to someone who has done some programming and understands the syntax and fundamentals but hasn't gotten into programming larger pieces of software. I think that if you have programmed anything significant you won't find much new in here.
Rating:
Summary: Great Advice for Journeyman Programmers
Review: This book is great for those who are new to professional software development such as recent college graduates or those who have moved from other disciplines into programming. From suggestions on how to take pride in one's work to how to improve one's understanding of the art and science of programming, this book can open the doors to mastery of software development. I would recommend this book to recent college graduates, programmers who only know one programming language, and programmers who know only one development platform or operating system.
| 
