A Knowledge Management Framework for Agile Software Development Teams

Abstract

Software development is a knowledge-intensive activity and its success depends heavily on the developers' knowledge and experience. Knowledge is considered as the main competitive asset of the organization. One of the objectives of knowledge management (KM) is to improve productivity by effective knowledge sharing and transfer. Agile software development has put a new focus on the question of how to share knowledge among members of software development teams. In contrast to heavy-weight, document-centric approaches, agile approaches rely on face-to-face communication for knowledge transfer. Pair programming is one such practice with the idea to share the work specific knowledge across the development teams through pair rotation. This paper introduces work on developing a framework for capturing the tacit knowledge shared among the practitioners of agile software development methodologies. This approach facilitates the organizational learning process by capturing and maintaining the necessary knowledge.

Full text

A Knowledge Management Framework for Agile Software Development
Teams
R.K. Kavitha
Assistant Professor, Department of Computer Applications
Kumaraguru College of Technology, Coimbatore, India
rk_kavitha@ymail.com
M.S. Irfan Ahmed
Professor & Head, Center for Computer Applications
VLB College of Engineering and Technology, Coimbatore, India
msirfan@gmail.com
Abstract: Software development is a knowledge-intensive activity
and its success depends heavily on the developers’ knowledge
and experience. Knowledge is considered as the main competitive
asset of the organization. One of the objectives of knowledge
management (KM) is to improve productivity by effective
knowledge sharing and transfer. Agile software development has
put a new focus on the question of how to share knowledge
among members of software development teams. In contrast to
heavy-weight, document-centric approaches, agile approaches
rely on face-to-face communication for knowledge transfer. Pair
programming is one such practice with the idea to share the
work specific knowledge across the development teams through
pair rotation. This paper introduces work on developing a
framework for capturing the tacit knowledge shared among the
practitioners of agile software development methodologies. This
approach facilitates the organizational learning process by
capturing and maintaining the necessary knowledge.
Keywords: Knowledge Management (KM), Pair Programming,
Agile Software Development
I. INTRODUCTION
Knowledge Management has been the subject of increasing
focus over the last several years. Literature and research on
the topic has grown as companies and organizations have
come to realize that success is often determined by one’s
ability to create, disseminate, and embody knowledge in
products and services. This realization has led to increased
interest in examining the ways in which knowledge can be
effectively created, identified, codified, disseminated, and
retained. The field of Knowledge Management has emerged to
address this need. There are several knowledge frameworks
that describe knowledge-related practices. The organizational
knowledge is embedded in people, systems, procedures and
products. Knowledge workers are required to improve their
work on a daily basis in a process that cumulates into a
significant improvement in performance for the entire
enterprise.
Software knowledge is stored in documents, process,
practices, technologies, and project artifacts. Software’s
developed using traditional methods are well documented
whereas agile methods support working software rather
comprehensive documentation. In traditional software
development methodologies, the knowledge is explicit and
can be easily captured whereas the agile methodology deals
with tacit knowledge. Tacit knowledge is stored in the minds
of people in the form of memory, skills, experience,
education, imagination and creativity [15]. One of the greatest
challenges of knowledge organizations is to extract tacit
knowledge possessed by their knowledge employees, so as to
apply the right knowledge at the right place when needed and
to encourage innovation.
Fig1. Software Knowledge
Agile software methodologies have some inbuilt practices that
facilitate the transmission of experiences and knowledge
inside the organization. Pair programming is such a practice
that holds promise for overcoming some of the challenges
faced by Knowledge Management [12]. In pair programming,
978-1-61284-764-1/11/$26.00 ©2011 IEEE

