Agile Manifesto Authors (1992-2010)

A collection of IEEE Software articles written by authors of Agile Manifesto. 10 of the 17 authors of the 'Manifesto for Agile Software Development' have written for IEEE Software: Kent Beck, Alistair Cockburn, Ward Cunningham, Martin Fowler, James Grenning, Andrew Hunt, Ron Jeffries, Robert Martin, Steve Mellor, and Dave Thomas.

This collections includes 50 articles published between 1992 and 2010.

(stats / articles)
(stats / downloads)
(top articles)




2010 (1)

2010
Perspectives [The changing nature of software evolution; The inevitability of evolution]
IEEE Software 2010 (4); by B. Boehm, K. Beck

Summary form only given. Traditionally, software evolution took place after software development put a system in place.

2009 (1)

2009
A Pedagogical Framework for Domain-Specific Languages
IEEE Software 2009 (4); by M. Fowler

A framework for thinking about domain-specific languages DSLs divides them into internal DSLs, external DSLs, and language workbenches.

2008 (2)

2008
Point/Counterpoint
IEEE Software 2008 (2); by T. Gilb, A. Cockburn

Traditional software engineering jumps too quickly from high-level quality statements to design ideas.

2008
Tests and Requirements, Requirements and Tests: A Möbius Strip
IEEE Software 2008 (1); by R. C. Martin, G. Melnik

Writing acceptance tests early is a requirements engineering technique that can save time and money and help businesses better…

2007 (3)

2007
Guest Editors' Introduction: TDD--The Art of Fearless Programming
IEEE Software 2007 (3); by R. Jeffries, G. Melnik

Test-driven development is a discipline of design and programming where every line of new code is written in response to a test the programmer writes…

2007
Professionalism and Test-Driven Development
IEEE Software 2007 (3); by R. C. Martin

Test-driven development is a discipline that helps professional software developers ship clean, flexible code that works, on time.

2007
Point/Counterpoint
IEEE Software 2007 (2); by I. Alexander, K. Beck

The key to successful systems is building what the stakeholders desire.

2005 (3)

2005
The state of design [software design]
IEEE Software 2005 (6); by M. Fowler

A useful way to talk about design is to identify principles that lead to well-designed systems.

2005
The test bus imperative: architectures that support automated acceptance testing
IEEE Software 2005 (4); by R. C. Martin

Agile methods more specifically, test-driven development practices have begun to raise the software industry's awareness of automated…

2005
Editor's Introduction: Adapting Agile Approaches to Your Project Needs
IEEE Software 2005 (3); by S. J. Mellor

The author describes how the Agile Alliance began, what the Agile Manifesto advocates, and what he feels are the most important principles in…

2004 (7)

2004
Practice [software construction]
IEEE Software 2004 (6); by D. Thomas, A. Hunt

The concept of "construction" is being a separate activity in the development process.

2004
Imaginate [software construction]
IEEE Software 2004 (5); by A. Hunt, D. Thomas

We looked at the projects requirements and thought they were straightforward.

2004
Open source ecosystems
IEEE Software 2004 (4); by D. Thomas, A. Hunt

The open source OS community can deliver high-quality, very popular software-according to the May 2004 Net-craft survey, the Apache Web server…

2004
OO in one sentence: keep it DRY, shy, and tell the other guy
IEEE Software 2004 (3); by A. Hunt, D. Thomas

Some people feel that "getting" object-oriented programming is a difficult, time-consuming process.

2004
Module assembly [programming]
IEEE Software 2004 (2); by M. Fowler

How to modularize a program is one of the most general and important issues in software design.

2004
Nurturing requirements
IEEE Software 2004 (2); by D. Thomas, A. Hunt

We focus on requirements engineering. The fundamental problem here is that we believe that underlying every project there's some absolute, discoverable…

2004
Three legs, no wobble [software construction]
IEEE Software 2004 (1); by A. Hunt, D. Thomas

We look at how to ruin a software project in just three easy steps there are many more, of course, but we'll start with these: 1.

2003 (10)

2003
Data access routines
IEEE Software 2003 (6); by M. Fowler

One of the most important things about good design is modularity: dividing a system into separate pieces so that you can modify one module without the changes…

2003
Pipelines [Unix programming]
IEEE Software 2003 (6); by D. Thomas, A. Hunt

One of the underlying philosophies of the Unix command shell is the idea of the pipeline: take a set of small, specialized programs and let them interact by…

2003
Design - Who needs an architect?
IEEE Software 2003 (5); by M. Fowler
2003
Preparing the raw material
IEEE Software 2003 (5); by A. Hunt, D. Thomas

Any construction project begins with raw material, and as Confucius suggests, the nature of the raw material is critical to…

2003
Model-driven development - Guest editor's introduction
IEEE Software 2003 (5); by S. J. Mellor, A. N. Clark, T. Futagami

Presents the guest editorial for this issue of the publication.

