Project Management & Agile Methodologies
Plan Driven – Waterfall, Agile Development, Scrum, XPProject Management is the process of organizing, directing and measuring the work involved in a given project. It was developed as a means of managing the three interdependent factors that affect the outcome of any successful project: the scope of the work involved, the time-based schedule and the cost of necessary resources. The roots of today’s formalized project management methodologies lie in ancient civil engineering projects. What began as a set of compounding “best practices” emerged in the 1950s as a distinct discipline applicable in an ever-expanding assortment of industries. In the IT sector, the utilization of project management in software development projects began as early as 1957. The first formalized project management methodologies — often referred to as “traditional” or “classic” — were highly disciplined and plan-driven. They can be described as “predictive,” and essentially assume that all aspects of the project, and the future itself, can be anticipated and accounted for with thorough planning.
Plan-Driven MethodologiesTraditional plan-driven models for software design, also known as Software Development Lifecycles (SDLCs) break up projects up into phases. A typical example might be:
- Requirements: Assessing scope of the system requirements and the overall project.
- Architecture and Design: Developing an understanding of the solution from a technical perspective, creating a high-level design of modular components and their interactions, and setting standards for how common technical issues should be resolved.
- Development: Producing code in an environment specific to the culture of the project. Tasks are assigned according to individual skills, and development continues until goals or milestones are reached.
- Testing, Delivery and Feedback: Testing of individual component should be ongoing, with application-level testing towards the end of the project — ideally, involving customers to confirm that requirements have been met, or to identify changes that must be made.
Examples of SDLCs include:
- Waterfall: An early software development process. Eight phases (Conception, Initiation, Analysis, Design, Construction, Testing, Production/Implementation and Maintenance) are carried out to completion in successive, cascading manner.
- PRINCE2 (PRojects In Controlled Environments, Second Version): A generic process framework popular in the UK, not limited to software development. Provides overarching direction with a specific set of project stages (Initiating, Directing, Controlling, Managing Stage Boundaries, Managing Product Delivery, Closing). However, actual tactical practices involved therein are not defined.
Rational Unified Process RUP
- Rational Unified Process (RUP): Also phase-oriented, but iterative — meaning phases may be repeated cyclically and sometimes even overlap. Unlike PRINCE2, RUP outlines a detailed set of practices for even the most minute elements of a project. Consequently, RUP is intricate, overly detailed and difficult to apply.
Rapid Application Development
- Rapid Application Development (RAD): Emphasizes user involvement and the building of prototypes to prove techniques and refine requirements. After the scope of the project is defined in the Requirements Planning phase, users interact with system analysts to develop prototypes in the User Design phase. Users then provide direct feedback during the Construction phase. Finally, in the Cutover phase the end users are trained to use the product as it is deployed.
- Information Technology Infrastructure Library (ITIL): A comprehensive set of processes and best practices for projects in the IT realm. ITIL is a how-to guide for IT projects such as data center design or large-scale institutional network hardware configuration.
Agile Development ProcessesDuring the mid-1990s tech boom, critics of traditional methods emerged within the software development community. Over time it became apparent that rigidly defined, plan driven methodologies were not working. They tended to deliver projects that were late, featured poorly chosen functionality, or were low quality overall. As a result, a shift was made toward processes that ascribe to the general principles of lean development, specifically focusing on the elimination of waste and optimization of the way in which a team delivers value. In 2001, a team of 17 software developers published The Manifesto for Agile Software Development. As stated therein, the guiding principles of Agile development are: Individuals and interactions over processes and tools. Working softwareover comprehensive documentation. Customer collaboration over contract negotiation. Responding to change over following a plan. The model generally emphasizes flexibility, nimbleness and adaptability. Compared to the longer cycles of plan-driven projects, iterative development enables the incremental delivery of capabilities to customers, providing value to customers sooner. Enforcing the discipline of completing individual components of functionality with each iteration mitigates risk relating to scope and schedule uncertainty, and enables major course changes more quickly. Underneath the umbrella of the Agile philosophy a series of specific process frameworks have subsequently emerged, including:
- Scrum: A generic process framework, not limited to software development. Cyclic and iterative, rather than phase-oriented — planning and implementation are concurrent, so while the team is busy building, they’re also planning for the future.
- Crystal Methods: “Crystal Clear” is an example of a software development process that never really took off. It focused more on priorities (safety of the product outcome, efficiency, habitability) and key properties (Frequent Delivery, Reflective Improvement, Close Communication) than process, but was never widely adopted.
Extreme Programming (XP)
- Extreme Programming (XP): XP focuses on tactical best-practices for building software rather than the best ways to get the overall project to the release on time and on budget. It prescribes a very specific set of software development practices, like pair programming, test-driven development, and continuous integration. As a result, agile software projects often use Scrum for project management while drawing tactical practices from XP.