Using Software Development Cycle to Integrate Software Engineering

Document Sample
Using Software Development Cycle to Integrate Software Engineering Powered By Docstoc
					 Using Software Development Cycle to Integrate Software
  Engineering Principles throughout the Undergraduate
             Computer Science Curriculum
                    Rochelle Elva                                              Dr. David Workman
            Department of Computer Science                                 Department of Computer Science
             University of Central Florida                                  University of Central Florida
                Orlando, Florida, USA                                          Orlando, Florida, USA


                                                                 Upon graduation about 30% of CS students are employed
Abstract – Upon graduation about 30% of Computer
                                                                 in jobs requiring SE skills [6]. For a long time leaders in
Science (CS) students are employed in jobs requiring
                                                                 industry have complained of the gap which exists between
software engineering (SE) skills [6]. For a long time
                                                                 the practical skills required of software engineers and
leaders in industry have complained of the gap which
                                                                 competencies of graduating students. One possible reason
exists between the practical skills required of software
                                                                 for this is the absence of focus on SE in most
engineers and competencies of graduating students. This
                                                                 undergraduate CS programs. Currently in many CS
paper suggests that software engineering principles and
                                                                 curricula, SE is offered as a single elective course for
practice, be integrated throughout the undergraduate CS
                                                                 seniors or students who have already had a few years of
curriculum. It proposes that software concepts be
                                                                 programming experience. A course in quality is even more
introduced from the very first programming course so that
                                                                 rare; and often when it is offered, the practice of quality is
good software habits can be instilled early and become
                                                                 limited to testing and debugging. CS and SE have been
second nature to students. In addition, it teaches them to
                                                                 treated as separate disciplines rather than a discipline
value quality from the onset, while also establishing an
                                                                 within the other. As a result, graduates lack experience in
appreciation of both the end product, and the entire
                                                                 the practice of good software development habits and
process employed to create the software. Thus by
                                                                 genuine quality assurance.
graduation, CS students would have had enough
experience and training to produce software of high
                                                                 In this paper SE is treated as a discipline to be integrated
quality and competently take their place in the prominent
                                                                 with CS to increase the quality of the software engineer’s
software industry.
                                                                 personal software development process and hence the
Keywords: CS-SE integration, assessment methodology,             product. The thesis of this paper is that SE principles
personal software process, curriculum improvement.               should be introduced from the onset of CS education and
                                                                 continued throughout the curriculum, through integration
                                                                 into existing undergraduate courses. This is to ensure that
1    Introduction                                                students develop good programming and design habits
                                                                 from the beginning of their college education.
      Over the past few decades, SE has risen in                 Consequently, good software practice will become second
prominence as computing technology has entered and               nature. To this end, a CS Curriculum needs to combine the
dominated every facet of modern life. This status while it       development of technical SE skills with general CS
has translated into high salaries for software engineers has     education.
also placed these individuals and their work beneath the
spotlight so to speak. In the last decade the mirror of          The importance of technical skill development adopted in
scrutiny has reflected many moments of triumphs.                 this paper has been addressed by accreditation agencies like
Unfortunately though, it has also reflected moments of           the Accreditation Board for Engineering and Technology
shame due to failed and faulty software which has caused         (ABET) [3] and the Computing Accreditation Commission
financial disaster and at times even loss of life. As a result   (CAC). In its 2006-2007 cycle ABET/CAC has identified
of this, many companies have resorted to adopting a              program outcomes, assessment & evaluation and
philosophy of total quality, in an effort to guarantee           curriculum as its third, fourth and fifth criteria for
consistent delivery of high quality products free of defects.    accreditation respectively [3]. ABET’s prerequisites with
Currently businesses are spending as much as 50% of their        regard to curriculum outlines that CS programs should
budget on quality [6]. Yet, even the best organizational         satisfy both technical and professional requirements in
efforts do not guarantee success. It is also imperative that     order to prepare students for their professional careers. To
individual software developers examine and improve their         fulfill the assessment and evaluation requirement
personal software development process.                           institutions must ensure that evaluations are used to effect
continuous improvement;         In the description of                                               In each academic year students will be exposed to all
requirements re outcomes, it is stated clearly that for                                             phases of the development cycle. However, in successive
accreditation, institutions must provide students with                                              courses, the software practices employed will vary in focus
opportunities to:                                                                                   and complexity, to match the objectives of a particular
                                                                                                    course and student readiness. A greater and more direct
        -      analyze problems and identify the necessary                                          concentration on software principles will then be pursued
               computing requirements to arrive at a solution                                       in the undergraduate SE course/s. This approach presents
        -      design, implement and evaluate computer based                                        two major advantages. First, students would have learned
               systems                                                                              to program using good and efficient software practice from
        -      use modern tools, skills and techniques in their                                     the onset. As a result when they enter the pure SE class,
               computing practice                                                                   lecturers do not have to labour to correct deeply rooted bad
                                                                                                    software development styles. Secondly, integration of
