Books & Videos

Table of Contents

  1. Chapter 1 Introduction

    1. Why a Book on Programmer Productivity?

    2. What This Book Is About

    3. Where to Go Now?

  2. Mechanics

    1. Chapter 2 Acceleration

      1. Launching Pad
      2. Accelerators
      3. Macros
      4. Summary
    2. Chapter 3 Focus

      1. Kill Distractions
      2. Search Trumps Navigation
      3. Find Hard Targets
      4. Use Rooted Views
      5. Use Sticky Attributes
      6. Use Project-Based Shortcuts
      7. Multiply Your Monitors
      8. Segregate Your Workspace with Virtual Desktops
      9. Summary
    3. Chapter 4 Automation

      1. Don’t Reinvent Wheels
      2. Cache Stuff Locally
      3. Automate Your Interaction with Web Sites
      4. Interact with RSS Feeds
      5. Subvert Ant for Non-Build Tasks
      6. Subvert Rake for Common Tasks
      7. Subvert Selenium to Walk Web Pages
      8. Use Bash to Harvest Exception Counts
      9. Replace Batch Files with Windows Power Shell
      10. Use Mac OS X Automator to Delete Old Downloads
      11. Tame Command-Line Subversion
      12. Build a SQL Splitter in Ruby
      13. Justifying Automation
      14. Don’t Shave Yaks
      15. Summary
    4. Chapter 5 Canonicality

      1. DRY Version Control
      2. Use a Canonical Build Machine
      3. Indirection
      4. Use Virtualization
      5. DRY Impedance Mismatches
      6. DRY Documentation
      7. Summary
  3. Practice

    1. Chapter 6 Test-Driven Design

      1. Evolving Tests
      2. Code Coverage
    2. Chapter 7 Static Analysis

      1. Byte Code Analysis
      2. Source Analysis
      3. Generate Metrics with Panopticode
      4. Analysis for Dynamic Languages
    3. Chapter 8 Good Citizenship

      1. Breaking Encapsulation
      2. Constructors
      3. Static Methods
      4. Criminal Behavior
    4. Chapter 9 YAGNI

    5. Chapter 10 Ancient Philosophers

      1. Aristotle’s Essential and Accidental Properties
      2. Occam’s Razor
      3. The Law of Demeter
      4. Software Lore
    6. Chapter 11 Question Authority

      1. Angry Monkeys
      2. Fluent Interfaces
      3. Anti-Objects
    7. Chapter 12 Meta-Programming

      1. Java and Reflection
      2. Testing Java with Groovy
      3. Writing Fluent Interfaces
      4. Whither Meta-Programming?
    8. Chapter 13 Composed Method and SLAP

      1. Composed Method in Action
      2. SLAP
    9. Chapter 14 Polyglot Programming

      1. How Did We Get Here? And Where Exactly Is Here?
      2. Where Are We Going? And How Do We Get There?
      3. Ola’s Pyramid
    10. Chapter 15 Find the Perfect Tools

      1. The Quest for the Perfect Editor
      2. The Candidates
      3. Choosing the Right Tool for the Job
      4. Un-Choosing the Wrong Tools
  4. Chapter 16 Conclusion: Carrying on the Conversation

  1. Appendix Building Blocks

    1. Cygwin

    2. The Command Line

  2. Colophon