two programmers work side-by-side at one computer
collaborating on the same design, algorithm, code, or test. The
continual interaction between pair programmers would seem
to provide an environment that promotes knowledge sharing
and collaborative knowledge discovery. Additionally, through
pair rotation, in which pairs change partners fairly often, tacit
knowledge might be spread more effectively through face-to-
face communication than by documentation, databases, or
other means.
The practice of Pair Programming helps to mange knowledge
to a good extent. Even, other ways of exploring tacit
knowledge needs to be considered. In this paper we propose a
framework for managing the knowledge generated by agile
software developers.
II. WORKING OF KM
Knowledge Management is the collection of processes that
govern the creation, dissemination, and utilization of
knowledge. It is a range of practices used in an organization to
collect and share knowledge to help people get their job done.
For the learnings to be retrieved and reused, they need to be
qualified and codified so that they are accessible and
searchable. Furthermore, knowledge management can also
include strategies to foster a culture of information sharing
and the implementation of tools that make it easier for
employees to share their learnings and, in turn, to learn from
each other.
Knowledge repository is a database that organizes and makes
available to all employees, the basic information about the
products, services, customers, and business processes of the
organization. The repository serves as a
• Directory of knowledge sources that can be used by
employees to locate specific knowledge when needed
• Directory of learning sources that can be used by employees
to find out where they may learn new knowledge and skills
• Groupware that facilitates communication and collaboration
among employees
It is found that nearly 40% of organizational knowledge is
stored in employees' heads. This knowledge will be useful in
many ways to the organization and supports reusability,
learning, decision making etc. It is lost when people move to
newer roles, or leaves the organization.
KM requires effective colloboration among the members of
the team. For an organization to do knowledge management
more effectively, one way is to leverage the Communities of
Practice (CoPs) within its organization. Communities of
practice are groups of people who are informally bound to one
another by exposure to a common class of problems. These
groups share their learnings and knowledge resources
continuously and informally amongst each other for mutual
benefit [13]. These CoPs are perfectly positioned to support
knowledge management efforts. They are continuously
capturing and sharing relevant knowledge with each other.
III. KNOWLEDGE MANAGEMENT CHALLENGES IN
AGILE SOFTWARE DEVELOPMENT
The absence of explicit documentation in agile software
development leads to a number of problems:
• Experts find themselves spending much time in
repeatedly answering the same questions
• Members find themselves in situations where they
know that they have had a certain problem before,
but cannot remember its solution
• Knowledge is lost as soon as experienced developers
leave the project or company
• Informal communication cannot serve as a record
• Less support for reusability
• Less contribution to organizational knowledge
The main challenges of KM in agile software development are
to transfer implicit knowledge to explicit knowledge, as well
as to transfer explicit knowledge from individuals to groups
within the organization [4]. The generated knowledge needs to
be stored in a repository. More commitment is needed from
the practitioner’s side in sharing knowledge. Another issue is
to know how far the stored knowledge is used.
Effective Knowledge Management through Pair
Programming
Pair programming consists of two programmers working side-
by-side at one computer, collaborating on the same design,
algorithm, code, or test. One programmer is the driver,
controlling the input device to produce the design or code.
The other programmer is the navigator, continuously and
actively examining the driver’s work. The navigator watches
for defects, thinks of alternatives, looks up resources,
considers strategic implications, and asks questions. Through
these activities, the navigator contributes by identifying
tactical and strategic deficiencies in the design or code.
Every so often, the driver and navigator switch roles. This
allows the programmers to vary their work routine, learn and
practice new skills, and contribute to the work in more than
one manner. There is no set rule as to how often the
programmers should switch roles. It should occur at a natural
transition point in the design or coding activity. Sometimes
this may be after only one or two hours, or sometimes it may

