ETPM5

Project Management National Conference 2011 PMI India

Unleash, an Active Project
Management System: Cloud based
Project Management tool for Agile,
Waterfall and Hybrid approaches

Dr. Srinivas Telukunta,
Mr. Raghu Kumar Katakam,
Mr. G Swamy Naidu,
Mr. Srinivasu Nimmakayala

2|P a g e
Application of Select Tools of Psychology for Effective Project Management


Contents
1 Abstract:.............................................................................................................................4
2 Keywords:..........................................................................................................................4
3 Introduction: ......................................................................................................................5
4 Related Work: ...................................................................................................................6
5 Current Work: ...................................................................................................................7
5.1 Introduction:....................................................................................................................7
5.2 Approach:........................................................................................................................9
5.3 Experiments:..................................................................................................................11
5.3.1 Metrics:.......................................................................................................................11
5.3.2 Projects:......................................................................................................................12
5.4 Results:..........................................................................................................................13
5.4.1 Human Factors:..........................................................................................................14
6 Future Work: ...................................................................................................................14
7 Conclusions: ....................................................................................................................15
8 Authors’ Profiles..............................................................................................................15
9 References........................................................................................................................17

3|P a g e


1 Abstract:

Traditional waterfall approaches are based on clear structure, control,
progression, finite project cycles and works well when the project has well known
phases with defined work at the beginning of a phase. Agile techniques on the
other hand provide freedom for teams to iterate through a single deliverable
numerous times, until a desired level of quality is achieved and works well, when
certain amount of flexibility is available to prioritize, as project progresses and
partial results or features are implemented.

Both approaches have significant yet different benefits, and are generally seen
as being mutually exclusive of one another. It is the authors’ contention that
certain elements of these two seemingly different approaches can be combined
to achieve better results, not possible with traditional methods alone. These are
demonstrated using their online, cloud based project management tool (Unleash)
whose methodology and functioning will allow for collaboration across various
departments with iterations, under the broad framework of defining project
management work in various phases. This method allows for easy transition and
adoptability of Agile methods into traditional settings with positive results.

Some salient features of unleash include:

• Manage projects, programs, portfolios and products on a cloud (Self
managed or outsourced).

• Manage meetings, track information and streamline creation of
Information radiators.

• Creation of collaborative environment where teams emphasize faster
product creation following a mix of water fall and agile technologies as
appropriate.

• Use traditional waterfall approach, completely agile approach or any
degree of Agility in between the two approaches as appropriate to the
project needs.

2 Keywords:

Unleash, Agile and waterfall coupling, Cloud Project Management, Flexible
Project Management, Software Configuration Management System, Hybrid
project management approach, Hybrid project management approach results,

4|P a g e


Online project management system, Online project tracking, Efficient software
development process.

3 Introduction:

In any software development, the challenging task is to complete projects under
the pressure of dynamic market, where “Time to Market (TTM)” and
requirements instability could result in the failure of projects execution. Under
these conditions, it becomes imperative that teams should use development
methods which have the ability to minimize problems due to requirements of
faster development time and somewhat (or sometimes drastically) changing
requirements. Agile teams argue that traditional waterfall approaches are unable
to cope with the rapid changes of the dynamic market, because of their strong
emphasis on a detailed and thorough planning in addition to detailed design
techniques (Sommerville, 2006). On the other hand, agile teams claim that agile
methodology is a better solution to deal with problems arising out of dynamic
market because agile achieves higher flexibility and is better able to satisfy
actual customer requirements. Agile achieves this, by developing and delivering
the software product in an incremental fashion. Agile methodologies try to avoid
any development overheads, and minimize unnecessary effort. This paper
presents an approach to project management which offers the teams, flexibility to
use either of the approaches and adjust the “Agility” of a project as needed
during the course of the project and thereby significantly reduce the software
development time (and cost) by providing a choice to adopt the best of both the
approaches as appropriate for the project needs.

