Simulating
Software Product Evolution
in the Classroom
May 3, 2001
The Western Canadian
Conference on
Computing Education (WCCCE)
By
Kal Toth
Associate Professor
Technical University of British Columbia
Suite 301 - 10334 152A Street
Surrey, B.C. Canada, V3R 7P8
T: (604) 586-5286; F: (604) 586-5237
Abstract
One of the main challenges for software engineering and information
technology instructors is to provide learners with a real-world environment for
developing software products and systems.
Learners are often given toy problems to solve and rarely work on
projects that involve integrating software components in a team or project
setting. This paper describes an
innovative approach introduced by the author to provide learners with an
environment that closely simulates an ongoing industrial software product
development process.
The learning approach described in this paper is being implemented and
evaluated for the first time in a second level software engineering course at
the Technical University of British Columbia (TechBC). It is based on the Personal Software Process
(PSP) developed by the Software Engineering Institute (SEI) and documented in
[1]. The author has developed a PSP
Support Tool (“Zelda”) which supports the PSP approach providing learners with
a loosely integrated set of capabilities supporting planning, estimating, time
management, bug tracking, process management and software reuse activities.
The innovative aspect of this new method of teaching is that the IT
learners become intimately involved in the ongoing evolution of the PSP support
tool. Learner assignments are
explicitly geared to enhance the PSP tool itself. New assignments further enhancing the tool will be allocated to
future cohorts of learners thereby simulating a continuous software evolution
process in the class.
Subject Areas: Software Engineering; Personal Software
Process (PSP); Team Software Process (TSP); Project Support Environments, Software
Tools
Academic
Department: Information
Technology
In more recent years, computer science and information technology (IT) programs have begun to prepare learners with both theoretic and applied knowledge and skills prior to entering the workforce. The term “software engineering” (SE) is often used when referring to the industrial practice of applying computers and software to solve, automate and support business and operational problems.
Current academic programs often assign toy problems that provide insight into fundamentals, theories and structures, but they offer a limited degree of skills development or applied problem solving. To develop applied knowledge, the challenge has been provide IT and SE students with practical project experience in systematic and continuous evolution of software and to achieve this in a project-oriented working environment.
The goal of this paper and the learning
approach described herein is to provide an integrated project support
environment in the classroom that closely simulates industry practice. This environment is targeted at facilitating
the full development lifecycle including planning, estimating, time management,
bug tracking, requirements management, and process management. A related goal is to integrate
industry-oriented process thinking and process improvement into the IT
curriculum. Because industry practice
includes collecting data / metrics about the software process to systematically
improve processes, research data will become available to study the efficacy of
the proposed approach.
The author has long-time industry experience
in the development of software-intensive systems and in recent years has
developed and delivered several SE and IT courses at the graduate and
undergraduate levels. Of particular
relevance has been his experience with the “Personal Software Process” (PSP)
developed by the Software Engineering Institute (SEI) and Watts Humphrey
[1]. The author currently conducts a
second level (“Tech2”) Software Engineering course at the Technical University
of British Columbia (TechBC) which is based on the PSP and also calls on
material from Humphrey’s Team Software Process (TSP) [2].
The PSP introduces the learner to software
engineering practices, process thinking and metrics. The learner begins with their baseline process and is
incrementally introduced to software sizing, estimating, planning, time tracking,
bug/defect tracking, performance and quality metrics, and process
improvement. The course provides
several lab assignments, some of them related to the estimating and reuse
techniques advocated by the PSP, that provide the learner with an opportunity
to practice the newly introduced SE practices just-in-time.
The PSP is also the foundation material for
SEI and Humphrey’s Team Software Process (TSP) [2]. The TSP extends the processes at the personal level to software
processes carried out by development teams.
One shortcoming of the PSP as presented in
[1] is that it relies on paper-based forms.
Getting buy-in to complete these forms can be a challenge and they do
not lend themselves readily to automated feedback and project control. Industry practice typically involves
adopting integrated project support environments to capture, control, aggregate
and analyze data for the project. To
address these shortcomings, the author developed an automated PSP support tool
(now called “Zelda”) to support the lab exercises.
This tool is implemented in MS Access, runs
as a stand-alone tools on a PC client, and provides several sub-tools
(“widgets”) as follows:
Project Data |
Effort / Time Logging |
Requirements Specs |
Bug / Defects Tracking |
Process Scripts |
Size and Effort Estimating |
Productivity Database |
Planning / Scheduling |
Maintenance Functions |
Reports / Listings |
This support environment has been evolved over time by the author and has increasingly automated many of the previously manual processes and methods of the PSP. Zelda will also be applicable at the team level (per the TSP), however, groupware enhancements need to be made to support development and integration across a project team.
Although the PSP assignment outputs are
working programs related to the PSP processes, we are not aware of any
attempting to integrate or reuse these outputs.
The approach advocated by the author was stimulated by the idea of feeding back learner output from programming assignments into the Tech2 Software Engineering course for subsequent offerings of the course. The objective of this learner-centered strategy was to both simulate industry practice and continuously improve the course itself.
The central idea to achieve this has been to
get the learners to both use Zelda (the PSP support tool) and participate
actively in the evolution of the Zelda to achieve increasingly enhanced
capabilities.
This process was just launched this winter
with the first offering of this course to second level learners. The ongoing plan of action to achieve the
desired results may be summarized as follows:
As the learners use Zelda, they are encouraged to not only post
improvements to their personal processes (as advocated by the PSP), but to also
propose changes / enhancements to the tool.
This achieves buy-in – shortcomings and bugs in Zelda will become
opportunities for improvement rather than opportunities for complaining.
Learners and the instructor will review the proposed changes
periodically and establish new assignments for subsequent offerings of the
course designed to improve Zelda.
Each year a new set of assignments will be posted. These new assignments are thereby driven by
the process and product improvements proposed by the previous cohort. The course also evolves dynamically and
incorporates emerging SE methods and tools as they become available over time.
Just-in-time product and process changes will also be encouraged –
assignments could possibly change mid-course.
As the course evolves, the instructor will evaluate the software
components resulting from the new assignments and lead the incorporation of the
enhancements into Zelda. The strategy
for conducting this re-integration effort has yet to be worked out, however, it
could potentially be incorporated into as a final group assignment in the
course or become an assignment for a third or 4rth level IT course at TechBC.
The author plans to put the software into the public domain via an open
source license so that other learners, institutions, and companies conducting
software development may benefit and/or contribute to the evolution of Zelda.
Some of the improvements that have already been contemplated include:
web-based development support using Java Applets to reduce dependency on
client side tools like MS Access
development of a central repository using MySQL or MS SQL Server to
capture project data
Enhanced requirements management including version control and
traceability
Support for software integration and test management
Improved data capture in the effort and defect tracking widgets
Non-linear regression and other improvements in the estimating tool
More generalized planning and scheduling
More direct support for work breakdown
Ability to drill down into processes (move towards a process enactment
capability).
There are a number of issues and follow-on
work that may be considered:
What would it involve to translate the metrics gathered in the class to
generalize them to industrial applications?
What mechanisms might be employed to encourage learners to participate in the growth and value of the product in an academic environment?
Might it be possible to have the students share in the proceeds of the
public domain tool?
The proposed
approach is expected to quite closely simulate an industrial approach to
software engineering and process thinking thereby providing the learners with hands-on
practical project experience in the evolutionary development of software
intensive systems. Learners will
achieve an enhanced sense of accountability, teamwork, self-assessment, process
improvement and professionalism, and the course itself will continue to improve
over time. The proposed approach
potentially offers an industry-oriented test bed for gathering and analyzing
various software processes that could lead to potential new approaches for
undertaking and optimizing software engineering in the field. Finally, a
practical and useful open source tool will be made available and continuously
enhanced for application in both academic and industry settings.
1.
Humphrey, W. (1995). A Discipline for Software
Engineering, Addison Wesley
2.
Humphrey, Watts S. (1999). Introduction to the Team Software Process, Addison Wesley
Kal has a Ph.D. in Computer Systems Engineering from
Carleton University and has a software engineering designation with the
professional engineering association in BC. He is both a faculty member at
TechBC and a principal and cofounder of The Wise Net Inc. He
has long-time industry experience in the development of software-intensive
systems and has also developed and delivered several SE and IT courses in
recent years at the graduate and undergraduate levels at TechBC, UBC, SFU and
the Software Productivity Centre (SPC).
Kal has been a senior
executive with several large, medium and small sized technology companies and
organizations including Hughes Aircraft, Datalink Systems Inc., the CGI Group
and Intellitech Canada Limited.