• 1968: “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.)
  • 1970s: Barry Boehm proposes “Wideband Delphi”, a forerunner of Planning Poker
  • 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
  • 1980s: 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”
  • 1985: the ETVX (for entry-task-validation-exit) framework described in ”A programming process architecture” anticipates Scrum’s definitions of “ready” and “done”
  • 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: the term “Scrum” appears in an article by Takeuchi and Nonaka ”The New New Product Development Game”, often cited as an inspiration for Scrum, the framework; however, it only appears once (in the title of a section: “Moving the scrum downfield”) and does not at this point refer to any sort of meeting
  • 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: Rebecca Wirfs-Brock describes the conceptual aspects of CRC, which she invented while she and Cunningham were working at Tektronix, in her book ”Designing object-oriented software”.
  • 1990: testing discipline dominated by “black box” techniques, in particular in the form of “capture and replay” testing tools
  • 1990s: 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
  • 1991: independent creation of a testing framework at Taligent with striking similarities to SUnit (source)
  • 1991: the details of the “timebox” are described at length in one chapter of James Martin’s Rapid Application Development
  • 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 this article 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
  • 1994: Jim Coplien, describing his observations of the “hyperprodutive” 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
  • 1994: Kent Beck writes the SUnit testing framework for Smalltalk (source)
  • 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 exit, 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”.
  • 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 to 2002: “Test First” is elaborated into “Test Driven”, in particular on the C2.com Wiki
  • 1998: article on Extreme Programming mentions that “we usually write the test first” (source)
  • 1998: continuous integration is listed among the core practices of Extreme Programming
  • 1998: in “Chrysler goes to Extremes”, the earliest article about Extreme Programming, pair programming is presented as one of the core practices of the C3 team; it is later described formally as one of XP’s original “twelve practices”
  • 1998: the “daily stand-up” is listed as one of the core practices in Extreme Programming
  • 1998: the earliest writing on Extreme Programming mentions “tasks assigned” vs “tasks self-chosen” as one of the salient differences between the “old way” and the Extreme Way.
  • 1998: the first writings on Extreme Programming describe fixed-length, three-week iterations and emphasize the advantage of this scheme in obtaining imprecise but accurate feedback on schedule performance
  • 1998: the earliest writings on Extreme Programming recommend “Collective Code Ownership” as an official practice. The “extremos” argue, much as Coplien does in the opposite direction, that other Extreme Programming practices mitigate the problems cited against collective ownership: uniform code conventions and extensive tests.
  • 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: Mock Objects are among the novel techniques developed during that period (source)
  • 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: the term “velocity” is a relatively late addition to Extreme Programming, replacing a previous notion of “load factor” deemed overly complex
  • 2000s: 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
  • 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: 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: 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: 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: 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 “quick design session” is described in ”Extreme Programming Installed
  • 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 “Project Retrospectives” is introduced in Norm Kerth’s book of the same name
  • 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 Scrum community picks up the practice of measuring “velocity”
  • 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: the current form of Planning Poker is set out in an article by James Grenning
  • 2003 to 2004: driven by the popularity of Fit/FitNesse ATDD becomes accepted practice in spite of Beck’s objections
  • 2003-2006: for some time the Fit/FitNesse combo eclipses most other tools and becomes the mainstream model for Agile acceptance testing
  • 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: Kent Beck briefly mentions ATDD in the book “Test Driven Development: By Example” but dismisses it as impractical
  • 2003: agiledox, the ancestor of BDD, is a tool generating technical documentation automatically from JUnit tests, written by Chris Stevenson
  • 2003: adoption of Fit, which has remained marginal, booms when Bob Martin combines Fit with Wikis (another invention of Cunningham’s), creating FitNesse
  • 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: publication of Test Driven Development: By Example by Kent Beck
  • 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 cheklist 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-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-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: more recently, tools inspired by the BDD approach have renewed competition in the acceptance testing area
  • 2006: niko-niko calendars are first described by Akinori Sakata in this Web article
  • 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
  • cf. the 3 C’s model, 2001
  • cf. the Given-When-Then template, 2006
  • cf. the INVEST checklist, 2003
  • cf. the Role-feature-benefit template, 2001