The Agile Developer

1. Continuous development, not episodic.

2. Inject energy.
3. Agile development uses feedback to make constant adjustments in a highly
collaborative environment.
4. Start with the hardest. Always tackle the most difficult problems first, and leave
the simple one towards the end.
5. Software development doesnt happen in a chart, an IDE, or a design tool; it
happens in your head. But its not alone.
6. Blame doesnt fix bugs.
7. Instead of brooding over the problem, theyll direct their efforts toward solving it.
8. Beware of land mines.
9. Dont code in isolation.
10. Dont fall for the quick hack. Invest the energy to keep code clean and out in the
open.
11. Negativity kills innovation.
12. It is the mark of an educated mind to be able to entertain a thought without
accepting it.
13. Criticize ideas, not people. Take pride in arriving at a solution rather than proving
whose idea is better.
14. Do whats right. Be honest, and have the courage to communicate the truth. It
may be difficult at times; thats why it takes courage.
15. Keep up with changing technology. You dont have to become an expert at
everything, but stay aware of where the industry is headed, and plan your career
and projects accordingly.
16. Always be the worst guy in every band youre in. If youre the best guy there, you
need to be in a different band. And I think that works for almost everything thats
out there as well.
17. Raise the bar for you and your team. Use brown-bag sessions to increase
everyones knowledge and skills and help bring people together. Get the team
excited about technologies or techniques that will benefit your project.
18. Learn the new; unlearn the old. When learning a new technology, unlearn any old
habits that might hold you back. After all, theres much more to a car than just a
horseless carriage.
19. Keep asking Why. Dont just accept what youre told at face value. Keep
questioning until you understand the root of the issue.
20. Tackle tasks before they bunch up. Its easier to tackle common recurring tasks
when you maintain steady, repeatable intervals between events.
21. Decide what you shouldnt decide.
22. Let your customers decide. Developers, managers, or business analysts
shouldnt make business-critical decisions. Present details to business owners in a
language they can understand, and let them make the decision.
23. Design should be only as detailed as needed to implement.
24. Strategic versus tactical design.
25. A good design is a map; let it evolve. Design points you in the right direction. Its
not the territory itself; it shouldnt dictate the specific route. Dont let the design
(or the designer) hold you hostage.
26. Blindly picking a framework is like having kids to save taxes.
27. Choose technology based on need. Determine your needs first, and then evaluate
the use of technologies for those specific problems. Ask critical questions about
the use of any technology, and answer them genuinely.
28. Dont build what you can readily download. Building everything you need from
the ground up may be necessary, but it is the most expensive and risky option.
29. Keep your project releasable at all times. Ensure that the project is always
compilable, runnable, tested, and ready to deploy at a moments notice.
30. Software integration is like that. If you continue developing your code in isolation
and one day suddenly jump to integrate, dont be surprised at the beating youll
get.
31. Never accept big-bang integration.
32. Integrate early, integrate often. Code integration is a major source of risk. To
mitigate that risk, start integration early and continue to do it regularly.
33. Deploy your application automatically from the start. Use that deployment to
install the application on arbitrary machines with different configurations to test
dependencies. QA should test the deployment as well as your application.
34. Your success in software development is based on how close you end up to your
customers expectations.
35. Develop in plain sight. Keep your application in sight (and in the customers
mind) during development. Bring customers together and proactively seek their
feedback using demos every week or two.
36. Develop in increments. Release your product with minimal, yet usable, chunks of
functionality. Within the development of each increment, use an iterative cycle of
one to four weeks or so.
37. A fixed price guarantees a broken promise.
38. Estimate based on real work. Let the team actually work on the current project,
with the current client, to get realistic estimates. Give the client control over their
features and budget.
39. One test is worth a thousand expert opinions.
40. Use automated unit tests. Good unit tests warn you about problems immediately.
Dont make any design or code changes without solid unit tests in place.
41. Write tests before writing code.
42. Good design doesnt mean more classes.
43. Use it before you build it. Use Test Driven Development as a design tool. It will
lead you to a more pragmatic and simpler design.
44. Automate to save time.
45. Different makes a difference. Run unit tests on each supported platform and
environment combination, using continuous integration tools. Actively find
problems before they find you.
46. Create tests for core business logic. Have your customers verify these tests in
isolation, and exercise them automatically as part of your general test runs.
47. Measure how much work is left. Dont kid yourselfor your teamwith
irrelevant metrics. Measure the backlog of work to do.
48. Every complaint holds a truth. Find the truth, and fix the real problem.
49. Write code to be clear, not clever. Express your intentions clearly to the reader of
the code. Unreadable code isnt clever.
50. Dont comment to cover up, explain.
51. Comment to communicate. Document code using wellchosen, meaningful names.
Use comments to describe its purpose and constraints. Dont use commenting as a
substitute for good code.
52. Actively evaluate trade-offs. Consider performance, convenience, productivity,
cost, and time to market. If performance is adequate, then focus on improving the
other factors. Dont complicate the design for the sake of perceived performance
or elegance.
53. Write code in short edit/build/test cycles. Its better than coding for an extended
period of time. Youll create code thats clearer, simpler, and easier to maintain.
54. Develop the simplest solution that works. Incorporate patterns, principles, and
technology only if you have a compelling reason to use them.
55. Keep classes focused and components small. Avoid the temptation to build large
classes or components or miscellaneous catchall classes.
56. Tell, dont ask. Dont take on another objects or components job. Tell it what to
do, and stick to your own job.
57. Use inheritance for is-a; use delegation for has-a or uses-a
58. Extend systems by substituting code. Add and enhance features by substituting
classes that honor the interface contract. Delegation is almost always preferable to
inheritance.
59. Maintain a log of problems and their solutions. Part of fixing a problem is
retaining details of the solution so you can find and apply it later.
60. Treat warnings as errors. Checking in code with warnings is just as bad as
checking in code with errors or code that fails its tests. No checked-in code should
produce any warnings from the build tools.
61. Attack problems in isolation. Separate a problem area from its surroundings when
working on it, especially in a large application.
62. Handle or propagate all exceptions. Dont suppress them, even temporarily. Write
your code with the expectation that things will fail.
63. Present useful error messages. Provide an easy way to find the details of errors.
Present as much supporting detail as you can about a problem when it occurs, but
dont bury the user with it.
64. Use stand-up meetings. Stand-up meetings keep the team on the same page. Keep
the meeting short, focused, and intense.
65. Good design evolves from active programmers. Real insight comes from active
coding. Dont use architects who dont codethey cant design without knowing
the realities of your system.
66. Emphasize collective ownership of code. Rotate developers across different
modules and tasks in different areas of the system.
67. Knowledge grows when given.
68. Be a mentor. Theres fun in sharing what you knowyou gain as you give. You
motivate others to achieve better results. You improve the overall competence of
your team.
69. Give others a chance to solve problems. Point them in the right direction instead
of handing them solutions. Everyone can learn something in the process.
70. Share code only when ready. Never check in code thats not ready for others.
Deliberately checking in code that doesnt compile or pass its unit tests should be
considered an act of criminal project negligence.
71. Review all code. Code reviews are invaluable in improving the quality of the code
and keeping the error rate low. If done correctly, reviews can be practical and
effective. Review code after each task, using different developers.
72. Keep others informed. Publish your status, your ideas and the neat things youre
looking at. Dont wait for others to ask you the status of your work.
73.