Simplicity is the ultimate sophistication.

Successful software always gets changed.

A programmer is ideally an essayist who works with traditional aesthetic and literary forms as well as mathematical concepts, to communicate the way that an algorithm works and to convince a reader that the results will be correct.

Prioritize specific business goals, customers, and users, and then their goals, before prioritizing features.

Viable means successful for a specific business strategy, target customers, and users.

Keep the progress and quality visible to stakeholders inside your organisation.

Great art is never finished, only abandoned.

The best product owners help their entire team take ownership of the product.

Scope doesn't creep; understanding grows.

It turns out that the name you give something matters.

Minimize output, and maximize outcome and impact.

Shared documents aren't shared understanding.

The first principle is that you must not fool yourself, and you are the easiest person to fool.

To me, style is just the outside of content, and content the inside of style, like the outside and inside of the human body—both go together, they can't be separated.

Knowledge is of two kinds. We know a subject ourselves, or we know where we can find information upon it.

A successful book is not made of what is in it, but what is left out of it.

Don't tell me how it works, tell me how to use it.

It was impossible to get a conversation going, everybody was talking too much.

The biggest mistake is believing there is one right way to listen, to talk, to have a conversation - or a relationship.

The more original a discovery, the more obvious it seems afterwards.

The goal is not physical closeness between people, the goal is mental closeness.

It is not necessary to change. Survival is not mandatory.

A successful team is one that is made up of individuals that are able to set themselves aside.

If you want to go fast…go alone. If you want to go far…go together.

You must be the change you want to see in the world.

You should name a variable using the same care with which you name a first-born child.

The difference between the right word and the almost right word is the difference between lightning and a lightning bug.

If I had only one hour to save the world, I would spend fifty-five minutes defining the problem, and only five minutes finding the solution.

Prediction is very difficult, especially about the future.

All problems in computer science can be solved by another level of indirection ... except for the problem of too many layers of indirection.

Make sure to be passionate about whatever it is you get into, because otherwise you won't put the right amount of work into it.

We can't control systems or figure them out. But we can dance with them!

Delivery plans should be more about options that could be explored instead of scope that is nailed down by commitment.

You should automate as much as you possibly can.

Many consider CI without automated, continuous testing not to be CI. We couldn't agree more.

One of the interesting things about Continuous Integration is how often people are surprised by the impact that it has.

The first rule of any technology used in a business is that automation applied to an efficient operation will magnify the efficiency. The second is that automation applied to an inefficient operation will magnify the inefficiency.

When you have to stop and define what it means to be Agile and argue what flavor of Agile you are, you just stopped being Agile.

Whether it is the build and release procedure, code review paperwork, or any other recurring task on the project, it has to be automatic.

The intuitive mind is a sacred gift and the rational mind is a faithful servant. We have created a society that honours the servant but has forgotten the gift.

If you can't explain something to a six-year-old, you really don't understand it yourself.

Quality is value to some person.

Arguments over style are pointless. There should be a style guide, and you should follow it.

No plan survives contact with the enemy.

If you do it more than twice, script it!

Reuse costs, for a start.

To keep up, there is no need to work more, but more clever.

Automation also reduces the need for documentation.

Agility demands a high quality and professionalism of all participants, though.

Documentation must be aligned with specific project needs, not with rigid predetermined result types.

Paper is better in remembering than your brain.

It is not the strongest of the species that survives, nor the most intelligent that survives. It is the one that is the most adaptable to change.

Managers are able to work on average of only five minutes between interruptions.

All code in any code-base should look like a single person typed it, no matter how many people contributed.

We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%.

If we do not know who the customer is, we do not know what quality is.

The proper use of comments is to compensate for our failure to express ourself in code.

’Law of Triviality: The time spent on any item of the agenda will be in inverse proportion to the sum involved.

If it hurts do it more often.

There are 3 rules to follow when parallelizing large codes. Unfortunately, no one knows what these rules are.

