Kent Beck Quotes

I'm not a great programmer; I'm just a good programmer with great habits.

Do The Simplest Thing That Could Possibly Work

Responsibility cannot be assigned; it can only be accepted. If someone tries to give you responsibility, only you can decide if you are responsible or if you aren't.

Write tests until fear is transformed into boredom

Brilliance in a scientist does not consist in being right more often but in being wrong about more interesting topics.

Saying that programmers should just accomplish twice as much doesn't work. They can gain skills and effectiveness, but they cannot get more done on demand. More time at the desk does not equal increased productivity for creative work.

the XP strategy is "design always.

The XP philosophy is to start where you are now and move towards the ideal. From where you are now, could you improve a little bit?

A statement Kent Beck often makes about himself, "I'm not a great programmer; I'm just a good programmer with great habits.

Given the choice between an extremely skilled loner and a competent-but-social programmer, XP teams consistently choose the more social candidate. The best interviewing technique is to have the candidate work with the team for a day. Pair programming provides an excellent test of technical and social skills.

It reminds me of a statement Kent Beck often makes about himself: “I’m not a great programmer; I’m just a good programmer with great habits.” Refactoring helps me be much more effective at writing robust code.

I've sat through far too many "crying in the beer" sessions where all the energy for change was dissipated in the intensity of the complaining. Once you see an idea for improvement that makes sense to you, do it.

In software development, “perfect” is a verb, not an adjective. There is no perfect process. There is no perfect design. There are no perfect stories. You can, however, perfect your process, your design, and your stories.

If you're happy slamming some code together that more or less works and you're happy never looking at the result again, TDD is not for you. TDD rests on a charmingly naïve geekoid assumption that if you write better code, you'll be more successful. TDD helps you to pay attention to the right issues at the right time so you can make your designs cleaner, you can refine your designs as you learn.

McConnell writes, "In ten years the pendulum has swung from 'design everything' to 'design nothing.' But the alternative to BDUF [Big Design Up Front] isn't no design up front, it's a Little Design Up Front (LDUF) or Enough Design Up Front (ENUF)." This is a strawman argument. The alternative to designing before implementing is designing after implementing.

No matter the circumstance you can always improve. You can always start improving with yourself. You can always start improving today.

Rather than apply minutes of suspect reasoning, we can just ask the computer by making the change and running the tests.

Without planning, we are individuals with haphazard connections and effectiveness. We are a team when we plan and work in harmony.

Beta testing is a symptom of weak testing practices and poor communication with customers.

Software development is a game of insight, and insight comes to the prepared, rested, relaxed mind.

If there are forms of testing, like stress and load testing, that find defects after development is "complete," bring them into the development cycle. Run load and stress tests continuously and automatically.

Pair programmers: Keep each other on task. Brainstorm refinements to the system. Clarify ideas. Take initiative when their partner is stuck, thus lowering frustration. Hold each other accountable to the team's practices. Pairing

Sit Together Develop in an open space big enough for the whole team. Meet the need for privacy and "owned" space by having small private spaces nearby or by limiting work hours so team members can get their privacy needs met elsewhere.

Code should be obvious: When someone needs to make a change, they should be able to find the code to be changed easily and to make the change quickly without introducing any errors. A healthy code base maximizes our productivity, allowing us to build more features for our users both faster and more cheaply. To keep code healthy, pay attention to what is getting between the programming team and that ideal, then refactor to get closer to the ideal. But the most important thing to learn from this example is the rhythm of refactoring. Whenever I’ve shown people how I refactor, they are surprised by how small my steps are, each step leaving the code in a working state that compiles and passes its tests. I was just as surprised myself when Kent Beck showed me how to do this in a hotel room in Detroit two decades ago. The key to effective refactoring is recognizing that you go faster when you take tiny steps, the code is never broken, and you can compose those small steps into substantial changes. Remember that—and the rest is silence.

If you have a month to plan a project in detail, spend it on four one-week iterations developing while you improve your estimates. If you have a week to plan a project, hold five one-day iterations. Feedback cycles give you information and the experience to make accurate estimates.