In view of these ABET stipulations it becomes evident that                                          software engineering practices throughout the curriculum
training CS students in SE is not merely an option, but the                                         would make the fulfillment of the goals of the SE courses
responsibility of all CS educators. Thus, the principles of                                         more realistically attainable.
good software practice should be integrated throughout the
CS curriculum- not just in SE courses.                                                              Too often, SE courses fail to truly meet their objectives
                                                                                                    because in one semester, students are expected to learn
The integration process suggested is structured around four                                         good software practices and apply them successfully in the
major stages of the software development cycle as shown                                             implementation of a project. Any seasoned software
in Figure 1. The intention is not to simply present the                                             engineer can testify that it takes years of practice to
model in one course, but gradually, over time in every                                              develop an efficient personal software process rooted in
course in the curriculum. The four-phase software                                                   good practice. Consequently, independent of how well
development process will be developed in a spiral manner                                            these SE courses are planned and executed, they may not
as shown in Figure 2.                                                                               achieve the levels of success expected. The primary reason
                                                                                                    is that success relies on the retention of good software
Start
            Requirements Elicitation                                                                habits and this has to be fostered by opportunity for
                  & modeling
                                                                                                    repeated practice. Unfortunately, one semester is not
                                                                             Source Code
                                                                                                    enough time to guarantee either of these. However, if
                                                            Code &
 Software requirements
 specification                                             Unit Testing                             students arrive at this point of their education with at least
 Use Case Model
                                                                              Tested                two years of practicing good habits in software
                                                                          Sub-components
                                                                                                    development, then the goal of retention and permanent
                            Analysis Model
                            Software Development Plan                                               practice of good software development habits will be more
                                                                                   Component        readily realized.
                                                                                   Integration
                                                  Design Model                    & System Test

                                                                                                    To facilitate faculty in implementing the recommended
            Requirements Analysis
              & Software Design                                                                     teaching methodology, a tool will be provided to assist in
                                                                                 Working System     the assessment of assignments and evaluation of students’
                                                                                                    progress in developing good software development habits.
               Figure 1 Software Development Process                                                The proposed tool will allow faculty to select specific focus
                                                                                                    areas of the software development phases, to be used as
                                                                                                    criteria for grading each assignment. One of the outputs
                                                                                                    from the tool is a program profile. This provides feedback
                                                                            Requirements Analysis   on the quality of the submitted code in the four focus areas
 Requirements Elicitation                                                    & Software Design
       & modeling                                                                                   of the software development process. Another facility
                                                                                                    provided by the tool, is a data store of students’ progress in
                                                                                                    past assignments. This provides historical data which can
                                                                                                    be used to track students’ progress over time. Together
                                                                                                    these provide assessment support for the integration
                                                                                                    method.

                                                                                                    The rest of the paper will focus on: related research in the
       Integration                                                                 Coding
    & System Testing                                                            & Unit Testing      area of integration of SE into the CS curriculum; A
                                                                                                    description of a framework for the proposed integration; A
                                                                                                    suggested architecture for the assessment tool and a
                                                                                                    discussion of future plans for testing the proposed methods.
                                                                                                    The final section is a summary of the ideas presented.
        Figure 2 Spiral Model of Software Development