Traditional waterfall methodologies are designed to control and solve the
problems associated with the development style which is based on “coding first
and fixing next”, where the software is written without a complete emphasis on
immediately usable software and relies on making many short term decisions. As
the code grows it becomes a huge problem to add new features or fix bugs
without incurring significant additional costs (Fowler M. , 2005). These difficulties
are overcome by the traditional approaches by adopting a rigid up-front design
technique which results in detailed development plan (W.Royce, 1970). Agile
methods deal well with unstable and changing requirements by using a number
of techniques of which most noticeable are: low ceremony documents, short
iterations, early testing, and customer collaboration. These characteristics enable
agile methods to obtain the smallest workable piece of functionality to deliver the
business value early and continually improving it while adding further
functionality throughout the life of the project (Cohn, Nov 11, 2005). The major
impact of changes in requirement using traditional waterfall approach is the cost
that is spent on fixing the defects. It is very expensive to fix a change in
requirements especially in the late phases of waterfall methods (Roger, 2005) as
seen in Figure-1. Fixing errors increases the cost exponentially the later they are

5|P a g e


detected in the development lifecycle because the artifacts within a serial
process build on each other (Ambler, 2006).

Figure 1: Cost of Changes in Waterfall Methods

In agile methodologies, the effect of changes of requirements is minimized as
Figure-2 shows and controlled by depending on implementation of requirements
in small releases (M. Kamel, 2010). The changes of requirements during small
period of time seldom happen, and even if they do, they are immediately
prioritized by project stakeholders, and added to the requirements stack in the
appropriate increments.

Figure 2: Cost of Changes in Agile Methods

4 Related Work:

Significant research has been done which provides some guidelines as to when
to use agile based methods and when to use traditional water fall based
methods. For example, Boehm Turner's work looks at several characteristics like
criticality, culture and dynamism (Barry, August 15, 2003) to decide on the choice
of the method to be used. Andrew and Nachiappan (Nagappan, MSR-TR-2007-

6|P a g e


09, no. (2007): 10) reported on the results of an empirical study conducted at
Microsoft by using an anonymous web-based survey. They found that one third
of the study respondents use Agile methodologies to varying degrees and most
view it favorably due to improved communication between team members, quick
releases and the increased flexibility of agile designs. Their findings also suggest
that developers are most worried about scaling Agile to larger projects, and
coordinating agile and traditional teams. Most existing literature and
methodologies focus on the parameters to consider in making a choice between
either traditional waterfall based approaches or Agile based approaches by
treating them as exclusive approaches. In addition, quantified literature results on
the application of these nascent methods are very few.

5 Current Work:

The complexity of everyday software development has changed dramatically in
the last several years. Teams want to deliver higher quality software at a rapid
pace. The current work described here is focused on development of
methodology for integration of the best practices of both Agile and traditional
practices and treats them as mutually complementary, rather than as exclusive
methodologies. Our goal is to present a way to combine these methods and
make it applicable for larger projects and gain efficiencies. The approach
combines peer review, short development cycles, issue based branching, allows
advanced integrated development environment (IDE) and web-based
collaborative tools to develop high quality software that meets customer
requirements meeting cost and schedule constraints.

5.1 Introduction:

Developing high-quality software which meets customer requirements and user
needs is the desired outcome of any software development process, but the
software development industry is still far from being able to meet this goal in a
satisfactory way. Various studies (NandhaKumar J, 1999) have been made
which argue that traditional software development methods “are treated primarily
as a necessary fiction to present an image of control or to present a symbolic
status”. Truex et al (Truex, 2000) go even further to claim that it is possible that
traditional methods and “merely unattainable ideals and hypothetical ‘strawmen’
that provide normative guidance to utopian development situations”. While a
perfect agreement on what the concept of “Agile” actually refers is yet to be
made, it has generated a lot of interest among practitioners, project management
consultants and also lately in the academia. The introduction of “Extreme
Programming (XP)” (Beck, 1999a) is widely acknowledged as the starting point
for the various agile approaches. Despite enormous interest, a clear agreement
on how to distinguish agile methods from traditional methods has been made.
While some effort has been made to establish a few guidelines as to the

7|P a g e


applicability of these methods for various situations, existing literature is mostly
based on exclusive application of either of these methods with hardly any
consideration for the possibility of application of a hybrid approach, utilizing the
best principles of both the approaches. There is very little known at this stage
about the actual payoffs to the investment made into process improvement
efforts, and even less is known about how much an organization will benefit from
the use of agile software development approaches. The initial industry
experiences have been positive (Grenning, 2009 (18)), but hard numbers are not
yet available with a good degree of certainty. There is hardly any literature which
presents the methods or benefits of using a hybrid approach. This paper aims to
address some of these gaps by presenting an approach and preliminary results
of one such hybrid approach to software development process. This article thus
has three broad purposes. Firstly, a hybrid approach where both traditional and
agile methodologies are used for software development is introduced. Secondly,
an analysis of the preliminary results obtained with the use of this approach is
made and finally, directions for future work and larger scale implementation of
these methods is proposed.