I didn’t know then that Carol DaRonch, Jean Graham, and Debby Kent’s girlfriend, Jolynne Beck, who had seen the man in the auditorium on November 8, had all picked Ted out of the Utah lineup on October 2. Ted had been one suspect, standing in a seven-man lineup, surrounded by detectives, all of them a little older, a little heavier than he was.

Change always starts at home. The only person you can actually change is yourself. No matter how functional or dysfunctional your organization, you can begin applying XP for yourself. Anyone on the team can begin changing his own behavior. Programmers can start writing tests first. Testers can automate their tests. Customers can write stories and set clear priorities. Executives can expect transparency. Dictating practices to a team destroys trust and creates resentment. Executives can encourage team responsibility and accountability. Whether the team produces these with XP, a better waterfall, or utter chaos is up to them. Using XP, teams can produce dramatic improvements in the areas of defects, estimation, and productivity.

However, those whose souls are healed by the balm of elegance can find in TDD a way to do well by doing good. TDD is also good for geeks who form emotional attachments to code. One of the great frustrations of my young engineer's life was starting a project with great excitement, then watching the code base decay over time. A year later I wanted nothing more than to dump the now-smelly code and get on to the next project. TDD enables you to gain confidence in the code over time. As tests accumulate (and your testing improves), you gain confidence in the behavior of the system. As you refine the design, more and more changes become possible. My goal is to feel better about a project after a year than I did in the starry-eyed beginning, and TDD helps me achieve this.

Optimism is an occupational hazard of programming; feedback is the treatment." - Kent Beck

First you learn the value of abstraction, then you learn the cost of abstraction, then you're ready to engineer

One example is the concept that vulnerability is safety. The old habit of holding something back in order to be safe doesn’t really work. Holding back that last 20% of effort doesn’t protect me. When my project fails, the fact that I didn’t give my all doesn’t actually make me feel better. It doesn’t protect me from a sense of failure that I couldn’t make the project work. If I do my very best writing a program and people don’t like it, I can still feel justly good about myself. This attitude allows me to feel safe no matter the circumstance. If how I feel is based on an accurate read on whether I did my best, I can feel good about myself by doing my best.

If you want people to take your advice, you need to solve more problems than you create.

... no matter what the client says the problem is, it is always a people problem.

Simplicity only makes sense in context. If I’m writing a parser with a team that understands parser generators, then using a parser generator is simple. If the team doesn’t know anything about parsing and the language is simple, a recursive descent parser is simpler.

Listening , Testing , Coding , Designing. That's all there is to software. Anyone who tells you different is selling something .

The future value of a system reveals itself in today’s realities, not yesterday’s speculation.

I don’t write to make money; I make money with writing so I can afford to write.

By far the dominant reason for not releasing sooner was a reluctance to trade the dream of success for the reality of feedback.

Simon Baron-Cohen, The Science of Evil; Judith Beck, Cognitive Behavior Therapy; Louis Cozolino, The Making of a Therapist; Kevin Dutton, The Wisdom of Psychopaths; James Fallon, The Psychopath Inside; Peter and Ginger Ross Breggin, Talking Back to Prozac; Robert D. Hare, Without Conscience; Kent Kiehl, The Psychopath Whisperer; Jane McGregor and Tim McGregor, The Sociopath at the Breakfast Table; J. Reid Meloy, The Psychopathic Mind; Dinah Miller, Annette Hanson, and Steven Roy Daviss, Shrink Rap; Daniel Smith, Monkey Mind; Scott Stossel, My Age of Anxiety; Martha Stout, The Sociopath Next Door; M. E. Thomas, Confessions of a Sociopath; and Robert Whitaker, Mad in America.

Used Pluggable Adaptor, which we promise not to use again for four months, minimum, because it makes code hard to statically analyze.

There is only one code stream. You can develop in a temporary branch, but never let it live longer than a few hours. Multiple code streams are an enormous source of waste in software development. I fix a defect in the currently deployed software. Then I have to retrofit the fix to all the other deployed versions and the active development branch. Then you find that my fix broke something you were working on and you interrupt me to fix my fix. And on and on. There are legitimate reasons for having multiple versions of the source code active at one time. Sometimes, though, all that is at work is simple expedience, a micro-optimization taken without a view to the macro-consequences. If you have multiple code bases, put a plan in place for reducing them gradually. You can improve the build system to create several products from a single code base. You can move the variation into configuration files. Whatever you have to do, improve your process until you no longer need multiple versions of the code.