be after days. In organizations where there is more than one
pair, pairs often rotate partners after the completion of a task
or subtask. Pair rotation allows the programmers to learn
different areas of the system, and learn from the skills of
different partners.
The pair programming approach lends itself to several
potential benefits. By being under the scrutiny of two
programmers at all times, the design and code is under
continuous review, potentially leading to higher defect-
removal rates [1]. The combined strengths of two
programmers can potentially enable them to solve difficult
problems more quickly than if they had worked alone. By
pairing, programmers can learn skills from each other and
communicate more closely. And, exposing multiple
programmers to each piece of code potentially reduces the
impact of losing staff.
Developers tend not to document task-related knowledge,
contextual knowledge, and social resources generated through
pair programming for many reasons, such as being
overburdened with other tasks or they may think that the
knowledge may be irrelevant or of no interest to others [9]. To
ensure knowledge shared among a pair is accessible to the
entire team, XP recommends pairs be rotated from time to
time which may not be very effective always. Even though
Pair Programming is an excellent knowledge management
strategy by itself, it would be beneficial to have some means
to capture and store such knowledge.
The following research questions are outlined from the issues
discussed above.
1. How knowledge management is achieved in agile
software development with least documentation?
2. To which extent agile practices like pair
programming contributes to KM effectively?
3. How to capture the tacit knowledge generated during
informal communication?
IV. RELATED WORK
Several frameworks exist for managing software knowledge
generated especially while using traditional methodologies. A
framework for KM Support suggests two important
considerations in managing knowledge [19]
• Where the knowledge resides and
• The extent to how the knowledge is structured.
A KMS architecture has been proposed consisting of seven
layers, which are interface, access, collaborative, application,
transport, integration and repositories [20]. A Soft-System
Knowledge Management approach for KM system
development was proposed to ensure a fit between the
organizational needs on new product development (NPD) and
KM initiatives [5]. This framework consists of three main
components:
Knowledge sharing methods, Organizational level and Key
Enablers
A KMSOS2oD Framework is formulated especially to support
software development life cycle for Open Source Systems and
consists of five main components: layers, components,
process, knowledge, and CoP [2].
Researchers have proposed several tools to better support
collocated and distributed agile software development. The
tools are mainly intended for application sharing. For
communication and collaboration among team members, tools
like e-mail, newsgroups, and instant messengers are used.
Real-time collaboration tools like audio/video conferencing
and application sharing facilitate the informal and
spontaneous social interactions necessary for sharing tacit
knowledge [3]. Wiki technology enables any users to access,
create, organize, and update any web pages in real-time using
only a web browser. This technology supports asynchronous
collaboration and it only allows users to capture information
in an unstructured format like text and graphics. Several
plugins like JSPWiki and MASE provides a process support
environment tailored for agile development teams [6]. MILOS
can provide each developer with a basic to-do list application;
Jazz Sangam is ex-tended from Sangam, an Eclipse plug-in
for distributed pair programming. It helps the pair
programmers to code effectively and has features like defect
tracking, instant chat etc.
Several studies were carried out in industries and academics to
study the impact of Pair programming on factors like
productivity, quality of software, team work, enhanced
learning etc. Only less research considering pair programming
as knowledge management factor has been carried out.
From the existing studies we come to understand that there
exist some tools and techniques for managing software
knowledge. So far no specific framework that integrates tools
and methods for addressing the tacit knowledge generated
during agile software development has been suggested.
V. PROPOSED FRAMEWORK FOR CAPTURING
TACIT KNOWLEDGE
Needs and benefits of capturing knowledge:

• Knowledge captured from informal communication
can contribute to organizational knowledge
• Experiences/ knowledge about a work can be made
known to other members of the project team
whenever needed
• Stored knowledge supports reusability
• Members will be committed and recognized
This paper introduces work on developing a framework for
capturing and distribution of knowledge generated while using
agile software development methodologies in which the team
members may either be collocated or distributed. The
approach facilitates an incremental organizational learning
process to capture and maintain knowledge on what
documentation/information is actually needed. The framework
describes a suite of integrated tools that provides support for
capturing, storing and disseminating knowledge
Real-time collaboration tools like emails, news groups,
NetMeeting facilitate the social interaction necessary for
sharing tacit knowledge.
Fig.2 Tacit Knowledge Enablers
The proposed framework enables informal knowledge
sharing. The members work usually in a collaborative
environment connected by internet / intranet. The framework
provides the developers with a set of tools that helps in
collecting the knowledge. Experiences generated related to
coding, debugging, logic, practices, facts, proof of a concept
etc are entered via an interface by the member and is collected
in the experience recorder. The idea map helps to store
unstructured information related to the project like work
notes, to do list etc. Information can also be posted on a
discussion forum. The information collected by the experience
recorder, idea map and forums can be structured and stored in
the knowledge repository.
The knowledge generated during software development will
be of use to all the project stakeholders. Storing information
does not guarantee that others can find it. The members
should be able to successfully retrieve the information from a
repository that combines structured and unstructured data.
Efficient query mechanisms can be helpful in easy retrieval of
required data.
Fig.3 Proposed Framework for capturing tacit knowledge
during agile software development
VI. CONCLUSION AND SCOPE FOR FURTHER
WORK
This paper is based on the assumption that KM is a vital part
of software projects. Specifically, our work aims to examine
the integration of KM and agile software development which
helps to overcome the existing difficulties when introduced
and applied. The pairing of KM and agile software
development has been acknowledged by various researchers.
In this paper we have presented a framework to capture the
tacit knowledge generated while adopting agile software
development methodologies. The framework shall provide
support for agile practices and overcome the challenges in
organizational knowledge sharing. Immediate future work is
to study how pair programming contributes to KM in practice
and to implement and evaluate the suggested framework. A
further study of the various knowledge management metrics
for agile software development teams will be conducted to
understand how far the stored knowledge will be useful to the
developers and the organization.
REFERENCES
[1] V.Venkatesan, A.Sankar, “Adoption of Pair Programming in the
Academic Environment with Different Degree of Complexit y in Students
Perspective– An Empirical Study”, International Journal of Engineering
Science and Technology, Vol. 2(9), 2010, 4791-4800

