A Software Engineering Senior Design Project Inherited From a Partially Implemented Software Engineering Class Project

A Software Engineering Senior Design Project

Inherited From a Partially Implemented Software

Engineering Class Project

University of Texas – Pan American, Department of Computer Science,

Edinburg, TX 78541 brazier@utpa.edu, agarcia_3321@hotmail.com, ilovuc@yahoo.com

Abstract - For a computer science program in which

students are required to complete one course in Software Engineering, it is impossible to create a polished finished product for a project of any significant size that can demonstrate all the phases of the project. This can be solved by requiring students to complete a full set of requirements and specifications. Develop design documents for only a subset of the requirements and an even more limited implementation of the design documents. The artifacts from such a class can then be used as the foundation for a senior capstone design course. This allows for the development of skills that are directly needed in the real world, in which a team is given a set of requirements to implement, or is assigned to an existing project to continue its development, or is assigned to a project team that maintains existing code. Anticipated skills developed by the student by such a capstone project are: the ability to read and understand requirements and specifications, the ability to understand preexisting designs and the design decisions that contributed to the design, the ability to understand existing code, the ability to enhance the code to complete a project based on the requirements, and the ability to evaluate preexisting documentation. This paper will describe such a software engineering class project that involved a client from another academic department to develop a non-trivial internet based software application, which supported the department’s scheduling of faculty to classes, using an internet based web service to solve the linear programming problem that resulted from the constraints of the problem. The paper will then discuss the subsequent senior design project and implementation that followed.

Index Terms – Software Engineering Project, Software

Engineering Senior Design Project, Problem-based Learning.

INTRODUCTION

Many undergraduate computer science programs have one software engineering course. The objective of most of these courses is to cover the theoretical topics of software engineering and also to provide a major project which follows one of the life-cycle models. It is virtually impossible to assign and complete a project that is large enough to motivate the students in the necessity of completing the traditional steps in the software engineering process. The author’s solution to

this problem has been to assign a project of significant size but have the students concentrate mainly on the requirements, top level design and project planning phases of the life-cycle model for software engineering [1], while selecting only parts of detailed design and implementation sections to complete. This results in a set of artifacts that can be used for a Senior Design Project to simulate various real world scenarios from Software development to Maintenance.

Anticipated skills developed by the student by such a capstone project are: the ability to read and understand requirements and specifications, the ability to understand preexisting designs and the design decisions that contributed to the design, the ability to understand existing code, the ability to enhance the code to complete a project based on the requirements, and the ability to evaluate preexisting documentation. Such experiences in the undergraduate program support the top levels of Bloom’s Taxonomies of Cognitive Learning [2]. At the Analysis level the students are required to analyze, appraise, compare, criticize, experiment with, and test the existing designs. They are required to create additional features, redesign, organize plan, prepare and write documentation for the features, which supports the Synthesis cognitive level. Lastly at the top level Evaluation is performed with the final product by the defense and evaluation of their solutions.

This experience can also be placed in the realm of Problem-based learning (PBL) [3]-[4] that began over thirty years ago at McMaster University in Canada. Problem-based learning is an instructional method that challenges students to "learn to learn," working cooperatively in groups to seek solutions to real world problems. Problem-based learning is a development and instructional approach built around an ill-structured problem which is messy and complex in nature; requires inquiry, information-gathering, and reflection; is changing and tentative; and has no simple, fixed, formulaic, "right" solution (Finkle & Torp, 1995) [4]. The approach of this project fits this definition and supports all the characteristics of Problem-based learning which are:

• Ill-structured, complex problems provide the focal point(s) and stimuli for the course, curriculum and/or program.

• Learning is student-centered. • Faculty act as a coach or facilitator.

• Students work in small groups to solve/provide multiple solutions to problems

• Learner assessment is enhanced by self and peer assessment.

In this paper, we first provide a brief background on the pedagogy of the software engineering course, and then discuss the objectives of the senior design project. Next, we describe the software engineering project, followed by a description of the senior design project using the artifacts of the software engineering course, followed by a description of the final software product. Finally student feedback and conclusions are given.

BACKGROUOND