It’s not my job to “manage” someone else’s expectations. It’s their job to manage their own expectations. It’s my job to do my best and to communicate clearly.

Are the teeny-tiny steps feeling restrictive? Take bigger steps. Are you feeling a little unsure? Take smaller steps. TDD is a steering process -- a little this way, a little that way.

Without the adjustment, you are working under a lie. Everyone knows it and has to hide to protect themselves. This is no way to get good software done and deployed;

Cards on a wall is a way of practicing transparency, valuing and respecting the input of each team member. The project manager has the task of translating the cards into whatever format is expected by the rest of the organization.

However, most defects end up costing more than it would have cost to prevent them. Defects are expensive when they occur, both the direct costs of fixing the defects and the indirect costs because of damaged relationships, lost business, and lost development time.

Trust energizes participants. We feel good when things work smoothly. We need to be safe to experiment and make mistakes. We need testing to bring accountability to our experimentation so that we can be sure we are doing no harm.

Folk wisdom in software development teaches that interfaces shouldn't be unduly influenced by implementations. Writing a test first is a concrete way to achieve this separation.

Inaccurate estimates are a failure of information, not of values or principles. If the numbers are wrong, fix the numbers and communicate the consequences.

The constraint has shifted out of software development. Here's a sad but repeated story: a development team begins applying XP, dramatically improves quality and productivity, but then is disbanded, its leaders fired and the rest of the team scattered.

Some of the teams who read and applied the first edition of this book didn't get the part of the message about the last responsible moment. They piled story on story as quickly as possible with the least possible investment in design. Without daily attention to design, the cost of changes does skyrocket. The result is poorly designed, brittle, hard-to-change systems.

If I have the same logic in two places, I work with the design to understand how I can have only one copy. Designs without duplication tend to be easy to change.

Change is not necessarily slow. A team eager or desperate for improvement can progress quickly. It doesn't need to wait long to assimilate one change before moving on to the next practice. If you change too fast, though, you risk slipping back into old practices and values. When this happens, take time to regroup. Remind yourself of the values you want to hold. Review your practices and remind yourself why you chose them. New habits take time to solidify.

Don't make more versions of your source code. Rather than add more code bases, fix the underlying design problem that is preventing you from running from a single code base.

Write contracts for software development that fix time, costs, and quality but call for an ongoing negotiation of the precise scope of the system. Reduce risk by signing a sequence of short contracts instead of one long one.

A team using the information provided by pay-per-use should be able to do a more effective job than a team relying for feedback only on license revenues.

Customers may have a good idea of the general behavior they want to see, but testers are good at looking at "happy paths" and asking what should happen if something goes wrong. "Okay, but what if login fails three times? What should happen then?" In this role testers amplify communication.

To achieve this his team had a sophisticated stress testing environment. When they wanted to improve the architecture they would first improve the stress tests until the system broke. Then they would improve the architecture just enough to run the tests. I suggested this strategy to an architect at another company. He complained of spending all of his time writing specifications and then explaining them to developers.

First a small team writes a small system. Then they find the natural fracture lines and divide the system into relatively independent parts for expansion. The architects help choose the most appropriate fracture lines and then follow the system as a whole, keeping the big picture in mind as the groups focus on their smaller section.

XP always keeps the system in deployable condition. Problems are not allowed to accumulate.

Exceptions occur at different levels of abstraction. Catching and reporting a low-level exception can be confusing to someone who is not expecting it. When a web server shows me an error page with stack trace headed by a NullPointerException, I’m not sure what I’m supposed to do with the information. I’d rather see a message that said, “The programmer did not consider the scenario you have just presented.” I wouldn’t mind if the page also provided a pointer to further information that I could send to a programmer so he could diagnose the problem, but presenting me with untranslated details isn’t helpful.

The majority of the cost of software is incurred after the software has been first deployed. Thinking about my experience of modifying code, I see that I spend much more time reading the existing code than I do writing new code. If I want to make my code cheap, therefore, I should make it easy to read.

Incremental design—We invest in the design every day, but we have the additional constraint that we need to keep our APIs stable.

The difference between what I think is valuable and what is really valuable creates waste.