2    Related research                                           methodology which involved the integration of software
                                                                concepts across the curriculum for first year CS majors. To
     From the end of the 1980’s various attempts have           achieve this, they employed a program called Doing
been made in academia to improve the level of SE                Quality Work (DQW). Students in the participating courses
competence of the graduating CS student [2, 4, 9, 10, 12].      were taught the first half of the PSP model using
These efforts have ranged from creating degrees in SE as        Humphrey’s introductory text. Initially, students were
opposed to CS; adding SE and software quality assurance         required to engage in time management and estimation,
courses to the curriculum; making SE a part of the core         using a modified version of the PSP logs. The rest of PSP
undergraduate CS curriculum; introducing SE principles as       was then covered in the programming course of the next
a module in some CS courses and integrating components          semester. Students would then have the opportunity to
of software process models across the CS curricula for          develop and improve into a mature personal process over at
freshmen and sophomores.                                        least seven courses. A survey carried out nine weeks into
                                                                the experiment, revealed that students were resentful about
In 1989 Humphrey presented The Personal Software                the integration of software material into the CS courses
Process (PSP) as a model for continuous improvement of          because they perceived this as needless, extra work.
the individual software process of software developers. In
later experiments he showed that PSP offered the advantage      From the review of literature it is evident that while current
of improving planning by 25% and general reduction in           integration methods have offered a certain measure of
defects by as much as 5 times [9]. After conducting three       success, generally they are not achieving their goal. It is
case studies, Ferguson et al discovered that the use of PSP     our view that the fault does not lie in the concept of
can result in an improvement of up to 20% in productivity       integration; but rather in the strategies which have been
and five times in product quality [4].                          employed to date to accomplish it. Many of the cases cited
                                                                have sought to use PSP because of the impressive past
Boistler et al also experimented with teaching a modified       experimental results. However, two things have been
version of PSP in an introductory CS course at four             overlooked. First, the positive results of PSP have only
different universities -three in the U.S. and one in Sweden     been validated when the complete program is used.
[2]. The approach that they chose was to include PSP as a       Second, PSP presumes a certain software readiness on the
separate module within the course curriculum. They              part of participants. Most freshmen entering CS
focused on either of two levels of PSP - tracking of            undergraduate programs often have no programming
planning and scheduling, or tracking defects. In all cases      experience. The results of past experiments have also
students were presented with tools to aid in data collection    revealed that students oppose the idea of SE introduced to
and specific exercises were assigned to evaluate students’      their courses as an appendix.
progress with using the module. In the majority of
instances the results were disappointing. When given a          There is no silver bullet. No cookie cutter solution has been
choice, most students opted not to use the data gathering of    found to teach CS students to be first-class software
PSP or any of the suggested activities. At two of the           engineers. However, the necessary skills can be developed
schools students complained that the data collection process    throughout the curriculum as part of already established
was too labour intensive; even when they were using PSP-        courses. It is our view that the secret to the success of this,
lite (Humphrey’s introductory version), with its reduced        is the transparent integration of principles of good software
logging requirements. One school however recorded               development practice into CS courses.             Also these
success. The distinguishing feature at that site was that PSP   principles must be introduced in a timely manner - when
was not used as an appendum to the curriculum. Instead it       students are cognitively ready to receive them. The process
was integrated into exercises already scheduled for two         can then be supported by both faculty and technical tools.
courses and logs were kept at a minimum.                        Thus any CS-SE integration scheme should consider the
                                                                following three factors: the course environment, the extent