The University of Texas-Pan American is a regional Minority Serving Institution with a traditional ACM ABET accredited program in Computer Science. A three credit-hour semester course in Software Engineering is required for the degree. This course covers theoretical Software Engineering concepts and also includes a semester long group project experience in applying those concepts. The author has used the traditional Waterfall life-cycle model [1] as a guide for the project, but the course could just as easily be adapted to the more agile Extreme Programming model [5]. Students are assigned a project by the instructor, sometimes using a client from the university, and other times selecting a project the instructor is familiar with, where the instructor plays the role of the client. During the past semester, the students worked with a non-profit organization as a real-world client.

Projects have varied from Tennis Tournament Management Software [6]-[7], Intramural Sports Management Software, Online shopping software, and the project used for this paper, Course Scheduling of Faculty to Classes [8]. All of these projects can be designed using a three layered approach in which the user interface can be web based, and an application layer, which connects the user interface to some underlying database. The projects also lend themselves to using a prototype of the user interface to present the functional requirements of the system. Although prototypes used in this way in the real word are meant to be replaced, for purposes of the course, many times the prototypes survive and are included as part of the partial implementation. In most cases the application and the database layers do not get fully implemented.

Students were required to have a working demonstration of the partial implementation at the end of the course. This means they must provide stubs and drivers to the parts of the program that are partially finished. Having to work with partially completed components emphasizes the need for well defined interfaces for communication between the subsystem layers. For example, if the database layer was not completed, using the test cases expected results as output from the database stub allows testing the components that depend on the database. The functionality of an implemented database with a partially implemented application layer can be

demonstrated by appropriate use of the test cases as input into a driver to test the database.

The class project is organized to simulate a software company in which the instructor plays the role of the CEO and directs the review and approval of all documents. The course requires the students to submit a complete requirements document, software project management plan and a system design document using templates given in [1]. Students then submit a partial detailed design of one or more subsystems identified by the system design, a partial test plan and test cases based on the system and detailed design. The design documents are then used to complete a partial implementation of the system.

SENIOR PROCECT OBJECTIVES FOR INHERITED PROJECT

Students enrolled in the Senior Project course will construct a software product, following it through the stages from initial specification to the final completed project, including user manual. The student chooses his/her advisor and works with the advisor on a two-page Senior Project pre-proposal, outlining the project and its goals. The pre-proposal must be approved and signed by the advisor, and then submitted to the Senior Project course coordinator for approval. The student hands in the implementation code (electronically or hardcopy or both) along with proper documentation and performs a demonstration to the advisor and the coordinator. Students must also submit a final report describing the project and the goals that were accomplished and how they were accomplished, and what goals were not accomplished and why they were not accomplished. A copy of the final report is signed by the both advisor and the coordinator.

The organization of the Software Engineering course produces a set of artifacts that can be used as a basis for a Senior Design Project. This can be seen as a simulation of a real world scenario in which students join a project in midstream and must get up to speed by studying pre-existing documents or a scenario in which students join an organization where one team is involved in design and yet another team may be involved in the implementation. This can also simulate the scenario of joining a team whose function is to do maintenance on an existing project, developing the skills of reading and understanding existing code and documentation and then redesigning and modifying the software.

DESCRIPTION OF THE SOFTWARE ENGINEERING PROJECT

The Software Engineering class was divided into six teams with four members in each team. Each team produced a set of all the documents required. The project was to develop software to assist in the assignment of faculty to specific courses for a given semester. Two faculty from the Mathematics department served as real world clients [8]. The Mathematics department had been using a manual process to gather faculty preferences for courses and desired days and times they wanted to teach. These preferences were then used to produce schedules for each faculty. The two faculty clients had begun automation of the scheduling process by modeling the problem as a linear programming problem and using a

online linear program solver to assist them. This involved creating a specialized GAMS file. The General Algebraic Modeling System (GAMS) is a high-level modeling system for mathematical programming and optimization [9]. The GAMS file describing all the scheduling constraints and the faculty preferences was the input to the NEOS server to solve the scheduling problem. The NEOS Server offers the GAMS/BDMLP solver for the solution of linear programming problems in GAMS format [10]. The faculty then interpreted the text based file that was output from the NEOS server to produce the final schedule.

The purpose of the project was provide an integrated environment in which an administrator could set up the schedule of classes, the faculty information, and constraints for the faculty. The faculty could enter their preferences, and based on those inputs, the software would create the linear programming input GAMS file, make a connection to the NEOS server, and prepare an easily understood report of the results. Based on those results, a editable schedule for each faculty member would be produced.

