home 
 
 
 
nlfr
 
Home
About ABIS
Services
Courses
Resources
Contact
MyABIS
C
What is available?ABIS Infor » 2017-09 » 2017-01 » 2016-11 » 2016-06 » 2016-04 » 2016-02 » 2015-03 » 2014-03 » 2013-04 » 2013-01 » 2012-10 » 2012-06 » 2012-04 » 2012-01 » RUP and Agile and the like » CICS: from 3270 to service » "Ex Cathedra" vs. "Hands On" » WebSphere Application Server from 6.1 to 7 or to 8 » 2011-11 » 2011-10 » 2011-08 » 2011-06Exploring Db2Presentations and papersTest your knowledge 

ABIS Infor - 2012-01

RUP and Agile and the like

Ludo Van den dries (ABIS) - 16 January 2012

Abstract

For more than 50 years we have been writing applications, and we have made tremendous progress on the technical side (hardware and software). Mastering and managing the software production process appears to be one of the toughest challenges, as indicated by the myriad of software development methods and process models that keep appearing and fading away. The last decade, a lot of attention went to incremental and iterative approaches like the Rational Unified Process (RUP) and several methods grouped under the 'Agile' umbrella.

Introduction

In the beginning (of the computing era) there was only darkness: our programs were unstructured (spaghetti code) and we had no clue how to structure the development process. Around 1970 we introduced structured programming to get more modular coding, thereby improving readability, maintainability and reusability. And on the process level we introduced structured development methods, describing and organizing the main activities (or call it steps, flows, roles, disciplines, ...) to achieve working software: requirements gathering, analysis, design, construction, testing, etc.

After that, each of the subsequent methods tried to improve on the previous ones, by formulating a different way to perform the same activities, or renaming and refining them (e.g. functional analysis, detailed design), and suggesting more/other tools to achieve the goal, and more/other deliverables (documents, models, diagrams, modules) to be produced.

Actually the word 'method' - or in full: software development method(ology) - does not have a single and precise definition. It embraces many aspects. Apart from describing the aforementioned activities, roles and deliverables, it also (implicitly or explicitly) adheres to a software development process model (or in short: a process), specifying the software life cycle.

The first methods assumed a Waterfall process: every step (from requirements to delivery) is only executed once. The Waterfall process got criticized for its rigidity: it does not deal well with changing or unclear requirements, design uncertainties etc.

As a reaction, from the 1980s on, methods started incorporating a cyclical approach, allowing earlier delivery and continuous improvement. Some efforts: RAD, Spiral, Iterative & Incremental. This is where the story of RUP and Agile starts.

The Rational Unified Process (RUP)

The RUP is a concrete implementation of the open Unified Process, which was developed mainly by Booch, Rumbaugh and Jacobson in the late 1990s - the 'tres amigos' working for Rational (the CASE tool vendor, since 2003 part of IBM), and who also stood at the cradle of the Unified Modelling Language (UML).

The main characteristics of the RUP are:

Actually the RUP calls itself a software development process model framework, thereby indicating that there are many degrees of freedom, and that it can be implemented in many different ways, depending on the situation. The original UP specifications mentioned e.g. 32 different roles (Systems Analyst, Requirements Specifier, Software Architect, Designer, etc.), and more than 100 different deliverables (documents, modules, etc.), often to be produced/revised at each iteration.

Although the RUP does not impose to use all of these options all the time, many RUP projects suffered from this 'embarras du choix'. The movement, that reacted to this aspect of 'too much ceremony', is known as the Agile Development.

Agile Software Manifesto

In 2001 a group of 17 leading software gurus formulated the Manifesto for Agile Software Development, which summarized the principles of 'lightweight' development as they were present in several emerging methods such as Extreme Programming, Scrum and DSDM, to form a counterpart to the RUP, with values such as:

This was concretized into 12 principles:

Agile methods

In fact the several member methods of the Agile movement do concentrate on various aspects.

The most popular Agile emanation, Scrum (1995), stems from the manufacturing world, and is not specific for software development: it concentrates on the project management aspect, with characteristics such as

While also adopting standard agile features such as frequent delivery (e.g. 2 weeks iteration), small self-organizing teams and heavy customer participation, Extreme Programming (XP, 1999) adds specific software accents:

In 2006 IBM/Rational produced a explicitly lightweight version of the (R)UP, calling it OpenUP and donating it to the community as a part of the openEclipse Process Framework (EPF). It is not clear whether this OpenUP gathered much momentum until now. In fact several other parties (e.g. Scott Ambler) have published their own lightweight RUP implementation.

Agile adoption and criticism

Many of the Agile principles are just 'common sense' and were already practised by well-organized teams long before the publication of the Agile Manifesto. It appears that the approach needs skilled, experienced and motivated team members, with little place for junior developers.

Since the Agile requires small self-organizing teams, there may be a scalability issue (although there exists something like 'a Scrum of Scrums'): for large and/or mission-critical projects, most enterprises still prefer the Waterfall model with its stricter up-front planning.

 

Want to find out more about Scrum and Agile? Take a look at http://www.abis.be/html/en1590.html.