Another example of poor results with integrating PSP into       of coverage of software principles and the provision of the
the CS curriculum is cited by Lisack [10]. An experiment        necessary support for integration.
was conducted integrating PSP into two programming
courses - one for freshmen (CS1) and the other for
sophomores (CS2). The general feedback was negative and
the experiment deemed a failure due to student resistance.
The students evaluated the documentation process (which
                                                                3    A framework for integration
involved keeping three logs), as “frustratingly tedious” and          In this section we propose strategies for integrating
were very unhappy with the experience.                          SE practice in a seamless way throughout the CS
                                                                curriculum. Typically when SE exercises are included in
Embry Riddle University has also been experimenting with        CS courses, they are distinct from the regular course
the idea of integrating SE into the CS curriculum. Their        assignments rather than integrated into the regular scheme
work began in academic year 1995-1996 [12] using a              of assigned coursework. We propose that SE concepts be
introduced transparently from the first programming course      appreciation of requirements from both the customer’s and
to the very last. This means that the SE material should not    developer’s perspective. They also learn to model both the
be distinguishable from the regular course material but that    structural and dynamic view of software. These skills will
the requirements of programming assignments would have          be developed using:
some SE component. The aim is to achieve course goals,              -UML (Universal Modeling Language)
while cultivating good software habits.                             -Use Case analysis
                                                                          o system inputs/outputs
We view software design and quality as notions to be                      o system actors
addressed from the onset of teaching programming and                -Design focus areas
algorithm development. Too often though, these are treated                o architectural design
as an afterthought, if considered at all. Hence, normally                        modular decomposition techniques (OO
when students are faced with a programming assignment,                           versus functional)
their first instinct is to begin coding immediately. Our                         modeling modular relationships
integration strategy will address this by facilitating                    o data design
appropriate SE practices prior to the production of code. In                     data relationships (static models)
order to achieve the integration of SE principles into the CS                    conceptual database design
curriculum we propose a framework structured around the                          distribution across member devices &
four development phases shown in Figure 1, implemented                           processing nodes
using the spiral development pattern depicted in Figure 2.                       persistence, shared/dedicated and access
In each academic year students will be exposed to activities                     protocols
and practices for each stage of the software development                         integrity and security
process. However, the software practices employed and                            search and retrieval
artifacts produced for each phase will change in focus and                o interface design
increase in complexity to match student readiness and the                 o component design
objectives of course assignments. Student readiness will be          -Design quality and attributes
interpreted from the status of students’ personal software                o degree of abstraction
process and level of programming skill acquired with                      o degree of data encapsulation
experience, from one course to another. The following                     o degree of information hiding
sections describe the spiral approach used to train students              o degree of distribution of control
in the software development process.                                      o degree of reusability
                                                                          o degree of efficiency
                                                                          o degree of robustness
3.1 Requirements elicitation & modeling                                   o degree of modifiability and maintainability
                                                                          o degree of fault tolerance
    The first quadrant of the spiral- Requirements                        o degree of flexibility and adaptability
Elicitation & Modeling will provide experiences for                   -Size and cost estimation
students to appreciate the value of a sound requirements                  o product size metrics
elicitation process and also to develop skills in modeling                o function points and cocomo models
requirements.      These will be developed through the                    o resource loading models
following activities:                                                 -Software project planning
     -Identifying requirements
     -Classifying requirements
          o functional versus non-functional                    3.3 Coding & unit testing
          o categories of non-functional
          o testable and quantifiable versus imprecise and          Coding and unit testing are covered by the third
              ambiguous                                         quadrant. The coding phase of the software development
      -Authoring good requirements documents                    cycle will be handled by the programming aspects of the
      -Formal models for requirements                           course. As good practice, students will be taught to develop
          o specification                                       and test the individual components of their programming
          o data flow diagrams                                  projects prior to integration into the final system. This will
          o Use Case models                                     be achieved through the development of the following sub-
                                                                skills:
                                                                     -Implementation languages
3.2 Requirements analysis & software design                              o OO languages
                                                                         o procedural languages
    Requirements analysis and system design are treated                  o functional languages
