Trace the history and evolution of Agile from its roots in 1968, and learn how it has evolved through the years.
“Conway’s Law” is coined and summarized as follows: “Any organization that designs a system (defined more broadly here than just information systems) will inevitably produce a design whose structure is a copy of the organization’s communication structure.” It has long had the status of folklore rather than of well-supported scientific result, though recent studies have lent it some academic support. (The social aspects of software development remained largely ignored by academic software engineering until the mid-90’s.)
Barry Boehm proposes “Wideband Delphi”, a forerunner of Planning Poker.
A series of articles by D. Panzl describing tools with features closely resembling those of JUnit attest to the long history of automated unit testing.
Publication of Software Reliability by Glenford Myers, which states as an “axiom” that “a developer should never test their own code” (Dark Ages of Developer Testing).
Creation of the “make” tool for Unix systems – the principle of automating software builds is not a new idea.
Substantial discussion of incremental development in IBM’s Federal Systems Division can be found in a volume edited by Harlan Mills, ”Principles of software engineering”, specifically an article by Dyer, which recommends organizing “each increment to maximize the separation of its function(s) from function(s) in other increments”; however, the idea is still very much that of a scheduled, phased approach rather than one responsive to change.
The notion of “visual control” originating in the Toyota Production System is an anticipation of “information radiators.”
A wide range of “human factors testing” techniques foreshadowing usability testing, used at the Xerox PARC during the design of the Xerox Star, are described in the CHI conference proceedings.
An early empirical study by Barry Boehm of projects using prototyping, by essence an iterative strategy, suggests that iterative approaches first started receiving serious attention around that time, most probably driven by factors such as the rise of personal computers and graphical user interfaces.
The notion of “factoring”, an anticipation of refactoring, is described in Brodie’s “Thinking Forth”, where it is presented as “organizing code into useful fragments” which “occurs during detailed design and implementation.”
While criticisms of the “waterfall” sequential approach have started much earlier, formulations of alternative incremental approaches are becoming more pointed; a good example is an early paper on ”Knowledge-based communication processes in software engineering” advocating incremental development for the specific reason that “complete and stable specifications are not available.”
Perhaps the first explicitly named, incremental alternative to the “waterfall” approach is Tom Gilb’s Evolutionary Delivery Model, nicknamed “Evo.”
In a well-known paper, Barry Boehm presents ”A Spiral model of software development and enhancement”, an iterative model geared to identifying and reducing risks through any appropriate approaches (though the “typical” example presented is based on prototyping).
Takeuchi and Nonaka publish their article ”The New New Product Development Game” in Harvard Business Review. The article describes a rugby approach where “the product development process emerges from the constant interaction of a hand-picked, multidisciplinary team whose members work together from start to finish.” This article is often cited as the inspiration for the Scrum framework.
The rise of event-driven GUI software and their specific testing challenges create an opportunity for “capture and replay” test automation tools provided by companies such as Segue or Mercury; this type of tool dominates the market for the next decade.
The “timebox” is described as a cornerstone of Scott Schultz’s “Rapid Iterative Production Prototyping” approach in use at a Du Pont spin-off, Information Engineering Associates.
Though the idea of reasoning through design issues by anthropomorphizing objects, as in the CRC technique, may seem quite natural, it has had some formidable detractors, for instance this artlce by Dijsktra ”On the cruelty of really teaching computing science”, which appears just as object-oriented is hitting the mainstream: “in computing science the anthropomorphic metaphor should be banned.”
Ward Cunningham describes the CRC technique in a joint article with Kent Beck; the specific format used for the cards derives from an application designed by Cunningham to store design documentation as a Hypercard stack.
Bill Opdyke coins the term “refactoring” in an ACM SIGPLAN paper with Ralph Johnson, “Refactoring: An aid in designing application frameworks and evolving object-oriented systems.”
Testing discipline dominated by “black box” techniques, in particular in the form of “capture and replay” testing tools.
Owing to the rise in popularity of RAD tools and IDEs, “make” type tools acquire a mixed reputation.
RAD, possibly the first approach in which timeboxing and “iterations” in the looser sense of “one repetition of the entire software development process” are closely combined, is described by James Martin in his ”Rapid Application Development”. This book also describes the details of the timebox in one of its chapters.
Independent creation of a testing framework at Taligent with striking similarities to SUnit (source).
“Dynamic Duo” is the term coined by Larry Constantine, reporting on a visit to Whitesmiths Inc., a compiler vendor started by P.J. Plauger, one of the implementors of C: “At each terminal were two programmers! Of course, only one programmer was actually cutting code at each keyboard, but the others were peering over their shoulders.” Whitesmiths existed from 1978 to 1988.
A comprehensive description of “refactoring” is presented in Opdyke’s thesis, “Refactoring object-oriented frameworks.”
“The benefits of collaboration for student programmers” by Wilson et al. is one early empirical study indicating benefits of pairing for programming tasks specifically. Posterior studies are more abundant and driven by the desire to “validate” pair programming after it had already gained popularity through Extreme Programming.
The phrase “continuous integration” is already in use and thus predates what will later be known as Agile processes, for instance an article written this year contrasts it with “scheduled” integration, and recommends the latter, citing “lack of thorough testing” as one issue with continuous integration; this helps explain why the automated testing favored by Agile teams is an enabler for continuous integration.
Jeff Sutherland invents Scrum as a process at Easel Corporation.
Jim Coplien, describing his observations of the “hyperproductive” Borland Quattro Pro team, notes their reliance on almost daily meetings: “the project was made more of meetings than anything else”; this article is also cited as a strong influence on Scrum.
Kent Beck writes the SUnit testing framework for Smalltalk.
Coplien names the “Code Ownership” pattern in Pattern Languages of Program Design, in an early version of his “Organizational Patterns”, a work influential in the later development of Agile discourse. However, he endorses exclusive individual code ownership, and cautions against collective ownership which he equates to no ownership at all. Coplien admits that objections against individual ownership exist, but argues that other of his patterns mitigate those problems.
An article by Alistair Cockburn, ”Growth of human factors in application development”, suggests one major reason why iterative approaches gradually gain acceptance: the bottleneck in software development is shifting to (individual and organizational) learning, and human learning is intrinsically an iterative, trial and error process.
Based on the same inspiration as CRC cards, Ward Cunningham develops the concept of a Wiki, which will later become the ancestor of Wikipedia and undoubtedly one of the most influential ideas in the history of the World Wide Web.
The earliest writings on Scrum introduce the notion of the “sprint” as iteration, although its duration is variable.
The pattern “Developing in Pairs” is given a brief description, in Alexandrian pattern form, in Jim Coplien’s chapter “A Generative Development-Process Pattern Language” from the first patterns book, “Pattern Languages of Program Design.”
Andrew Koenig originally coined the term antipattern in the March – April 1995 edition of the Journal of Object Oriented Program: “An antipattern is just like a pattern, except that instead of a solution it gives something that looks superficially like a solution, but isn’t one.”
Andrew Koenig originally coined the term antipattern in the March – April 1995 edition of the Journal of Object Oriented Program: “An antipattern is just like a pattern, except that instead of a solution it gives something that looks superficially like a solution, but isn’t one.”
Ken Schwaber and Jeff Sutherland co-present Scrum at the OOPSLA Conference.
Steve McConnell describes the “Daily Build and Smoke Test” technique, used at Microsoft for Windows NT 3.0 during the 1990’s; the emphasis is not so much on the automation as on the frequency, the daily cycle being at that time considered “extreme.”
Automated tests are a practice of Extreme Programming, without much emphasis on the distinction between unit and acceptance testing, and with no particular notation or tool recommended.
Ken Schwaber describes the “daily scrum” (which does not appear in his earlier writings, such as the 1995 article “SCRUM Development Process”), this is later recast in pattern form by Mike Beedle.
In ”Surviving Object-Oriented Projects”, Alistair Cockburn describes several projects (dating as far back as 1993) informally using the practice, but does not give it a label; he summarizes it as “Work in increments, focus after each.”
The testing tool JUnit is written by Beck and Gamma, inspired by Beck’s earlier work on SUnit; its growing popularity over the next few years marks the end of the “capture and replay” era.
“Test First” is elaborated into “Test Driven”, in particular on the C2.com Wiki.
Continuous integration and the “daily stand-up” are listed among the core practices of Extreme Programming.
Linda Rising reprints Keonig’s definition of antipattern in "The Patterns Handbook: Techniques, Strategies, and Applications."
The book "AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis" popularized the term antipattern.
The earliest article about Extreme Programming, “Chrysler goes to Extremes”, describes several XP practices such as self-chosen tasks, test first, three week iterations, collective code ownership, and pair programming.
Early on in the elaboration of Extreme Programming, the “System Metaphor” practice is proposed to address the issues of business-technical translation and cognitive friction, however the practice is poorly understood and fails to catch on.
In an article for the C++ Report, Robert C. Martin gives what is perhaps the earliest description of the Agile sense of the terms “iterative” and “incremental.”
Personas are first described in one chapter of Alan Cooper’s “The Inmates are Running the Asylum”, building on prior work in “Goal-Directed design.”
The “rules of simple design” are described for the first time in an IEEE Computer article by Kent Beck, “Embracing Change with Extreme Programming”, summarizing earlier discussions on the OTUG mailing list.
The practice of “refactoring”, incorporated a few years earlier into Extreme Programming, is popularized by Martin Fowler’s book of the same name.
The term “Big Visible Chart” is coined by Kent Beck in “Extreme Programming Explained”, though later attributed by Beck to Martin Fowler.
The unit “Gummi Bears”, an alternative to “story points” for estimating user stories, is first mentioned by Ron Jeffries (later attributed to an XP project led by Joseph Pelrine).
The “three questions” of Scrum’s daily meeting format are largely adopted by Extreme Programming teams.
The roles of Driver and Navigator are introduced to help explain pair programming; the earliest known reference is a mailing list posting. Note, however, that the reality of these roles has been disputed, for instance, Sallyann Bryant’s article ”Pair programming and the mysterious role of the navigator.”
An article by Martin Fowler provides perhaps the most complete description of the continuous integration practice available at that time.
The “mock objects” testing technique is described by Freeman, McKinnon and Craig in their article ”Endo-Testing: Unit Testing with Mock Objects”, an allusion to the “Mock Turtle” character in Lewis Carroll.
The burndown chart is first described by Ken Schwaber, who invented it while working at Fidelity Investments in an attempt to provide Scrum teams with a simple tool kit; he described it formally on his website.
Even though the practice is far from new, nor limited to Agile teams, it is partly due to Agile practices that a revival of “make” type build automation takes place.
17 people who develop software and help others do it met at The Lodge at Snowbird ski resort in the Wasatch mountains of Utah to find common ground among their different approaches to software development. The outcome of this meeting is the Manifesto for Agile Software Development. Several members of those discussions went on to found the Agile Alliance.
An avowed member of the “context-driven” school of software testing, Brian Marick participated in the Snowbird event leading to the publication of the Agile Manifesto; he has often described himself as the “token tester” of the group, bringing some awareness of practices within exploratory testing to the Agile community.
Regular retrospectives are one of the principles of the Agile Manifesto: “At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly”, though not necessarily yet common practice.
Mary Poppendieck’s article, ”Lean Programming”, draws attention to the structural parallels between Agile and the ideas known as Lean or the “Toyota Production System.”
Cruise Control, the first “continuous integration server”, is published under an open source license; it automates monitoring of the source code repository, triggering the build and test process, notifications of the results to the developers, and archival of the test reports; the period 2001-2007 sees a large number of similar tools appear, leading perhaps to an excessive focus on tools over practice.
Among the visualizations described in Norm Kerth’s “Project Retrospectives”, the “Energy Seismograph” can perhaps be seen as a forerunner of the niko-niko calendar.
An article by Bill Wake points out two distinct flavors of estimation in use among Agile teams, relative and absolute estimation.
Refactoring “crosses the Rubicon”, an expression of Martin Fowler describing the wide availability of automated aids to refactoring in IDEs for the language Java.
Some techniques of exploratory testing, together with a first mention of the “context-driven school of software testing”, are introduced in Kaner, Bach, and Pettichord’s ”Lessons Learned in Software Testing.”
The “role-feature-reason” format for expressing user stories was invented at Connextra in the UK.
The Scrum of Scrums is first described (summarizing experiences at IDX) in an article by Jeff Sutherland, Agile Can Scale: Inventing and Reinventing SCRUM in Five Companies.
The XP community endorses retrospectives early on, by way of a paper at XP2001 on ”Adaptation: XP Style.”
The Card, Conversation, Confirmation model is proposed by Ron Jeffries to distinguish “social” user stories from “documentary” requirements practices, such as use cases.
The article, which will later come to largely define project chartering as an Agile practice, is published: “Immunizing Against Predictable Project Failure.”
The first description of a “reflection workshop” in the context of an Agile project appears in Alistair Cockburn’s ”Agile Software Development.”
The term “Project Retrospectives” is introduced in Norm Kerth’s book of the same name.
The term “information radiator” was coined by Alistair Cockburn, part of an extended metaphor which equates the movement of information with the dispersion of heat and gas.
”Pair Programming Illuminated”, by Laurie Williams and Robert Kessler, is the first book devoted exclusively to the practice and discusses its theory, practice, and the various studies up to that date.
Ward Cunningham, one of the inventors of Extreme Programming, publishes Fit, a tool for acceptance testing based on a tabular, Excel-like notation.
An early article by Bill Wake calls attention to the possible inconsistencies arising from terms commonly used within teams, such as “done,” among others.
An early practitioner’s report discusses personas within the broader context: Jeff Patton’s “Hitting the Target: Adding Interaction Design to Agile Software Development” is perhaps the first formal description in an Agile context, although the topic has been discussed informally on mailing lists since at least 2000.
In early (unpublished) discussions of applying Lean ideas to software, seeing undeployed features as “inventory”, Kent Beck mentions continuous deployment at LifeWare and “several others”; it will take several years, however, for the idea to be refined and codified.
The Scrum community picks up the practice of measuring “velocity.”
The burndown gains popularity among the Scrum community, as well as alternatives such as the “burnup” which merely inverts the vertical direction, or the more sophisticated ”Cumulative Flow Diagram”, which most closely resembles a burnup but appears to be an independent invention.
The current form of Planning Poker is set out in an article by James Grenning.
Rebecca Wirfs-Brock and Alan McKean popularized CRC cards through their book on responsibility-driven design, “Object Design: Roles, Responsibilities and Collaborators.”
Joshua Kerievsky at Industrial Logic publishes ”Industrial XP”, a set of proposed extensions to Extreme Programming, which includes the Project Chartering activity, essentially as defined by the 2001 article.
AgileDox, the ancestor of BDD, is a tool generating technical documentation automatically from JUnit tests, written by Chris Stevenson.
Bob Martin combines Fit with Wikis (another invention of Ward Cunningham’s), creating FitNesse.
The Fit/FitNesse combo eclipses most other tools and becomes the mainstream model for Agile acceptance testing.
Kent Beck briefly mentions ATDD in the book “Test Driven Development: By Example” but dismisses it as impractical. In spite of Beck’s objections, ATDD becomes accepted practice due in part to the popularity of Fit/FitNesse.
An anonymous article on the C2 Wiki describes Ping-Pong Programming, a moderately popular variant that marries pairing with test-driven development.
Early Scrum training materials hint at the future importance of the “Definition of Done”, initially only in the form of a slide title: “The story of Done.”
Expanding on their earlier work on Lean Programming, Mary and Tom Poppendieck’s book ”Lean Software Development” describes the Agile task board as a “software kanban system.”
Publication of “Test Driven Development: By Example” by Kent Beck
Thanks in good part to sessions at the XP Day cycle of conferences, more teams start practicing project and iteration retrospectives.
The INVEST checklist for quickly evaluating user stories originates in an article by Bill Wake, which also repurposed the acronym SMART (Specific, Measurable, Achievable, Relevant, Time-boxed) for tasks resulting from the technical decomposition of user stories.
The five-column scrum task board format is described by Mike Cohn on his website; at the time, very diverse variants still abounded.
The term “Nebulous Units of Time” or NUTs is coined by Joshua Kerievsky as an alternative to “story points.”
The term “domain-driven design” was coined by Eric Evans and described in his book of the same name, eventually emerging as a viable alternative to the “System Metaphor.”
The daily meeting is generalized as a core Agile practice, and with widespread use of task boards, gains one final key guideline, “hold the daily meeting near the task board” (described, for instance, by Tobias Mayer).
Kent Beck proposes “Whole Team” as the new denomination for the practice previously known as “On-Site Customer.”
An article by Alberto Savoia proposes “Extreme Feedback Devices” such as lava lamps or dedicated monitors, to display the results of the most recent integration, an important innovation in CI.
To test his hypotheses about de-emphasizing “test” terminology in favor of “behavior”, Dan North releases JBehave.
The INVEST acronym is among the techniques recommended in Mike Cohn’s ”User Stories applied”, which discusses it at length in Chapter 2.
The Planning Poker technique is popularized in the Scrum community, as are a number of planning techniques, by Mike Cohn’s “Agile Estimating and Planning.”
The earliest recorded use of the term "backlog refinement" (aka "backlog grooming") is from Mike Cohn on the Scrum development mailing list; it will be several years before the practice is described more formally.
The first exercises inviting Scrum trainees to reflect on their (local) “definition of done” appear in later iterations of Scrum training materials.
Without giving it that name, Jeff Patton formulates the concepts of story mapping in “It’s All in How You Slice It.”
Several new tools are released, confirming the community’s investment in Behavior Driven Development (BDD), such as RSpec, or more recently, Cucumber and GivWenZen.
Jean Tabaka’s book ”Collaboration Explained” references project chartering as one of the key practices for effective collaboration; though she explicitly cites Industrial XP, her presentation differs in several respects from the 2001 article, indicating a synthesis influenced by other sources.
In collaboration with Chris Matts, North proposes the given-when-then canvas to expand the scope of BDD to business analysis and documents the approach in “Introducing BDD.”
Niko-niko calendars are first described by Akinori Sakata in this detailed web page, which describes how to make and use a Niko-niko Calendar.
The first conference article describing the core of continuous deployment, ”The Deployment Production Line” by Jez Humble, Chris Read and Dan North is published in the proceedings of Agile2006, a codification of the practices of several Thoughtworks UK teams.
The publication of Esther Derby and Diana Larsen’s ”Agile Retrospectives” brings to a close the codification of heartbeat retrospectives.
This part of the Agile Practices timeline is still being edited and updated.
The ”kanbandev” mailing list is formed to provide a venue for discussion of kanban-inspired Agile planning practices.
The first few experience reports from teams using the specific set of alterations known as “kanban” (no iterations, no estimates, continuous task boards with WIP limits) are published, including reports from Corbis (David Anderson) and BueTech (Arlo Belshee).
The simplified three-column task board format (“To Do”, “In Progress”, “Done”) becomes, around that time, more popular and more standard than the original five-column version.
Alan Cooper’s keynote at Agile 2008 marked a formal reconciliation, of sorts, between Agile discourse and interaction design, which had long been perceived to be at odds; invited by “the Agile leadership” as an “outsider”, Cooper came to be perceived over the following year as very much an “insider.”
The Agile 2008 conference features a stage dedicated to discussion of “User Experience” practices, such as usability testing, personas, or paper prototyping.
An emerging definition of exploratory testing is given by Cem Kaner, reflecting the continuing refinement of this approach to testing.
One of the first formal descriptions of backlog refinement (aka backlog grooming) is given by Kane Mar, under the name “Story Time”, and recommending it as a regular meeting.
The story mapping practice is described and abundantly illustrated in Jeff Patton’s “The new user story backlog is a map.”
The practice of continuous deployment has become well established, though still somewhat controversial, as a much commented upon article, ”Continuous Deployment at IMVU” by Timothy Fitz attests; it has become important not only in Agile but also as a core element of more specialized, recent strategies such as Lean Startup or DevOps.
Two entities dedicated to exploring the kanban approach are formed, one addressing business concerns, the LSSC, and a more informal one aimed at giving the community more visibility: the Limited WIP Society.
A comprehensive description of integrating mock objects, TDD, and OO design is provided in Freeman and Pryce’s ”Growing Object-Oriented Software Guided by Tests.”
The practice of backlog refinement (aka backlog grooming) is promoted to an “official” element of Scrum with its inclusion in the Scrum Guides.
James Coplien publishes Two Heads are Better Than One which provides an overview of the history of Pair Programming that traces its origins back to the mid 1980’s, if not before.
Janet Gregory and Lisa Crispin establish a definition of Agile Testing, marking the first succinct definition of that topic.
The first edition of the Agile Practice Guide was published by the Project Management Institute (PMI) in collaboration with the Agile Alliance on October 1, 2017. The guide provides tools, situational guidelines, and an understanding of the various Agile approaches available to enable better results.
Launched during two virtual panel events with Sanjiv Augustine, Jim Highsmith, Jon Kern, and Heidi Musser, Reimagining Agile was formed as a loose working group to reimagine Agile by clarifying and strengthening Agile fundamentals, making them more accessible to everyone. The group felt that Agile needed to be extended to respond to the relevant issues in 2024 and beyond.
The Enterprise Agility Manifesto Initiative was officially announced at Agile2025. This new joint effort from the Agile Alliance and the Project Management Institute (PMI) aimed to define what agility means at the organizational level. The initiative shifted the focus from scaling team-level practices to building the capacity to adapt across entire enterprises.
Reimagining Agility is an Agile Alliance initiative to promote Agile and Agility by re-examining and clarifying the core values and principles of Agile and extending those values and principles into new communities, such as product management, non-IT organizational units, and overall enterprise agility.
From an initiative led by PMI and Agile Alliance, the Manifesto for Enterprise Agility establishes adaptability as the advantage organizations need to reinvent, respond to disruption, and create sustained value amid accelerating change. Unlock the values and principles that power enterprise-wide agility.
Unlock members-only access to online learning sessions, Agile resources, annual conference discounts, and more! And when you join, you’ll be supporting our member initiatives, regional events, and global community groups.
IMPORTANT: We have transitioned to a new membership platform. If you have not already done so, you will need to SET UP AN ACCOUNT on the new platform to establish your user profile. Your previous login credentials will not work until you do this set up.
When you see the login screen, choose “Set up Account” and follow the prompts to create your new account. You can choose to log in using your social credentials for either Google or Linkedin (recommended), or you can set up your account using an email address.
