Quotes from Andrew Hunt

We who cut mere stones must always be envisioning cathedrals.

Don't Gather Requirements—Dig for Them

In an abstract sense, an application is successful if it correctly implements its specifications. Unfortunately, this pays only abstract bills. In reality, the success of a project is measured by how well it meets the expectations of its users.

Just be aware that you reach a point of diminishing, or even negative, returns as the specifications get more and more detailed.

Have you noticed how some project teams are efficient, with everyone knowing what to do and contributing fully, while the members of other teams are constantly bickering and don't seem able to get out of each other's way? Often this is an orthogonality issue. When teams are organized with lots of overlap, members are confused about responsibilities. Every change needs a meeting of the entire team, because any one of them might be affected.

More testing should be done automatically. It's important to note that by automatically we meant that the test /results/ are interpreted automatically as well.

Great software today is often preferable to perfect software tomorrow. If you give your users something to play with early, their feedback will often lead you to a better eventual solution

As a programmer, you are part listener, part advisor, part interpreter, and part dictator.

Documenting the reasons behind requirements will give your team invaluable information when making daily implementation decisions.

the only way to determine the timetable for a project is by gaining experience on that same project. This needn't be a paradox if you practice incremental development, repeating the following steps. Check requirements Analyze risk Design, implement, integrate Validate with the users

Providing a comfortable transition through familiar metaphors is one way to help get buy-in.

Rather than construction, software is more like gardening—it is more organic than concrete. You plant many things in a garden according to an initial plan and conditions. Some thrive, others are destined to end up as compost.

perfect software doesn't exist. No one in the brief history of computing has ever written a piece of perfect software.

We can be proud of our abilities, but we must be honest about our shortcomings—our ignorance as well as our mistakes.

Responsibility is something you actively agree to.

But while you can always write 'spaghetti code' in a procedural language, object-oriented languages used poorly can add meatballs to your spaghetti.

The DRY principle tells us to keep the low-level knowledge in the code, where it belongs, and reserve the comments for other, high-level explanations.

All programs transform data, converting an input into an output. And yet when we think about design, we rarely think about creating transformations. Instead we worry about classes and modules, data structures and algorithms, languages and frameworks.

There is a luxury in self-reproach. When we blame ourselves we feel no one else has a right to blame us.

Most people assume that maintenance begins when an application is released, that maintenance means fixing bugs and enhancing features. We think these people are wrong.

Within the overall structure of a project there is always room for individuality and craftsmanship.

Nothing is more dangerous than an idea if it's the only one you have.

Don't be like the frog. Keep an eye on the big picture. Constantly review what's happening around you, not just what you personally are doing.

One of the cornerstones of the pragmatic philosophy is the idea of taking responsibility for yourself and your actions in terms of your career advancement, your project, and your day-to-day work.