together in the next quadrant. In this phase students are                o data flow languages
exposed to activities and practices to facilitate an                     o logic programming languages
   -Error detection and handling Techniques                     formally, software metrics are employed to track software
   -Software size & quality metrics                             defects.
        o SLOC & FP
        o McCabe's metric                                       The development of this desired personalized software
        o cohesion, coupling                                    process and efficient defects tracking are achieved using the
        o Chidamber & Kemerer                                   principles underlying PSP developed by Humphrey [8,9].
        o defect yield, defect density, defect detection        The PSP model presents a disciplined approach to software
            rate                                                development using sound engineering practice. It helps
   -Test coverage analysis                                      software engineers to organize and plan their work. Thus it
   -Test models, strategies and techniques                      also allows them to improve themselves through self
   -Defect analysis and classification                          analysis and measuring their productivity by tracking their
   -Inspections, walkthroughs, formal reviews                   own software process [2,5]. This facilitates the
   -Configuration management (tools & techniques)               identification of individual strengths and weakness thus
   -Test scripts and tools                                      providing the advantage of learning from experience for
                                                                continuous improvement. The authors hold the view that
                                                                PSP in its entirety is inappropriate for the purposes of this
3.4 Integration & system testing                                paper. However, the principle of the progression of process
                                                                development through a sequence of four levels (as shown
    The final quadrant covers the incorporation of separate     in Figure 3), can be used to allow students to develop their
units to incrementally build the required system using          own personal software process.
bottom up integration of sub-units already tested. SE
principles covered in this phase include:
     -Integration techniques
                                                                                                                                              PSP3
     -Testing strategies & models                                                                                                    Iteratively apply PSP2
     -Quality improvement frameworks
     -Team system integration
     -Configuration management
                                                                                                                                       PSP2
                                                                                                                               Manage Product Quality

3.5 Personal software process improvement
    Following the spiral model presented in this paper                                                    PSP1
allows students to acquire the necessary skill for software                                   Estimate size and effort using
                                                                                                     historical data
development in the four phases described above. However,
since quality software development requires more than
mere technical knowledge, the proposed model also seeks                      PSP0
                                                                     Collect data about the
to foster continuous self improvement by nurturing the                  current process
practice of an efficient and sound personal software
process.
                                                                                              Figure 3 Levels of PSP
The primary focus for the development of a good personal
process is defect tracking. The focus on defects is
important for basically three reasons. First, counting          Some of the PSP techniques that will be borrowed include
defects is one of the easiest software measures for students    tracking: defects; scheduling and planning; and size and
to collect. Second, even experienced engineers are known        cost (effort) estimation. Students will monitor their
to inject as much as 100 defects per 1000 lines of code [10].   software development style by logging descriptions of how
Lastly, defects blur design issues. Thus, before good design    they usually approach the solution to a problem which
can be addressed, correctness of programming practices          requires the development of software. From their past
must be ensured to remove defects [9]. In addition, having      experience with programs developed, they will estimate the
a carefully planned personal software process provides          effort required for the software development of similar but
opportunity for quality improvement by addressing three         new projects and use those estimates to prepare schedules
key factors that affect defect density [4]:                     and a project plan. Using this plan, students will begin to
          - tracking defect sensitivities                       develop the software with the relevant code, and testing.
          -understanding the cost of removing defects           Software metrics as shown in Table 1 will be used during
          -effective practices for preventing and fixing        the testing phase to evaluate and manage the quality of both
           defects                                              the process and product. From the results, students will
Thus the proposed integration strategy employs defects          make design modifications and continue the cycle of
tracking as a key software quality testing measure and more
refining and testing the product until both the software                        In keeping with these perspectives on assessment, and the
design and performance, meet requirements.                                      evaluation requirements of the proposed integration
                                                                                paradigm, this paper suggests an assessment tool with the
                                                                                architecture presented in Figure 4. The function of the tool
         Table 1 Software metrics to evaluate defects                           is to assist in the grading and assessment of programming
                                                                                and other home-work assignments.
 Phase Monitored      Defect Metric                  Description
 Process Quality   Yield              Number of defects found before compile
                   Defect density     Defects per 1000 lines of code
 Product Quality                      Defects found in test per 1000 lines of
                   Test Defects
                                      code