[2] Modi Lakulu, “A Framework of Collaborative Knowledge Management
System in Open Source Software Development Environment” Journal of
computer and Information Science, Vol.3, No.1, Feb 2010, pp.81-90
[3] Filipe Figueiredo Correia, Ademar Aguiar, “. Software Knowledge
Capture and Acquisition: Tool Support for Agile Settings”, IEEE Computer,
2009
[4] Meira Levy, Orit Hazzan, “Knowledge Management in Practice:The Case
of Agile Software Development”, IEEE software, 2009, pp. 60-65
[5] Shankar, R., Acharia, S., & Baveja, A. ‘‘Soft-system Knowledge
Management Framework for New Product Development’’, Journal of
Knowledge Management, 2009, 13(1) , pp.135-153.
[6] Till Sch¨ummer, Stephan Lukosch, “Understanding Tools and Practices
for Distributed Pair Programming”, Journal of Universal Computer Science,
vol. 15, no. 16, 2009
[7] Jari Vanhanen, Harri Korpi, “Experiences of Using Pair Programming in
an Agile Project”, IEEE Computer, 2007
[8] Vanhanen, J., and Lassenius, C. 2007. “Perceived Effects of Pair
Programming in an Industrial Context,” 33rd EUROMICRO Conference on
Software Engineering and Advanced Applications, 28-31 Aug. 2007, pp 211-
218.
[9] Thomas Chau, Frank Maurer, “Integrated Process Support and
Lightweight Knowledge Sharing for Agile Software Organizations”, 2005
[10] Claudia Müller, Julian Bahrs, Norbert Gronau, “Considering the
Knowledge Factor in Agile Software Development”, Journal of Universal
Knowledge Management, vol. 0, no. 2 (2005), pp.128-147
[11] Jari Vanhanen and Casper Lassenius, “Effects of Pair Programming at
the Development Team Level: An Experiment”, IEEE, 2005
[12] Mustafa Ally, Fiona Darroch, and Mark Toleman, “A Framework for
Understanding the Factors Influencing Pair Programming Success”, XP 2005,
Sheffield, UK, pp.18–23
[13] Thomas Chau, Frank Maurer, “Knowledge Sharing in Agile Software
Teams”, 2004
[14] Harald Holz and Frank Maurer, “Knowledge Management Support for
Distributed Agile Software Processes”, 2003
[15] David Walsh Palmieri, “Knowledge Management through Pair
Programming”, Thesis
[16] Gerardo Canfora, Aniello Cimitile, Corrado Aaron Visaggio, “Lessons
learned about distributed pair programming: what are the knowledge needs to
address?” IEEE Software, 2003
[17] Williams, L., and Kessler, R. 2000. “All I really need to know about pair
programming I learned in kindergarten,” Communications of the ACM (43:5)
pp 108-114.
[18] Williams, L., Kessler, R., Cunningham, L., and Jeffries, R. 2000.
“Strengthening the case for pair programming,” IEEE Software, July/August
2000, pp 19-25
[19] Hahn, J., & Subramani, M. ‘‘A Framework of Knowledge Management
System: Issues and Challenges For Theory and Practice’’, Proceedings of the
twenty first international conference on Information systems, ACM, Brisbane,
2000
[20] Tiwana, A, The Knowledge Management Toolkit: Orchestrating IT,
Strategy and Knowledge Platforms. USA:
Prentice Hall.