|
The Pragmatic Programmer: From Journeyman to Master (平装)
by Andrew Hunt, David Thomas
| Category:
Software development, IT, Technology |
| Market price: ¥ 448.00
MSL price:
¥ 428.00
[ Shop incentives ]
|
| Stock:
Pre-order item, lead time 3-7 weeks upon payment [ COD term does not apply to pre-order items ] |
MSL rating:
 Good for Gifts |
| MSL Pointer Review:
A classic reading on programming ranking with Code Complete and The Mythtical Man-Month. |
| If you want us to help you with the right titles you're looking for, or to make reading recommendations based on your needs, please contact our consultants. |
|
| |
AllReviews |
1 2   | Total 2 pages 16 items |
|
|
Kent Beck (author of Extreme Programming Explained: Embrace Change) (MSL quote), USA
<2007-01-10 00:00>
The cool thing about this book is that it’s great for keeping the programming process fresh. The book helps you to continue to grow and clearly comes from people who have been there. |
|
|
Martin Fowler (author of Refactoring and UML Distilled) (MSL quote), USA
<2007-01-10 00:00>
I found this book to be a great mix of solid advice and wonderful analogies! |
|
|
John Lakos (author of Large-Scale C++ Software Design) (MSL quote), USA
<2007-01-10 00:00>
The wisdom and practical experience of the authors is obvious. The topics presented are relevant and useful... By far its greatest strength for me has been the outstanding analogies - tracer bullets, broken windows, and the fabulous helicopter-based explanation of the need for orthogonality, especially in a crisis situation. I have little doubt that this book will eventually become an excellent source of useful information for journeymen programmers and expert mentors alike. |
|
|
Daniel Schreiber (MSL quote), USA
<2007-01-10 00:00>
Andrew Hunt and Dave Thomas present what are humbly referred to as `tips' towards better software development. In principal, these two guys present a well put together argument that software development is a craft meant to be honed by craftsman (thus the secondary title, `from journeyman to master'). Truly, these two understand what it is to be an egoless developer destined for greatness and have captured the essence in a concise set of rules to follow.
Most notably is the DRY axiom (don't repeat yourself) which, although simple, encompasses so much that is bad in software projects on many levels that it leads the book off as a key tip (and is referenced further in as well). Others including understanding orthogonal code and ubiquitous automation are equally as pivotal. These authors clearly understand their terrain and think the way you want your developers to think.
On rare occasion, one of the tips provided seemed oddly out of the realm of what I would consider "key, generally applicable advice." An example was the blackboard or clue bag concept seemed a little off base for a book on programming and didn't provide me with enough concrete strings back to the rest of the tips to make me understand why it was included.
The book includes helpful cross-references allow similar subjects to be quickly found when there is topic crossover (happens a lot). The pull out in the back with the tips quickly provided for reference re-enforce how simple it really is and reminds one that we can all improve. Also, there are lots of references to other good material as a launching point for anyone choosing to make software development their profession.
Overall, a must-have book for the professional developer regardless of domain or technology. Ranks up there with The Mythical Man-Month and Code Complete as a classic. |
|
|
An American reader (MSL quote), USA
<2007-01-10 00:00>
Every programmer should be required to read this book. Junior programmers should read it (at least) annually until they fully understand it. I've been a programmer for 10 years. 1/2 of the book reinforced ideas I alredy held. The cooresponding copy should help me to educate those with whom I've typically battled over such concepts (managers, marketing, other programmers). 1/8 of the book validated some theory I've wanted to test; 1/8 seemed as though it might not directly apply to the language I program in most often; 1/4 just about blew my mind. The 15 or so hours I spent reading this book was some of the best time spent for me, education-wise over the last 2 years. I literally couldn't sleep the night I finished it thinking about implementing some of the ideas expressed within. To the authors: Thank you. |
|
|
Adam Kahtava (MSL quote), USA
<2007-01-10 00:00>
The Pragmatic Programmer should be read by anyone involved with the software industry. The tone of this book is casual and often humorous making it fun, enjoyable and easy to read.
As the title implies, this book is targeted towards the programmer or developer (the construction phase of software engineering). The text outlines principals and practices that are common sense, but that every practitioner SHOULD be aware of. However, in reality most of these principals and practices are overlooked. The book borders on the obvious, but keep in mind that "the obvious ... is never seen until someone expresses it simply." (Kahlil Gibran) The authors express good programming principals, outline the collection of tools every practitioner should have, and offer priceless advice in a simple manner.
I found the authors offering a lot of "Hows" and "Whats" with out answering the "Whys". Code Complete answers most (if not all) of these questions and in doing so, is three times the size. The Pragmatic Programmer is also somewhat short-lived - a new edition should be in the making. For example the collection of tools described within the text is changing (Subversion seems to be replacing CVS, etc...).
It's interesting to note that both authors (Andrew Hunt, David Thomas) are authors of the Agile Manifesto, and have a series of Pragmatic Programming books (Pragmatic AJAX, Agile Web Development with Rails, Programming Ruby, etc...). Their other texts are equally humorous and easy to read.
The Pragmatic Programmer makes an excellent prerequisite to Code Complete. I can attest the Pragmatic Programmer will help you become a better programmer" (Preface), but reading additional software engineering resources will make you an even better programmer. |
|
|
Andrew Violette (MSL quote), USA
<2007-01-10 00:00>
This book has a lot of good advice. Here's some of my favorites:
- DRY (Don't Repeat Yourself). So much unmaintainable code is written when you copy-n-paste stuff around. The pragmatic programmer goes out of his way to minimize the amount of code, testing, and documentation that is duplicated. I think if you take one thing away from this book...take this advice.
- Design techniques, such as DBC (design-by-contract) that make sure that you define the pre-conditions, post-conditions, and invariants for each method or function you define. This stuff is inherent in Eiffel, but he also talks about a Java library called iContract which accomplishes the same thing in Java. Thinking about coding this way makes it easier to define tests and conveys to the caller the state the system should be in when the code is executed.
- Know a scripting language. A lot of programmers see PERL, Python or Ruby as something that sys admin's use. However, these can be very powerful tools in your toolchest if you ever need to manipulate text, files, system resources, etc.
- Minimize coupling. I know we all know this...but it doesn't hurt to repeat it. |
|
|
Kyle Williams (MSL quote), USA
<2007-01-10 00:00>
This is the best text ever produced for a junior software developer. It touches on the value of almost all current developments in the software creation process and technology and most importantly, why they are valuable. It does not provide the details of any specific technology but instead describes the theory behind why a practice or current technology is popular/good. This allows the intelligent reader to apply the principle to a broad range of situations instead of one aspect of computing. Not suprizingly, the authors advocate writting code that fits that discription as well. |
|
|
Dakkak (MSL quote), USA
<2007-01-10 00:00>
This is the best book that I have read thus far on the practice of programming. The pragmatic programmer provides invaluable advice to those who are just starting to program, and those who have been programing for years. By following the authors' simple rules you should have gained some programming wisdom that a programmer would realize in a decade.
There are a couple of things that I think the book has done right:
1) The book is supplemented with code and examples that let the author present the topics better. So it is not just an essay, it is a programming guide
2) There are questions at the end of each chapter that ask you what would you have done in some situation; better yet all the questions have been answered
3) The book has been written and was organized in such a way that you would not need to read the entire book to understand what you want to understand. There is also little cruft
4) The book's key points are listed in the end so you would have the book's wisdom on one page at all times. |
|
|
A British reader (MSL quote), UK
<2007-01-10 00:00>
The Pragmatic Programmer is the book all programmers should have to read before they are unleashed onto your source base.
The book is nice and terse, covering the ground it needs to cover in little over 250 pages. Clearly the authors are applying the lessons they learnt from Unix, Perl, c++ and a variety of other sources. Rather than wasting words trying to beat home their lessons, the authors have trusted that the reader has some degree of intelligence. They present each nibble of wisdom in a few paragraphs of pithy text which helps to support the 70 tips they provide throughout the book.
The book covers a fair degree of ground in it's 258 pages. Testing, documentation, automation and even requirements specifications all get a look in. Most of the book however, is devoted to that part of the art which is harder to define and learn. It is usually learnt from painful experience, or passed on by a senior programmer if you are lucky enough to have one around. It is this knowledge that makes the book worth the read.
It's value is not so much that you will find anything revolutionary inside the book, you wont, but that the book provides a terse and approachable font of wisdom for programmers of all skill levels. It is filled with the sort of sensible advice that stops you getting third degree burns while cooking, or cutting your hand off while doing woodshop. Managing to convey that knowledge without sounding preachy or ivory tower in nature adds to it's charm.
This book will be required reading for all the programmers on my team at work. It will help them to understand the bigger picture of development, rather than focusing on the minutae of cutting code.
|
|
|
|
1 2 | Total 2 pages 16 items |
|
|
|
|
|
|