The aim of this paper is to introduce “Unleash”, a cloud based software
development management tool which allows incorporation of concepts from the
modern world of agile development, as well as current best-practice version
control systems from the traditional waterfall based methodologies. This
methodology allows for

• Management of the complexity associated with geographically
distributed teams working under different time zones.

• Integration of Waterfall, Agile or a mix of Hybrid project management
approaches in the management of software development process.

• Provide transparency and allow acceleration of the software
development process by providing customized work flow for each
software development project.

This work is organized into three sections. In the following section (Section 3.2
Approach), a hybrid method to integrate the principles of agile development
methodology in a traditional software development project is made. The second
section (Section 3.3) presents a few project cases which have been used as test
cases for the application of the hybrid development approach. Finally,
comparative preliminary results from the hybrid approach are presented with a
concluding section (Section 3.4) of various possible future studies which can
further extend the utility of the proposed methodology.

8|P a g e


5.2 Approach:

Design in traditional methodology begins once the requirements have been
completely analyzed, modeled and documented. In the traditional methodologies,
design team (architects) is usually separated from implementation team
(programmers). Architects think out the big issues in advance and do not need to
write code, because they do not build the software, they only design it. Towards
this end, they typically use various design techniques (like UML etc) which gets
away from the details of programming and allows working at an abstract level.
Once the design is done, architects hand it off to the programmers to write the
code. Since the design is thought off at a high level, decisions on many small
details are avoided. Architects create four design models (Figure-3) to complete
a specification of design and all design activities are well documented using a
documentation standard that has been selected in the analysis phases. These
documents would be the main source for the programmers to implement the
system.

Figure 3: Design models in traditional development approach

9|P a g e


Agile design rigorously follows the “keep it simple and design for today” principle.
Agile methodologies assume that more design for future, results in more complex
design, which lead to more unnecessary costs. In addition to that, the design
provides implementation guidance for a unit of requirements (usage of user
stories) as it is written and nothing less, nothing more. The design of extra
functionality (because it will be needed later) is discarded. Agile methodologies
use simple tools to keep the simplicity. They do not elaborate by using complex
and detailed tools. If a difficult design problem is encountered, agile
methodologies recommend the immediate creation of an operational prototype of
that portion of the design. The intent of this is to lower risk when true
implementation starts and to validate the original unit of requirement. Agile
encourages refactoring technique which is a reorganization technique that
improves, simplifies and maximize the efficiency of the design (or code) of a
component without changing its function or behavior. When software is
refactored, the existing design is examined for redundancy, unused design
elements, inefficient or unnecessary algorithm, poorly constructed or
inappropriate data structures or any other design failure that can be corrected to
yield a better design.

The proposed approach makes use of the principles from both traditional water
fall approach and the agile methodologies. Since, the purpose of the article is not
to describe the Agile methodology in detail, we are skipping these details and
can be referenced by interested elsewhere (Fowler M. ). In the proposed
approach the projects are planned in accordance to the water fall approach but
the actual implementation is done following agile methodologies making use of a
hybrid approach for project completion.

All the implementation is done by breaking the work into tasks which are of one
week in duration and consists of various features to be developed. The duration
is always fixed to one week and never changes (Similar to the concept of a “30
day Sprint” in Scrum (Degrace, 1990)). The one week tasks ensure that
significant amount of work does not progress without code review and the
developer has a well specified and easily understandable task with defined
features to complete. A prioritized ``wish list'' of existing and future development
features is also maintained in parallel, ordered by their expected iteration. The
team creates and updates the ``wish list'' to allow any member at any time to
view the feature deemed most important to incorporate into the next iteration.
Code reviews usually happen within a few hours and is usually scheduled to be
completed (for the code developed in the previous week) by end of a Monday.
Reviews are done by use of various automated tools like bug detectors,
structural analyzers etc to maintain high quality code. Because the task is fairly
small in size, sometimes the formal design review is skipped and most designs
are decided by the team with use of a white board and informal discussions. A
few occasional formal design meetings are held for tasks perceived to be critical
by the senior manager or the individual developer.

