What is Agile?

While some readers of this blog might be familiar with Agile software development, for those that aren't here is a brief (and over simplified) overview.

Early Software Development

With the early computers that were built after World War II, the hardware and software were very tightly coupled, and often the people that built the hardware also wrote the software that ran on those computers.


In the early era of computer software, when the people creating the software were often also the ones creating the hardware (or were working closely with them), with no other patterns for processes for software development to go on, they adopted processes for building software that were similar to the processes for building the computer hardware. These early computer hardware manufacturing processes logically followed processes for manufacturing that had evolved from the earliest days of the industrial revolution. In a nutshell, these processes for industrial manufacturing generally involved creating detailed requirements, then doing industrial design of the machine, then building the machine, and finally quality checking the machine before considering the machine to be done. Generically this is referred to as "waterfall" processes, because of the sequence of steps that flow into each other, each of which must be completed before the next step can be begun.

Waterfall Diagram - Attribution: Peter Kemp / Paul Smith License: https://creativecommons.org/licenses/by/3.0/deed.en

However, building software is not like a physical object, so these processes had some inherent problems. Physical objects are immutable once you begin building them, while software is infinitely mutable. - Once you being building an steam engine, you can't decide part way through to instead build a diesel engine without starting all over. You have a physical object that must be destroyed or torn down in order to make changes. This means that you must do a lot of planning and design up front, so that you do not have to make changes once you have begun creating the physical object. Software is different. It (generally) can be torn down, changed, and rebuilt without having to scrap everything and start all over from the beginning.

Software is not a physical object

In the 1970's and 1980's various individuals started experimenting with other processes for software development that were not modeled on the manufacture of physical objects, and which tried to account for the mutability of software.

Agile Revolution

In 2001 a group of individuals in the software industry who were not following prevailing waterfall processes, but were instead charting their own paths, got together at the Snowbird ski resort in Utah to talk and try to find common ground.

The Agile Manifesto

While the specific processes and practices were different for each, they were able to agree on a common set of values and principles, which they defiantly called the Agile Manifesto.

We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:

  • Individuals and interactions over processes and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
    Responding to change over following a plan
  • That is, while there is value in the items on the right, we value the items on the left more.

12 Principles behind the Agile Manifesto

This group of software development renegades, also also expressed 12 core principles behind the Agile Manifesto:

  • Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
  • Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
  • Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
  • Business people and developers must work together daily throughout the project.
  • Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
  • The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
  • Working software is the primary measure of progress.
  • Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
  • Continuous attention to technical excellence and good design enhances agility.
  • Simplicity--the art of maximizing the amount of work not done--is essential.
  • The best architectures, requirements, and designs emerge from self-organizing teams.
  • At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

Agile Today

Today, under the broad philosophy of Agile software development, there are a number of practical implementations such as Scrum, Extreme Programming, Feature Driven Development, Crystal, and numerous others. There is now a vast ecosystem of Agile practices!

Map of Agile Practices

Some of these implementations are highly prescriptive of specific practices to follow as part of the processes, while others only have a few core practices adhering to Agile values and principles. - But all of them follow the general philosophy of Agile software development.

Author image
About Shawn Samuel
Los Angeles Website
I am a technology leader focused on the delivery of websites and rich web applications using Agile and Lean processes.