The class met with the client faculty from the Mathematics Department to elicit requirements and then prepared a requirement elicitation and analysis document identifying functional and non-functional requirements. UML scenarios, use cases, object, sequence and state diagrams were used to present the requirements. They then created a system design document and proceeded with a partial detailed design, test cases, and partial implementation. The partial implementations were demonstrated at the end of the semester and electronic and hard copy versions along with a final report, indicating the state of the project was submitted to be archived.

Some groups had very complete User Interfaces, others were minimal, and most did not interface to the database. Some had a fairly complete database. Some groups had a fully functioning connection to the NEOS server and report generator for the output from the server. None of the groups automated the generation of the GAMS file. A variety of platforms were used for implementation.

Screen shots of the partially implemented project follow. Figure 1 illustrates one of the groups user interfaces allowing the addition of faculty by the administrator.

.

FIGURE 1

SAMPLE USER INTERFACE FROM SOFTWARE ENGINEERING PROJECT.

Figure 2 shows the design for the database, which includes course and faculty information.

FIGURE 2 SAMPLE DATABASE DESIGN

Figure 3 shows the output from the NEOS server, produced by the group who implemented the automatic connection to the NEOS server

FIGURE 3

USER SCREEN SHOWING OUTPUT FROM NEOS SERVER. SENIOR DESIGN PROJECT

Three students enrolled in the Senior Project course during the Fall of 2006 and one during Spring 2007. Three of the students in the Fall began working together as a group and proposed to take the 6 versions from the software engineering class, analyze them and use them to implement a complete and polished product that will help the Math department in their scheduling problem. They met and developed a plan to delegate the responsibilities to individual team members, one working on the user interface and input of the course and faculty information, one working on the database, and the other working on the interface to the NEOS server. About midway through the semester the team member who agreed to complete the database failed to hold up his end and dropped out of the group. This was not part of the desired plan but does reflect what can happen in the real world. The other team members then reassigned the database task to themselves; but as a result missed the end of the semester deadline and took an incomplete for the course. They finished up the project during the Spring semester. The third member chose to finish the project as an individual, using parts from the software engineering class, but redesigned much of it after completing a database course during the Fall semester and realizing how he could apply what he learned in that course. Again this was not a planned outcome of the project, but reflects real world experience as well, in that projects many times benefit from a fresh look and redesign as new capabilities and skills become available.

A fourth student took on the project during the Spring of 2007. His proposal was to convert the project to include a Web User Interface that is not coupled with the processing and storing of the data. It implements a web service that will process all the data and use a backend database to store user and scheduling director data as illustrated in Figure 4. The Web service was implemented in C#, the backend database

implemented in MSSQL, and the front end WEB UI was XHTML compliant with AJAX capabilities. This student’s proposal supported yet another objective of the senior design experience: to apply knowledge learned in his undergraduate experience and to extend that to learn new concepts independently, as well as the simulation of the real world experience as described previously. He has taken his knowledge and extended it to learn on his own, C# and the .Net Framework capabilities to support Web Services.

FIGURE 4

DIAGRAM OF SYSTEM USING A WEB SERVICE.

Web services are based on a core set of standards that describe the syntax and semantics of software communication: XML provides the common syntax for representing data; the Simple Object Access Protocol (SOAP) provides the semantics for data exchange; and the Web Services Description Language (WSDL) provides a mechanism to describe the capabilities of a Web service [11]. Support for Web services is available in the Microsoft environment as well as the Java platform [12].

FINISHED PROJECT

At the completion of the Senior Project the students presented their results in a poster at a day long Student Research Day and also met with the faculty of the Mathematics department and the project advisor to demonstrate the software. Screen shots from the finished product are described as follows.

Figure 5 is an overall view of the system, showing two classes of users, the Administrator, who can add courses and time periods to the database, creates a form selecting the list of courses, the number of sections, and the times the courses to be offered for a given semester, and can make necessary modifications to the final schedule generated by the software. Secondly, the Faculty user, who fills out the form selecting their preferences for teaching specific courses, and times they are available to teach. These results are stored in a central database to be used to automatically generate the GAMS file that is submitted to the NEOS server. The results from the NEOS server are captured by the WEB application layer for interpretation and generation of the schedules for each faculty member. These schedules are then stored in the Database.

FIGURE 5

