Customer Reviews

The Productive Programmer (Theory in Practice (O'Reilly))

5 star:		(17)
4 star:		(12)
3 star:		(4)
2 star:		(1)
1 star:		(0)

 

 

This is a terrific book for boosting your productivity in two areas: how you work, and how you code.

The first section of the book, Mechanics, focuses on tools you can use to boost your productivity as you're working with your system. Ford launches off into an exploration of lots of little crazy tools that help you automate or ease repetitive tasks. You'll find lots of goodies from virtual desktops to shortcut tips/launchers, to using Ruby to script everything from splitting up SQL to automatically sorting your laundry and washing it for you.[1]

All these little tools and tricks add up to drastic decreases in the amount of friction you're forced to suffer through while doing your daily job. Cutting this friction lets you focus on the job at hand, instead of trying to bend your environment to your will.

The second section of the book, Practice, discusses ways to speed your development. There's an awful lot of goodness in this portion of the book, ranging from re-emphasizing critical aspects of object oriented programming, to object and method composition. Ford walks through a lot of great stories meant to get you to re-evaluate why you do things a certain way. The infamous Angry Monkeys story gets pulled out as an example, and Ford also concisely covers development principles like the Law of Demeter, Occam's Razon, and his Polyglot Programming meme.

The book's concise, amazingly well written, and a definite must-have for your bookshelf.

I've been reading Neal's blog for a while. So I've been looking forward to the book. (I even accidentally ordered it twice - one was the pre-buy at amazon, which I forgot about).

I spend the last two days reading the book and found it quite helpful. There are a lot of concrete tips and examples for immediate use and daily improvement of your mechanic skills. Many of the experiences regarding the effective use of the tools at hand that he describes are well known to me. I can't really understand how developers are not keen to improve their productivity.
Neal's book is a good addition to the PragProgs masterpiece. It concentrates more on the mechanics and on some principles of productive software development. So the triad of values-principles-patterns got a son named mechanics.

What I missed in the book was:
* a comprehensive list of the notes at the end.
* Christopher Alexanders appearance as one of the philosophers.
* the notion of cheat sheets/refcards
* references to Martin Odersky's Scala the scalable language
* references to Kent Becks "Implementation Patterns" (especially in the SLAP section)

As being a developer myself I was a bit disappointed by the quality of the examples (the solutions not the starting points) and a bit by the correctness of the text (typos). I spotted several errors, some bad designs and some uninformed choices even on the first read of the book. I'll post them to the errata page.

Neals suggestion of an online repository of productive programmers tools, tips and mechanics is a great idea. I'd really like to join this effort.

Michael

http://creating.passionate-developers.org

I saw Neal the first time at DLW Europe. I'd like to check out the speakers online before deciding which talks to attend - the results were not positive at all; IT consultant (we've had our share at work) + spending lots of time speaking on conferences, that's a combination not likely to give me warm feelings. I still ended up in attending his talk because of lack of alternatives and thank god I did. Neal isn't only a great speaker but he also had something to say and the necessary experience and war stories to back it up. I ended up by attending every presentation of Neal plus - back at work - giving a presentation of his talks to my fellow co-workers.

Finding out that he now has written a book - I instantly had to read it. And the book is certainly a valuable read that I'll keep around as reference at least for a while. There's lots of great tips about tools, automation, ... that will certainly find their way into my professional life. However, it did not blow me off my feet. I've read "Pragmatic Programmer - From Journeyman to Master" before (a perfect book in my opinion) and this book does not quite measure up to it. The style is not as perfect - the information not as well-presented. However what I miss most is that Neal sometimes present a topic but then does not follow up with "How to get started" - most notably with "Polyglot Programming" and "Test driven design". I know that both topics are maybe out of scope of the book but then at least a reference to another book, website, ... would have been great. So even if I'm all psyched to up try to apply this principles now at my current projects, I know from past experience that adding new languages in any mix more often result in time wasted time because of integration issues... and how to start TDD on a project that's been going on for 15 years without any unit tests is beyond my imagination.

Don't get me wrong - it's a great book and well worth the read; it just needs some polishing to get it to excellent...

This book was disappointing for me on several fronts. To be fair, I am a mainly a C programmer (some Python ), and maybe could not fully appreciate the Java/Ruby focus.

The first half of the book had some good tips about common tools that could make you more productive ( for example multiple clipboards ) and some generic advice ( avoid distractions, block off quiet time ). The second half of the book was more Java/Ruby centric based around some "laws" and "stories". The author is obviously a clever man but I didn't really benefit. This is not a big book and has a cobbled together feel that left me asking "is that all?" It's the first O'Reilly book I have bought that left me disappointed. I would recommend instead buying "The Pragmatic Programmer".

I expected a list of cool tips and tricks, but this book is much more. The Mechanics section organizes the tips into 4 broad approaches to productivity. This allows Ford to not only provide interesting tricks, but also help you think about ways to improve your personal productivity in ways that make sense in your environment.

Much of his advice contradicts the point-and-click, user-friendly mindset of many computer users and suggests that to be really productive you need to be able to take charge of the computer.

The second half of the book focuses on more high-level approaches to productivity. How do you make certain the code you write is the best it can be and solves the problem you need to solve? How do you avoid writing code that does not need to be written? How do you get the most out of your tools?

This book is a must read for programmers and other computer power-users. The first section gives many tricks that would apply for anyone who is trying to do a lot of work with a computer.

My only quibbles with the book are that I would have liked to see even more tips and I would have liked a bit more attention paid to Linux, which is where I spend most of my time. Many of the tools Ford recommends have versions for Windows or Mac OSX, but not Linux.

This is a great book about micro efficiencies and tools. It's a great source of information for analytical tools as well! (like coverage tools, bug finding tools, code analysis tools).

All in all, i loved it because there's no other book like it. A "must have" for any programmer's library right along side refactoring, legacy code, and 'the pragmatic programmer'.

This is one of those books that is on the 'must read' list for programmers of all skill levels...it fits easily on the same shelf as Code Complete and The Pragmatic Programmer. While other books focus on the principles of what to code, this book focuses on how to code, including what programs to use to assist in development and ease the eventual pains of debugging and improvement. Ford tries to be platform-agnostic by focusing on Windows, Mac OS, and Unix/Linux, but the Linux people do get the short end of the stick. Examples are discussed in terms of modern languages, but seemingly most of all Java and Ruby, so C/C++ and Fortran coders out there (including myself) will have to do a bit of thinking to take something practical away from some of the lessons of the book. Nevertheless, programmers of all languages and on all platforms will benefit from reading this book. Ford uses an easy-to-read and occasionally humorous tone that makes this book pretty easy to digest.

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.

This is an excellent book for professional developers. There are many concrete, specific suggestions for allowing you to work faster and more effectively. Also, there are numerous pointers to excellent, free tools. But the book is not just a random catalog of tips and tools; it includes an interesting discussion of various aspects of a general approach and philosophy of software engineering that is not tied to any particular development methodology.

One refreshing aspect of the book is that, although Ford refers to practicing several tenets of agile development, the writing is not doctrinaire.

I'd strongly recommend this book for anyone who writes code for a living.

I've been a fan of Neal Ford's for several years now, both from his blog and his presentations at No Fluff, Just Stuff conferences around the country. He has an engaging, easy-going style that works extremely well in person. Along with all the advice, this book demonstrates how naturally his style translates into book form, too.

Neal's recommendations run from low-level, practical advice (like how to use wget to cache web sites locally) to mid-level, broader recommendations ("when coding, always prefer the keyboard to the mouse"), to high-level philosophy ("don't shave yaks"). Best of all, his irreverent humor comes through on nearly every page.

Neal obviously loves being a developer, and while he has the natural cynicism that comes from long years in the trenches, this book is much more about helping programmers become successful rather than lamenting the sad state we're in. It's a great "work-arounds" book that I expect to revisit over and over again.

I have to admit I was initially worried about this book. I'm much more of a Java/Eclipse/Windows person than a Ruby/IntelliJ/Mac person like Neal, and I was concerned that his advice would come across as disapproving or worse. That wasn't the case at all. There were recommendations for everybody, including many that I've already put into practice and many more that I'll be working through in the future, especially as I transition to becoming a more Groovy/IntelliJ/Cygwin individual. :)

This book is excellent, and more than that, it's fun. I highly recommend it.

Simply brilliant - that's what this book is. Reading this book is like having Neal sitting next to you in a paired-programming session showing you exactly how to make your life as a developer more productive. The book is easy to read, conversational in tone, and very easy to follow. I recommend reading this book from start to finish to understand the concepts Neal is trying to get across. Then, starting over in front of your computer and rereading the book, directly applying his shortcuts and techniques. I applied this technique after giving up reading this book in the living room (too many dog-ear pages and "oh, I'll have to remember that one"). While Neal's examples are great, his concepts are even better. Live the concepts, find your own accelerators and focus techniques, and become a more productive programmer. Oh, and buy this book!