《卓有成效的程序员》(The Productive Programmer)

Anyone who develops software for a living needs a proven way to produce it better, faster, and cheaper. The Productive Programmer offers critical timesaving and productivity tools that you can adopt right away, no matter what platform you use. Master developer Neal Ford not only offers advice on the mechanics of productivity-how to work smarter, spurn interruptions, get the most out your computer, and avoid repetition-he also details valuable practices that will help you elude common traps, improve your code, and become more valuable to your team. You'll learn to:
　　* Write the test before you write the code
　　* Manage the lifecycle of your objects fastidiously
　　* Build only what you need now, not what you might need later
　　* Apply ancient philosophies to software development
　　* Question authority, rather than blindly adhere to standards
　　* Make hard things easier and impossible things possible through meta-programming
　　* Be sure all code within a method is at the same level of abstraction
　　* Pick the right editor and assemble the best tools for the job
　　This isn't theory, but the fruits of Ford's real-world experience as an Application Architect at the global IT consultancy ThoughtWorks. Whether you're a beginner or a pro with years of experience, you'll improve your work and your career with the simple and straightforward principles in The Productive Programmer.　

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.If you have an insatiable curiosity about Neal, visit his web site at http://www.nealford.com. He welcomes feedback and can be reached at nford@thoughtworks.com.

Table of Contents
Chapter 1 Introduction
Why a Book on Programmer Productivity?
What This Book Is About
Where to Go Now?
Mechanics
Chapter 2 Acceleration
Launching Pad
Accelerators
Macros
Summary
Chapter 3 Focus
Kill Distractions
Search Trumps Navigation
Find Hard Targets
Use Rooted Views
Use Sticky Attributes
Use Project-Based Shortcuts
Multiply Your Monitors
Segregate Your Workspace with Virtual Desktops
Summary
Chapter 4 Automation
Don’t Reinvent Wheels
Cache Stuff Locally
Automate Your Interaction with Web Sites
Interact with RSS Feeds
Subvert Ant for Non-Build Tasks
Subvert Rake for Common Tasks
Subvert Selenium to Walk Web Pages
Use Bash to Harvest Exception Counts
Replace Batch Files with Windows Power Shell
Use Mac OS X Automator to Delete Old Downloads
Tame Command-Line Subversion
Build a SQL Splitter in Ruby
Justifying Automation
Don’t Shave Yaks
Summary
Chapter 5 Canonicality
DRY Version Control
Use a Canonical Build Machine
Indirection
Use Virtualization
DRY Impedance Mismatches
DRY Documentation
Summary
Practice
Chapter 6 Test-Driven Design
Evolving Tests
Code Coverage
Chapter 7 Static Analysis
Byte Code Analysis
Source Analysis
Generate Metrics with Panopticode
Analysis for Dynamic Languages
Chapter 8 Good Citizenship
Breaking Encapsulation
Constructors
Static Methods
Criminal Behavior
Chapter 9 YAGNI
Chapter 10 Ancient Philosophers
Aristotle’s Essential and Accidental Properties
Occam’s Razor
The Law of Demeter
Software Lore
Chapter 11 Question Authority
Angry Monkeys
Fluent Interfaces
Anti-Objects
Chapter 12 Meta-Programming
Java and Reflection
Testing Java with Groovy
Writing Fluent Interfaces
Whither Meta-Programming?
Chapter 13 Composed Method and SLAP
Composed Method in Action
SLAP
Chapter 14 Polyglot Programming
How Did We Get Here? And Where Exactly Is Here?
Where Are We Going? And How Do We Get There?
Ola’s Pyramid
Chapter 15 Find the Perfect Tools
The Quest for the Perfect Editor
The Candidates
Choosing the Right Tool for the Job
Un-Choosing the Wrong Tools
Chapter 16 Conclusion: Carrying on the Conversation
----------------------------------------------------------------------------------------------------------　
中文简介：
本书讲述如何在开发软件的过程中变得更加高效。同时，本书的讲述将会跨语言和操作系统：很多技巧的讲述都会伴随多种程序语言的例子，并且会跨越三种主要的操作系统，Windows（多个版本），Mac OS X以及 *-nix（Unix或者Linux）。
本书讨论的是程序员个体的生产力，而不是团队的生产力问题，所以它不会涉及方法论（好吧，可能总会在这里或那里谈论到一些，但肯定不会深入讨论）。同时，本书也不会讨论生产力对整个团队的影响。我的使命，是让作为个体的程序员通过掌握恰当的工具和思想变得更加高效。

豆瓣书评：
英文：http://www.douban.com/subject/3073403/
中文：http://www.douban.com/subject/3558788/