2003
Verbing the noun [software development]
IEEE Software 2003 (4); by D. Thomas, A. Hunt

Software development seems to be a discipline of artifacts; the developers spend their time producing products and attempting to find ways to measure just how…

2003
The trip-packing dilemma [agile software development]
IEEE Software 2003 (3); by A. Hunt, D. Thomas

A guiding principle behind agile software development is the idea of keeping things simple.

2003
Patterns [software patterns]
IEEE Software 2003 (2); by M. Fowler

Patterns provide a mechanism for rendering design advice in a reference format.

2003
When to make a type [programming]
IEEE Software 2003 (1); by M. Fowler

When I started programming computers, I began with fairly primitive languages, such as Fortran 4 and various early flavors of Basic.

2003
The art of enbugging
IEEE Software 2003 (1); by A. Hunt, D. Thomas

One of the best ways to keep future bugs out is to maintain a proper "separation of concerns", that is, design the code so that classes and modules have…

2002 (9)

2002
Using metadata
IEEE Software 2002 (6); by M. Fowler

I occasionally come across people who describe their programming tasks as tedious, which is often the sign of a design problem.

2002
State machines
IEEE Software 2002 (6); by D. Thomas, A. Hunt

We are surrounded by real-world state machines: ballpoint pen retractor mechanisms, vending machines, washing-machine controllers,…

2002
Zero-tolerance construction [software development]
IEEE Software 2002 (5); by A. Hunt, D. Thomas

Software construction is the ultimate embodiment of the software development process.

2002
Yet another optimisation article
IEEE Software 2002 (3); by M. Fowler

The author addresses the question: how do we achieve a fast program For many programmers, performance is something you pay continuous attention to as you…

2002
Mock objects
IEEE Software 2002 (3); by D. Thomas, A. Hunt

One thing that makes unit-testing code so hard is the way the real world keeps intruding.

2002
Public versus published interfaces
IEEE Software 2002 (2); by M. Fowler

One of the growing trends in software design is separating interface from implementation.

2002
The software engineering of internet software
IEEE Software 2002 (2); by E. Hendrickson, M. Fowler
2002
Software archaeology
IEEE Software 2002 (2); by A. Hunt, D. Thomas

This isn't programming, this is archaeology the programmer complained, wading through the ancient rubble of some particularly crafty…

2002
Ubiquitous automation
IEEE Software 2002 (1); by A. Hunt, D. Thomas

The way we construct software should not be arbitrary.

2001 (6)

2001
To be explicit [software design]
IEEE Software 2001 (6); by M. Fowler

Software is an odd medium in which to construct something.

2001
Launching extreme programming at a process-intensive company
IEEE Software 2001 (6); by J. Grenning

The author describes a project that was started using many extreme programming practices in a company that has a traditional formal…

2001
Aim, fire [test-first coding]
IEEE Software 2001 (5); by K. Beck

The author argues that test-first coding is not testing.

2001
Reducing coupling
IEEE Software 2001 (4); by M. Fowler
2001
Separating user interface code
IEEE Software 2001 (2); by M. Fowler

The first program I wrote on a salary was scientific calculation software in Fortran.

2001
Avoiding repetition [software design]
IEEE Software 2001 (1); by M. Fowler

Software design is not easy-not easy to do, teach, or evaluate.

2000 (4)

2000
Selecting a project's methodology
IEEE Software 2000 (4); by A. Cockburn

How do we determine the need for various software processes or methodologies, and what helps us choose the appropriate one for our project To answer…

2000
Strengthening the case for pair programming
IEEE Software 2000 (4); by L. Williams, R. R. Kessler, W. Cunningham, R. Jeffries

The software industry has practiced pair programming two programmers working side by side at one computer on the same problem with great…

2000
Strengthening the case for pair programming
IEEE Software 2000 (4); by L. Williams, R. R. Kessler, W. Cunningham, R. Jeffries

The software industry has practiced pair programming two programmers working side by side at one computer on the same problem with great…

2000
eXtreme Programming development through dialog
IEEE Software 2000 (4); by R. C. Martin

To those who are unfamiliar with the method, eXtreme Programming might conjure up visions of programmers madly hacking away without concern for…

1997 (3)

1997
Designing interfaces for programmers
IEEE Software 1997 (6); by R. Jeffries

Describes tools, techniques and concepts to optimize user interfaces.

1997
Using patterns to improve our architectural vision
IEEE Software 1997 (1); by N. L. Kerth, W. Cunningham

Pattern languages can play an important role in furthering the use of architecture and objects in software design, but first we must understand what these…

1997
Why Explore Object Mathods, Patterns, and Architectures?
IEEE Software 1997 (1); by S. J. Mellor, R. Johnson

1992 (1)

1992
Interface-usability evaluation: science of trade-offs
IEEE Software 1992 (5); by J. R. Miller, R. Jeffries

The effectiveness of four techniques in evaluating the usability of a graphical user interface is presented.