10|P a g e


Weekly developer based tests are performed on the current repository and any
defects uncovered are put for immediate resolution with highest priority to ensure
high quality of release repository. Some degree of non-functional testing (like
stress test, reliability etc) will also be done by the developers to fix any issues at
its infancy. Subversion (http://subversion.tigris.org/) version control pattern (SVN)
based on Activity Based Branching (ABB) is used where all development work is
performed on a branch that is running in parallel to the repository. This allows a
developer to focus on the task at hand without having to worry about any
significant merging issues in the future. This allows the repository (trunk) to be
always of release quality. All aspects of the project management are done using
the cloud based management software provided by Nucleus Group
(http://www.unleashpm.com), an enterprise workflow and project management
tool which has several in-built tools for effective online collaboration with various
in-built communication tools and project enterprise forms effective in both
traditional and agile settings.

5.3 Experiments:

In order to quantify the benefits gained from the hybrid development approach, a
few projects metrics were analyzed. Unfortunately, due to the early nature of the
process this is not a perfect set of metrics to evaluate, but nevertheless is a good
indicator of the effectiveness of the hybrid approach. To compare the
effectiveness of the new approach, three project results are analyzed and the
same metrics are collected. One project is completely developed following the
traditional approach, while one has been developed using a completely hybrid
approach and another one started off with a traditional approach but was
transitioned to the hybrid approach (roughly towards the midpoint of its execution
timeline). Also, it should be noted that these projects based on PHP
programming language are all of varying size and difficulty level but, but still
serve as a good study to compare the effectiveness of various approaches.

5.3.1 Metrics:

Static analysis techniques analyze either the source or compiled binaries of a
project and attempts to collect metrics. It is performed on the code itself and not
on the executing program. Static analyses vary in complexity, depending on the
metrics to be calculated (Fenton, 1997). Many different metrics and a range of
tools are available for analyzing the quality of code generated by the team.
Different metrics have their associated pros and cons and are designed to detect
certain types of issues, so a variety of metrics (figure-4) will be measured based
on tools developed by PHP_Depend (http://pdepend.org) and PHP code sniffer
(http://pear.php.net/package/PHP_CodeSniffer/redirected). These are described
in figure-4 below.

11|P a g e


Metric Detailed Explanation
ANDC Average Number of Derived Classes The Average of direct subclasses of a class
AHH The average of the maximum lenght from a root class to ist deepest subclass subclass
NOP Number of Packages
NOC Number Of Classes
NOM Number Of Methods
Lines of code. Indicates the generic size and complexity of the project. Particulary useful when
LOC
used with other metrics like the bug count etc.
Cyclomatic Complexity Number is a measure of the number of independent paths of
CYCLO execution through source code. A high CC indicates that a software module is
difficult to maintain and test.
NOM Number Of Methods
CALLS Number of Method or Function Calls
FANOUT Number of Fanouts Referenced Classes

Figure 4: Metrics for project evaluation

5.3.2 Projects:

For comparison of the hybrid approach and its impact on the final output, three
projects currently active (or recently completed) and have been managed using
the project management tool, “Unleash” (http://www.unleashpm.com) have been
selected and subjected to the same analysis. These three projects will be
referenced by code-names and are described next:

• Project-A: This is a project that has been running for the past one
and a half year. The first eight months of the project was done using
traditional methodologies with rigorous effort on documentation, and the
later part was done by addition of agile methodologies to the
implementation approach and has now completed user acceptance
testing.

• Project-B: Project B has been under active development for the past
8 months. It is developed completely using the above hybrid approach
and has been delivered to the customer without any issues or the need
for any additional work.

• Project-C: This is a completed project (On October 2010) which has
taken about 10 months of development time. This was developed
completely using traditional methodologies and has been delivered to the
customer without any issues.

12|P a g e


These projects were chosen primarily to represent a good cross-sample of
projects and also due to the fact that much larger projects completed based on
this methodology were not available at the time of compilation of this manuscript
(some of these will be the objects of study in future work as explained later in
section-4 of this article). A simple methodology for collecting results from each of
the projects was followed. The source code is checked out of Subversion,
compiled, and the results from PHP_Depend and PHP_Codesniffer are
gathered. These results are then processed into a single large metrics sample for
each project, and analysis of the metrics is performed on them.

5.4 Results:

The first analysis to be performed for each of the projects is a comparison of
LOC (Lines of executable code) to the number of errors (deviations from the
coding standards) and the sum of errors, violations and any sniff violations. As
errors are primary indicator of programming mistakes, we felt comparing the
errors to LOC are the best predictor of defects. These results are indicated in
Figures-5, 6 shown below. For the sake of comparison, the error rates for the
well known open source code wordpress (http://wordpress.org/download/) are
included in the analysis.

Figure 5: Static analysis results from PHP_Codesniffer

Errors Warnings Sniff Violations LOC LOC/Errors LOC/Total Violations
Project-A 8517 622 9139 13886 1.63 0.76
Project-B 3057 1037 4094 5454 1.78 0.67
Project-C 8431 472 8903 6680 0.79 0.38
Wordpress 34300 3475 38200 93183 2.72 1.23

Figure 6: Error rates per Lines of code (LOC)

13|P a g e


When moving to a development methodology that focuses on tasks rather than
development, a prime concern is the team's productivity. For this end, we have
compared the lines of code against the average man months and are
summarized in Figure-7. It can be seen that the error rates are significantly lower
for the hybrid methodology (Projects- A, B) in comparison to the traditional
approach (Project-C) providing significant benefits in terms of reduced rework
and associated costs.

Average Approximate
LOC LOC/(Team Size x Months)
Team Size months

Project-A 13886 5 19 146.17
Project-B 5454 6 9 101.00
Project-C 6680 3 10 222.67

Figure 7: Productivity aspect of development approach

Figure-7 shows a significantly higher productivity rate for project C (based on
traditional approach) than projects using the hybrid approach. This is not
completely unreasonable and coupled with Figure-6 indicates that traditional
approach is more productive, but of lower quality source code and is in line with
the standard production triangle of time, budget, and quality.

5.4.1 Human Factors:

One of the challenges to overcome when implementing new hybrid approach is
to train the team to be disciplined with respect to the timelines. Some members
had a feeling that one week was a very short time and was unfair as the tasks
could require longer time. This was overcome by providing significant flexibility to
break down a task into sub-tasks till the team felt comfortable with the size. While
usually selection of people is a challenge for any new approach, this was made
easier by the eagerness of the team to try a new approach.

6 Future Work:

The above work has shown the utility of adopting a hybrid approach over
traditional methods. Further work is needed to expand and confirm these benefits
to larger projects and among a larger sample of projects. Notable, among these
ideas which would be of benefit to the software development community would
be

14|P a g e


• Actual verification of the approach at a much larger scale (of 100 or
more team size).

• A more quantitative comparison of the approach with a completely
agile based approach.

• Cost benefits trade off analysis of the better quality source code as
against the dip in productivity due to adoption of the hybrid approach.

7 Conclusions:

Before performing the above studies, authors had a strong belief that a hybrid
approach would be a better model in comparison to the traditional development
approach followed. While a weakness in terms of lower productivity exists
partially it could be ascribed to the relative familiarity of traditional approaches to
the team, and it is also our belief that as organizations mature with the
application of hybrid approach productivity would be increased. The in-depth
code reviews done frequently was one of the prime reasons for the
improvements reported here. Another crucial noteworthy aspect is that the
benefits are substantial even when the method was adopted after the beginning
of the project, as seen by the results for Project-A. The method proposed here
provides substantially reduced rework and increases software development
effectiveness, in addition to being applicable to already existing development
approaches. This is of huge significance to larger projects looking to adopt Agile
techniques without too much risk in the Agile adoption process.

8 Authors’ Profiles

Dr. Srinivas Telukunta1: Currently works as Director for Business
Systems at Nucleus Group. He is a lead consultant and corporate project
management trainer for Nucleus Consulting. He holds a B-Tech from the
Indian Institute of Technology, Madras (IIT Madras), an MS and a PhD
from the Cornell University of Ithaca, NY. He also holds an MBA from the
Indian School of Business (ISB, Hyderabad) and is the chief architect for

1
Corresponding Author. Email: st245@cornell.edu, Tel/Fax: 91-40-40030324, Address: Nucleus Group, 201
KVR Enclave, Ameerpet, Hyderabad, AP, 500016, India.
15|P a g e


“Unleash”, flag ship product of Nucleus Software Technologies for enterprise
project management.

Mr. Raghu Kumar Katakam: Currently works as Director for Information
Technology at Nucleus Group. He has deep experience in developing
applications across various verticals and has successfully executed many
projects and is the chief developer for “Unleash”, flag ship product of
Nucleus Software Technologies for enterprise project management.
Raghu holds a Bachelor’s from Jawaharlal Nehru Technological
University (JNTU) in Information Technology and a Master’s from
International Institute of Information Technology (IIIT), Hyderabad in
Information Technology. He is currently pursuing an Executive MBA from
IIM Lucknow (Noida Campus).

Mr. G. Swamy Naidu: Currently works as Head of Product Development
for Information Technology at Nucleus Group. He is an accomplished and
expert solutions-oriented leader for a range of corporate IT initiatives to
drive efficiencies. He is the lead developer for “Unleash”, flag ship
product of Nucleus Software Technologies for enterprise project
management. Swamy holds a Bachelor’s from Jawaharlal Nehru
Technological University (JNTU) in Information Technology, Hyderabad in
Information Technology and presented various research papers.

16|P a g e


Mr. Srinivasu Nimmakayala: Currently works as Product Lead at Nucleus
Group. More than two years of experience in software product design,
development specialized in Project management, ERP Domains. He has
played an active role in taking initiatives and in this course he led
development of three products from concept to launch and involved in all
phases of product development. Prior to joining Nucleus, Srinivasu holds
a Bachelor’s degree from Jawaharlal Nehru Technological University
(JNTU) in Information Technology.

9 References

Ambler, S. (2006). Examining the Agile Cost of Change Curve (Available Online).
http://www.agilemodeling.com/assays/ExaminingtheAgileCostofChangeCurve.ht
m

Barry, B. a. (August 15, 2003). Balancing Agility and Discipline: A Guide for the
Perplexed,. Addison Wesley.

Beck, K. (1999a). Embracing change with Extreme Programming. IEEE
Computers , 70-77.

Cohn, M. (Nov 11, 2005). Agile estimating and planning. Prentice Hall
Professional Technical Reference.

Degrace, P. &. (1990). Wicked Problems, Righteous Solutions. Englewood :
Yourdon Press.

Fenton, N. P. (1997). Software Metrics. Boston: PWS Publishing.

Fowler, M. (n.d.). Retrieved July 10, 2011, from
http://martinfowler.com/articles/newMethodology.html

Fowler, M. (2005). The New Methodology (2005). Available Online ,
www.martinfowler.com/articles/newmethodology.html .

17|P a g e


Grenning, J. (2009 (18)). Launching XP at a process-intensive company. IEEE
Software , 3-9.

M. Kamel, I. B.-R. (2010). Planned Methodologies vs. Agile Methodologies under
the Pressure of Dynamic Market. KAU: Eng. Sci., Vol. 21, No-1 , 19-35.

Nagappan, A. B. ( MSR-TR-2007-09, no. (2007): 10). Usage and Perceptions of
Agile Software Development in an Industrial Context: An Exploratory Study.
MiIEEE Computer Society .

NandhaKumar J, A. J. (1999). The fiction of methodological development: A field
study of information systems development. Information Technology and People ,
176-191.

Roger, S. (2005). Software Engineering a Practitioner's Approach. McGrow-Hill
International Edition.

Sommerville. (2006). Software engineering, 8th ed. New York: Addison-Wesley,
Harlow, England.

Truex, D. B. (2000). A methodical systems development: The deferred meaning
of systems development methods. Accounting, Management and Information
Technology (10) , 53-79.

Unleash. (n.d.). Unleash Project Management. Retrieved July 06, 2011, from
Unleash: Active Management System: www.unleashPM.com

W.Royce. (1970). Managing the Development of Large Software Systems. Los
Angeles: IEEE WESTCON.

www.unleashpm.com. (n.d.).

18|P a g e

ETPM5

More Related Content

What's hot

Viewers also liked

Similar to ETPM5

More from PMI2011

Recently uploaded

ETPM5