DIAGRAM OF SYSTEM OF FINISHED SYSTEM

All screens provide a navigation bar, which include options to select Home, Inventory, View Schedule, Complete Form, Semester Management, View Semesters, Change Password, Help, GAMS, and Logout. Figure 6 shows the Administrator user interface used to select courses, times, and number of sections for a new semester. The interface allows the reuse of a previous semester as well as the ability to start from scratch.

FIGURE 6 TOP LEVEL USER INTERFACE

Figure 7 shows the Faculty user interface used to select their course and time preferences. Figure 8 shows a completed schedule for an individual faculty member. The software also provides a report showing the schedule for all faculty members.

FIGURE 7 SEMESTER SCHEDULE DESIGN

FIGURE 8

COMPLETED SCHEDULE FOR ONE FACULTY

STUDENT FEEDBACK

The students reported the following: The documents provided a strong foundation to start their work. The documents provided a great understanding of the overall project and its specifications. Since the students had participated in the software engineering class that created the documents, they indicated they understood the group experience. They felt it was a valuable experience in spite of the difficulties with the group. The greatest difficulty was time management and understanding of the amount of work that remained to complete a polished product. Students indicated they were able to modify the existing design and learn and apply new knowledge to the implementation. Students indicated it was a worthwhile experience.

CONCLUSION

Taking the documents created by a one semester Software Engineering course in which the emphasis is on writing complete requirements, using a limited set of the UML modeling language to describe and analyze a client’s requirements provides a realistic simulation of a real world situation. Students completing the Senior Design course were able to take the requirements documents, design documents,

and the partially completed implementations from five teams and deliver a fully functioning software product to the client. In the process, they had to understand and clarify the requirements, enhance the design, select an appropriate implementation domain, and integrate the best features of all the designs into the finished product. The students also explored additional technologies to enhance the design and implementation, demonstrating the ability to independently learn on their own.

ACKNOWLEDGMENT

The author wishes to acknowledge and thank the students in the CSCI 3340 Software Engineering class of Spring 2006, who created the documents and CSCI 4390 Senior Project Students, Alejandro Garcia, Jaime Lara, and Abel Vaca of Fall 2006 and Spring 2007 William Bishop, who used the documents for their Senior Design Projects.

REFERENCES

[1] Bruegge, B, and Dutoit A., “Modeling with UML”, Object-Oriented

Software Engineering Using UML, Patterns, and Java, 2nd Edition,,

Prentice Hall, 2004, pp 29-71.

[2] Taxonomies, http://tip.psychology.org/taxonomy.html (May 2007). [3] University of Delaware Problem-Based Learning,

http://www.udel.edu/pbl/ (May 2007).

[4] Center for Teaching, Learning, and Scholarship, Samford University, http://www.samford.edu/ctls/problem_based_learning.html (May 2007). [5] Kent Beck and Cynthia Andres Extreme Programming Explained:

Embrace Change (2nd Edition) (The XP Series), Addison Wesley, Nov

2004, Paperback, 224 pages.

[6] Brazier, P., “Process and Product in a Software Engineering Course: Simulating the Real World”, ASEE/IEEE 1998 28th _{Annual Conference}

on Frontiers in Education (FIE) Proceedings, 1998, IEEE: Piscataway

NJ, pp. 1292-1297.

[7] Brazier, Pearl (2000) Using High-Level Tools to Implement Software Engineering Projects, ASEE/IEEE 2000 30th ASEE/IEEE Frontiers in Education Conference Proceedings, 2000 IEEE: Piscataway, NJ, 2000, ISBN: 0-7803-6424-4. pp. T2C14-17.

[8] Brazier, Pearl, Villalobos, María Cristina, Taylor, Monty B., Basu, Kanadpriya, and Sircar, Treena (2006) A Cross-Disciplinary Software Engineering Project Implemented as a Web Service, 9th _{International}

Conference on Engineering Education, San Juan, PR.

[9] GAMS Home Page, http://www.gams.com (April 2006)

[10] NEOS Server Home Page, http://www-neos.mcs.anl.gov/ (March 2007) [11] Payam Shodjai ,Web Services and the Microsoft PlatformMicrosoft

Corporation June 2006, http://msdn2.microsoft.com/en-us/library/aa480728.aspx

[12] Java Technology and Web Services, http://java.sun.com/webservices/ 2007.