3.6 Curriculum assessment & Proposed Tool


    Curriculum assessment and evaluation is a mandate of
ABET for accreditation [3].            As discussed in the
introduction, this is covered in criteria 3-5 of the 2006-2007
CS accreditation cycle. ABET uses assessment to refer to
one or more processes that identify, collect and prepare data
to evaluate achievement based on predefined outcomes.
Evaluation on the other hand is defined as the interpretation                           Figure 4 Architecture of assessment tool
of the data gathered in the assessment process to ascertain
the extent to which objectives were met.                                        The Architecture consists of three major components: the
                                                                                design view, assessment view and the historical database.
Currently, assessment in programming classes includes                           The Design view allows lecturers to input model solutions
approximately 5-7 programming assignments to practice                           and to specify the criteria for assessment for each
concepts taught during the course. The feedback on these                        assignment. From these inputs the tool will generate
assignments is normally a numeric grade. This provides                          threshold software quality values for the assignment.
some implicit feedback on the extent to which the program                       Students’ submitted programs will then be entered for
worked as expected. However, there is no documentation                          grading in the assessment view. Assessment of students’
on the specific skills being evaluated. Factors such as the                     work will consist of computing values for the evaluation
extent to which requirements were met; design style,                            criteria stipulated in the design view. These values are then
efficiency and robustness of the design are not addressed.                      compared to the threshold values. The result of this
Thus, while students are given several opportunities to                         comparison is a quality profile of that program. The
practice their programming skills, practice of an incorrect                     proposed tool does not output a single grade. Instead it
methodology only cements bad habits; contributing to                            outputs a performance profile which is in effect a summary
software of poor quality. For effective assessment we need                      of the program features and attributes being assessed for the
more finely grained performance criteria. The                                   given assignment. In order to facilitate continuous
implementation of the paradigm proposed in this paper,                          improvement towards curriculum outcomes, the historical
demands new evaluation methods that would provide such                          database is used to keep track of students’ performance
feedback on the quality of students’ solutions. The required                    over time. It also provides a longitudinal view of changes
assessment strategy needs to perform three functions:                           in students’ personal software process as they progress
         - measure program improvement                                          through the curriculum.
         - measure students’ personal process capability
         - ensure that identified outcomes measure
              students’ personal software maturity

Workman and Massi [14] suggest course evaluation reports                        4    Future work
as an efficient way to ensure that assessment strategies have
content validity with respect to course objectives. In                                This paper presents a new teaching methodology for
addition, they suggest the use of a vector for exam scores                      integrating SE into CS and the architecture for a new
instead of a single value. This vector is a representation of                   assessment tool. Both the tool and the methodology need to
students’ grade points of performance in the acquisition of                     be validated. In the future, the authors will work on the
different knowledge and skills which are objectives of a                        actual development and implementation of the tool. Once
particular course.                                                              developed and verified, the tool will be used in the
validation of the proposed teaching methodology.                  Accreditation Cycle ABET Computing Accreditation
Experiments will be conducted to investigate the effect of        Commission October 29th 2005.
the integration of SE into the CS curriculum as prescribed        [4]      Ferguson, P. et al. Results of applying the Personal
in this paper. To this end, two experiments will be               Software Process. In Computer, Volume: 30 Issue: 5 May
conducted. The first experiment will test the effect of using     1997, page(s): 24-31.
this teaching methodology with students at different stages       [5]      Hayes, W. Using a Personal Software Process SM
of the undergraduate program. Their performance will              to improve performance.          In Proceedings of Fifth
then be compared to that of a control group not exposed to        International Software Metrics Symposium, 20-21 Nov
the methodology. The second experiment will be a                  1998. page(s): 61-71
longitudinal study tracing the effect of the use of integration   [6]      Hilburn, T.B. and Towhidnejad,M. Software
of software principles on a group of students from their          quality across the curriculum. In Proceedings of 32nd
freshman year to graduation.                                      Annual Frontiers in Education, 2002. FIE 2002. Volume 3,
                                                                  6-9 Nov. 2002 Page(s):S1G-18 - S1G-23 vol.3
                                                                  [7]      Hilburn, T.B. PSP metrics in support of software
                                                                  engineering education. In Proceedings of 12th Conference
                                                                  on Software Engineering Education and Training, 22-24
