- Series: Theory in Practice (O'Reilly)
- Paperback: 226 pages
- Publisher: O'Reilly Media; 1 edition (July 13, 2008)
- Language: English
- ISBN-10: 9780596519780
- ISBN-13: 978-0596519780
- ASIN: 0596519788
- Product Dimensions: 7 x 0.7 x 9.2 inches
- Shipping Weight: 1 pounds (View shipping rates and policies)
- Average Customer Review: 40 customer reviews
- Amazon Best Sellers Rank: #1,123,924 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Other Sellers on Amazon
+ $3.99 shipping
+ Free Shipping
+ $3.00 shipping
The Productive Programmer (Theory in Practice (O'Reilly)) Paperback – July 10, 2008
|New from||Used from|
Frequently bought together
Customers who bought this item also bought
About the Author
Neal Ford is an Application Architect at ThoughtWorks, a global IT consultancy with an exclusive focus on end-to-end software development and delivery. Before joining ThoughtWorks, Neal was the Chief Technology Officer at The DSW Group, Ltd., a nationally recognized training and development firm. Neal has a degree in Computer Science from Georgia State University specializing in languages and compilers and a minor in mathematics specializing in statistical analysis. He is also the designer and developer of applications, instructional materials, magazine articles, video presentations, and author of the books Developing with Delphi: Object-Oriented Techniques (Prentice-Hall, 1996), JBuilder 3 Unleashed (Sams, 1999) (as the lead author), Art of Java Web Development (Manning, 2003), and No Fluff, Just Stuff Anthology: The 2006 Edition (editor and contributor). His language proficiencies include Java, C#/.NET, Ruby, Object Pascal, C++, and C. His primary consulting focus is the design and construction of large-scale enterprise applications. Neal has taught on-site classes nationally and internationally to all phases of the military and to many Fortune 500 companies. He is also an internationally acclaimed speaker, having spoken at numerous developer conferences worldwide.
Try the Kindle edition and experience these great reading features:
Read reviews that mention
Showing 1-3 of 40 reviews
There was a problem filtering reviews right now. Please try again later.
While I don't like giving negative reviews, I figured it would be useful to other potential readers to give a no-fluff review of the book -- here we go:
This book is a decent book for new programmers. If you're fresh out of college, and have never before done any sort of real programming work, you'd likely find this book a quick and review-ish read. Most of the content of this book is extremely obvious stuff, I could summarize most of the book by stating the following points:
- Optimize your computer to get work done (use hotkeys, learn your editor well).
- Automate boring stuff that wastes times (running Excel reports, etc.).
- Focus on what you're working on and try to maintain flow.
The above three points are discussed and primarily talked about in the first 1/2 of the book. The rest of the book is dedicated to well known programming principles which I won't get into here -- suffice to say, if you're a programmer, you've likely already heard of and used them.
For any experienced developer, this book feels... Like a recipe. It comes off (to me) as being a well planned book with good intentions, but that (unfortunately) ends up covering a seemingly small array of things and only lightly touching on each subject. While other great books like The Pragmatic Programmer spend a lot of time covering productivity principles in great detail, this book seems to skimp on the content and focus on brevity in less less interesting topics.
While I really wanted to love this book (I'm a junkie when it comes to programming productivity stuff), I simply can't recommend this book to anyone but new developers looking for a quick read.
Most of the book covers the mechanics of programming, the first part, describing tools can help, and how to use them. The writing style is technical and informative, but light and often philosophical. It has well placed and sometimes whimsical anecdotes and historical background.
The author provides really solid, common sense advice, examples and tips on things as diverse as encapsulation (do *you* automatically defeat it?), EJB's and JSF (complexity management), and testing (TDD, polyglot programming).
While the book is relatively "thin" by today's standards, there are no wasted pages -- and no unnecessary fluff. Every page is full useful information and examples, and Mr. Ford never loses sight of the bigger picture.
While some, including this reviewer, would point out the flaws in YAGNI (You Ain't Gonna Need It), Bertrand Meyer has done a much more complete and instructive example in his book on Agile.
Some of the tips of the book are restating the lessons of The Pragmatic Programmer; while the importance of that book cannot be understated, Ford goes one step further to explicitly spell out the good coding practices by recommending (usually open-source) tools to help your endeavors, including version control, code coverage tools, multiple clipboards, macros, emphasis on keyboard over mouse, and distraction reducers/eliminators, just to name a few. You might want to be by a computer when you read this books, as Ford supplies web links that are definitely worth checking out. Because the emphasis of the book is on modern languages, Ford also discusses some of the peculiarities that arise when using object-oriented programming as well as suggestions on how to prevent getting bogged down in overhead, making your code easier to read, and so on.
I definitely recommend this book. After finishing the book and test-driving some of Ford's recommendations, I can say that I've been a more productive programmer, even though I don't really code in Java or Ruby. I do wish there were a bit more discussion in terms of C/C++ or other older languages and scientific (number cruncher) applications, but nevertheless I did learn a great deal of helpful hints from this book.