Sixty-four percent of the features included are rarely or never used.

All problems in computer science can be solved by another level of indirection …Except for the problem of too many layers of indirection.

I have never been forced to accept compromises, but I have willingly accepted constraints.

Legacy code is simply code without tests.

Code without tests is bad code. It doesn't matter how well written it is, it doesn't matter how pretty or object-orientated or well-encapsulated it is. With tests, we can change the behavior of our code quickly and verifiably.

These little code fragments that you call "unit tests" are actually usage examples of code that doesn't exist yet.

There are two ways of reading what someone says. One is to think and try to grok it. Other is to try to find a bug in it.

You cannot control what you cannot measure.

One difference between a smart programmer and a professional programmer is that the professional programmer understands that clarity is king. Professionals use their powers for good and write code that others can understand.

The better the communication and collaboration within a software development team, the greater your chance of success.

The cleaner your design, the less documentation you require.

Truth can only be found in one place: the code.

The name of a variable, function, or class, should answer all the big questions. It should tell you why it exists, what it does, and how it is used.

Remember that code is really the language in which we ultimately express requirements.

Indeed, isn't continuous improvement an intrinsic part of professionalism?

Names in software are 90 percent of what makes software readable.

Practice TDD and never let it go. When you write code, write the best code you can. Never succumb to the temptation to rush. The only way to go fast, is to go well!

Comments are, at best, a necessary evil.

The older a comment is, and the farther away it is from the code it describes, the more likely it is to be just plain wrong.

When the code is a mess, the product is mess.

Bad schedules can be fixed, bad requirements can be redefined, bad team dynamics can solved, but bad code stays.

The parts we ignore are where the bugs will hide.

In my experience, less than 50 percent of designed interfaces remain stable during the implementation phase.

You can't put enough effort into developing your ESB's ability to support logging and monitoring.

Optimizing to avoid doing things repeatedly is the best approach for achieving excellence.

You don't share or don't mutate.

Planning is everything. Plans are nothing.

Legacy code is simply code without tests.

If you look at how most programmers spend their time, you'll find that writing code is actually a small fraction.

In theory, theory and practice are the same. In practice, they are not.

To measure is to know.

Neither architecture nor clean code insist on perfection, only on honesty and doing things the best we can. In Scrum, we make everything visible. We are honest about the state of our code because code is never perfect.

Quality is the result of a million selfless acts of care - not just of any great method that descends from the heavens.

In software, 80% or more of what we do is quaintly called 'maintenance': the act of repair.

We should view our code as the beautiful articulation of noble efforts of design - design as a process, not a static endpoint.

Writing good test code is hard, and maintaining obtuse test code is even harder.

Rather than a diagram annotated with text, I write a text document illustrated with selective and simplified diagrams.

It takes fastidiousness to write code that doesn't just do the right thing but also says the right thing.

But making written documents that actually help the team produce good software is a challenge.

A bidirectional association means that both objects can be understood only together.

Civilization advances by extending the number of important operations which we can perform without thinking about them.

Automation will give you back something you don't have enough of: time.

Write your code well so that you do not impede yourself later. The only way to go fast is to go well.

Successful programs not only offer clear documentation but they also recognize that developers don't have a lot of time (or inclination) to sit down and read it.

Even a whiteboard diagram, or a CRC card, is documentation: the goal isn't to avoid documentation, but to document just the right things in just the right amount.

Documenting repeatable processes for anything you will do more than once is essential to your sanity.

The cleaner your design, the less documentation you require.

XP is designed to use face to face human communication in place of written documentation wherever possible. Effective conversation is faster and more effective than written documentation. When you bring people together, they need less paperwork.

Documentation represents potential profit, rather than a cost, because it's not a finely crafted mess of marketing jargon — documentation is legitimately useful from a developer's perspective. As such, it can help you build and sustain communities!

Intuitiveness does have limitations, however; that’s when developers need documentation. [...] Reading documentation is a last stop rather than a first stop for many.