5    Conclusion                                                   March 1999, page(s):135 – 136.
                                                                  [8]      Humphrey, W.S. Making process improvement
      The purpose of education is to prepare the student to       personal. In IEEE Software, Volume: 12 Issue: 5 Sep
take his/her place as a productive member of society. The         1995, page(s): 82-83.
education process is lacking if it does not meet this             [9]      Humphrey,W.S. The Personal Software Process.
objective. It is the opinion of many in industry that present     In Proceedings of 27th Annual Conference on Frontiers in
day CS curricula are in this latter category since students       Education, Volume: 1, 5-8 Nov 1997. page(s): 11 vol.1- .
graduating with a CS degree often lack the technical skill to     [10]     Lisack, S.K. The Personal Software Process in the
make them good software engineers. This paper presents a          classroom: student reactions (an experience report). In
methodology for incorporating good software development           Proceedings of 13th Conference on Software Engineering
principles from the onset of the CS academic curriculum for       Education & Training, 6-8 March 2000, page(s): 169- 175.
undergraduates. This teaches young software engineers to
value quality from the onset, while also establishing a sense     [11]      Prechelt, L. and Unger, B. An Experiment
of value for not just the end product but also for the entire     Measuring the Effects of Personal Software Process (PSP)
process employed in building software. It is agreed that          Training. In IEEE Transactions on Software Engineering,
there is no silver bullet for consistently producing software     Volume: 27, No. 5, May 2001, pages(s): 465-472.
of high quality. However, improvement of the process used         [12]      Towhidnejad, M. and Hilburn, T. Integrating the
to develop such software, is a definite step in the right         Personal Software Process (PSP) across the Undergraduate
direction. Our proposed curriculum improvement                    Curriculum. In Proceedings of 27th Frontiers in Education
methodology necessitates changes in the current                   Conference, IEEE Press, 1997, pages 162-168.
curriculum, particularly in the area of assessment. A tool is     [13]      Towhidnejad, M. Software Quality Through
presented to support the recommended changes. The                 Requirement and Design. In Proceedings of 36th Annual
proposed tool facilitates the generation of meaningful            Frontiers in Education, 2006. FIE 2006. Volume 3, 6-9
feedback on the status of students’ personal software             Nov. 2002 Page(s):S1G-18 - S1G-23 vol.3
process and continuous data which can be reviewed both by         [14]      Workman, D. and Chuck Massi, L.                  An
educators and students. The objective is that by the end of       Assessment Methodology and Process for Standardized
their undergraduate education, students would have had            Disciplines. In Proceeding of 36th Conference on Frontiers
enough experience and training to produce software of high        in Education: CS & CE. FECS 2006. University of Central
quality and thus competently take their place in the              Florida, June 26-29, 2006.
prominent software industry.                                      [15]      Zhong, X. et al. Critical factors affecting personal
                                                                  software processes. In IEEE Software, Volume: 17 Issue:
                                                                  6, page(s): 76-83, Nov/Dec 2000.
6    References
[1]      Babar, A. and Potter, J. Adapting the Personal
Software Process (PSP) to Formal Methods.               In
Proceedings of the 2005 Australian Software Engineering
Conference. Online Version.
[2]      Borstler, J. Teaching PSP: challenges and lessons
learned. In IEEE Software. Volume: 19 Issue: 5, page(s):
42- 48, Sep/Oct 2002.
[3]      Criteria for Accrediting Computer Science
Programs. Effective for Evaluations During the 2006-2007