Agile 101
Agile Practices Timeline
Trace the history and evolution of Agile from its roots in 1968, and learn how it has evolved through the years.
1968: “Conway’s Law”
“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.)
1976:
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.
1976:
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).
1977:
Creation of the “make” tool for Unix systems – the principle of automating software builds is not a new idea.
1980:
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.
1980:
The notion of “visual control” originating in the Toyota Production System is an anticipation of “information radiators”.
1983:
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.
1984:
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.
1984:
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”.
1984:
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”.
1985:
Perhaps the first explicitly named, incremental alternative to the “waterfall” approach is Tom Gilb’s Evolutionary Delivery Model, nicknamed “Evo”.
1986:
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).
1986:
1986: 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.
1988-1990:
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.
1988:
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.
1988:
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”.
1989:
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.
1990:
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”
1990:
Testing discipline dominated by “black box” techniques, in particular in the form of “capture and replay” testing tools
1990's:
Owing to the rise in popularity of RAD tools and IDEs, “make” type tools acquire a mixed reputation
1991:
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.
1991:
Independent creation of a testing framework at Taligent with striking similarities to SUnit (source)
1992:
“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.
1992:
A comprehensive description of “refactoring” is presented in Opdyke’s thesis, “Refactoring object-oriented frameworks”
1993:
“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.
1993:
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.
1993:
Jeff Sutherland invents Scrum as a process at Easel Corporation.
1994:
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
1995:
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.
1995:
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.
1995:
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.
1995:
The earliest writings on Scrum introduce the notion of the “sprint” as iteration, although its duration is variable.
1995:
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”.
1995
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.”
1995
Ken Schwaber and Jeff Sutherland co-present Scrum at the OOPSLA Conference.
1996:
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”.
1996:
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.
1997:
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.
1997:
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”.
1997:
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.
1998:
Continuous integration and the “daily stand-up” are listed among the core practices of Extreme Programming.
1998
Linda Rising reprints Keonig’s definition of antipattern in the The patterns handbook: techniques, strategies, and applications.
1998
The book AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis popularized the term antipattern.
1998:
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.
1999:
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.
1999:
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”.
1999:
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”.
1999:
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.
1999:
The practice of “refactoring”, incorporated a few years earlier into Extreme Programming, is popularized by Martin Fowler’s book of the same name.
1999:
The term “Big Visible Chart” is coined by Kent Beck in “Extreme Programming Explained”, though later attributed by Beck to Martin Fowler.
1999:
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).
2000,ca:
The “three questions” of Scrum’s daily meeting format are largely adopted by Extreme Programming teams.
2000 (or earlier):
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”.
2000:
An article by Martin Fowler provides perhaps the most complete description of the continuous integration practice available at that time.
2000:
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
2000:
The burndown chart is first described by Ken Schwaber, who invents it while working at Fidelity Investments in an attempt to provide Scrum teams with a simple tool kit; he describes it formally on his Web site.
2000's:
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.
February 11-13 2001:
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 that discussion went on to found the Agile Alliance.
2001:
An avowed member of the “context-driven” school of software testing, Brian Marick participates 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.
2001:
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.
2001:
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”.
2001:
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.
2001:
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.
2001:
An article by Bill Wake points out two distinct flavors of estimation in use among Agile teams, relative and absolute estimation.
2001:
Refactoring “crosses the Rubicon”, an expression of Martin Fowler describing the wide availability of automated aids to refactoring in IDEs for the language Java.
2001:
Some techniques of exploratory technique, 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”.
2001:
The “role-feature-reason” format for expressing user stories is invented at Connextra in the UK.
2001:
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.
2001:
The XP community endorses retrospectives early on, by way of a paper at XP2001 on ”Adaptation: XP Style”
2001:
The Card, Conversation, Confirmation model is proposed by Ron Jeffries to distinguish “social” user stories from “documentary” requirements practices such as use cases
2001:
The article which will later come to largely define project chartering as an agile practice is published:“Immunizing Against Predictable Project Failure”
2001:
The first description of a “reflection workshop” in the context of an Agile project appears in Alistair Cockburn’s ”Agile Software Development”
2001:
The term “information radiator” is coined by Alistair Cockburn, part of an extended metaphor which equates the movement of information with the dispersion of heat and gas
2002:
”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
2002:
Ward Cunningham, one of the inventors of Extreme Programming, publishes Fit, a tool for acceptance testing based on a tabular, Excel-like notation
2002:
An early article by Bill Wake calls attention to the possible inconsistencies arising from terms commonly used within teams, such as “done”
2002:
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
2002:
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
2002:
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
2002:
Rebecca Wirfs-Brock and Alan McKean popularized CRC cards through their book on responsibility-driven design, Object Design: Roles, Responsibilities and Collaborators. (Amazon Affiliate Link)
2003:
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
2003:
AgileDox, the ancestor of BDD, is a tool generating technical documentation automatically from JUnit tests, written by Chris Stevenson
2003:
Bob Martin combines Fit with Wikis (another invention of Cunningham’s), creating FitNesse
2003:
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.
2003 to 2006:
The Fit/FitNesse combo eclipses most other tools and becomes the mainstream model for Agile acceptance testing
2003:
An anonymous article on the C2 Wiki describes Ping-Pong Programming, a moderately popular variant which marries pairing with test-driven development
2003:
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”
2003:
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”
2003:
Thanks in good part to sessions at the XP Day cycle of conferences, more teams start practicing project and iteration retrospectives
2003:
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.
2003:
The five-column task board format is described by Mike Cohn on his Web site; at the time, as this photo gallery collected by Bill Wake shows, very diverse variants still abound.
2003:
The term “Nebulous Units of Time” or NUTs is coined by Joshua Kerievsky as an alternative to “story points”
2003:
The term “domain driven design” is coined by Eric Evans and described in a book of the same name, eventually emerging as a viable alternative to the “System Metaphor”
2004 to 2006:
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)
2004:
Kent Beck proposes “Whole Team” as the new denomination for the practice previously known as “On Site Customer”
2004:
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
2004:
In order to test his hypotheses about de-emphasizing “test” terminology in favor of “behavior”, Dan North releases JBehave
2004:
The INVEST acronym is among the techniques recommended in Mike Cohn’s ”User Stories applied”, which discusses it at length in Chapter 2.
2005:
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”
2005:
The earliest recorded use of the term “backlog grooming” is from Mike Cohn on the Scrum development mailing list; it will be several years before the practice is described more formally
2005:
The first exercises inviting Scrum trainees to reflect on their (local) “definition of done” appear in later iterations of Scrum training materials
2005:
Without giving it that name, Jeff Patton formulates the concepts of story mapping in “It’s All in How You Slice It”.
2006 to 2009:
Several new tools are released confirming the community’s investment in BDD, such as RSpec or more recently, Cucumber and GivWenZen
2006:
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
2006:
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”
2006:
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
2006:
The publication of Esther Derby and Diana Larsen’s ”Agile Retrospectives” brings to a close the codification of heartbeat retrospectives
2007:
By that point the “Definition of Done” as a full-fledged practice, and as a textual checklist displayed in the team room, has become widespread.
2007:
The ”kanbandev” mailing list is formed to provide a venue for discussion of kanban-inspired Agile planning practices
2007:
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)
2007:
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
2008:
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”
2008:
An emerging definition of exploratory testing is given by Cem Kaner, reflecting the continuing refinement of this approach to testing
2008:
One of the first formal descriptions of “backlog grooming” is given by Kane Mar, under the name “Story Time”, and recommending it as a regular meeting
2008:
The Agile 2008 conference features a stage dedicated to discussion of “User Experience” practices, such as usability testing, personas or paper prototyping
2008:
The story mapping practice is described and abundantly illustrated in Jeff Patton’s “The new user story backlog is a map”
2008:
While the first few allusions to teams using a “definition of ready” date to the beginning of that year, the first formal description seems to be from october, and is incorporated into “official” Scrum training material shortly thereafter
2009:
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
2009:
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
2010:
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”
2011:
The practice of “backlog grooming” is promoted to an “official” element of Scrum with its inclusion in the Scrum Guide
2015:
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.
2017
Janet Gregory and Lisa Crispin establish a definition of Agile Testing, marking the first succinct definition of that topic.
