Software engineering is a course for undergraduate computer science students that comprises of principles of engineering in a software development. In this course, students learn about typical phases of software that involves requirement analysis, planning and scheduling, design and coding, testing, deployment and management on different case studies. In this paper, we investigated a practical approach for learning software engineering through open source tools for different phases of the software on different case studies they have chosen as their problem statement.
Software Engineering describes about various phases involved in a software project such as requirements and analysis, design and coding, testing, deployment and maintenance. In this paper we discuss the lab process that was implemented to provide a conducive and a near software firm environment for students to provide a better understanding of Software engineering principles, different phases of the software and finally the principles of management through Open source tools. The paper is further organized as follows. Section 2 discusses about a brief introduction to the process model and Case Studies categories followed for the projects in the lab. Section 3 describes about course overview, tasks carried out in each week and the tools used, section 4 discusses about survey conducted for the curriculum and its results based on the course outcomes of the introduction of a practical way to teach software engineering with tool.
Software engineering consists of process models such as waterfall
model, incremental process, prototyping model, spiral model,
scrum model and several other models [
In requirement analysis phase, the requirements are gathered for
the project based on the features and goals listed down for a
project. It may include functional requirements such as
authentication of a user login and non-functional requirements
such as reliability, performance. During planning phase the
overall estimate or listing the various tasks to be carried out
carries out the schedule of the project and resources are assigned
to the tasks identified. In the system design phase, various
modules are identified that defines the features and requirements
identified in the phase 1. The modules identified are developed
using suitable implementation language during development
phase and tested with appropriate test cases either manually or
automated during testing. There are some disadvantages with
waterfall model compared to other software processes such as
early frozen requirements, no feedback from the user and so on as
discussed in [
Compared to other models we have followed a waterfall model approach with some modifications in the phase of requirements analysis and the feedback. During requirement analysis phase a SMART matrix approach was followed to frame the objectives and goals of a software project. For a feedback analysis in each phase a weekly status reports were designed that are discussed in the upcoming sections.
The course of Software Engineering is conducted for
undergraduate students for Computer Science and Engineering as
per ACM guidelines for Software Engineering education [
Now based on the features, requirements elicitation is carried
out to create the Software Requirement Specification (SRS) using
the tool called OSRMT (Open Source Requirements Management
Tool) [
Various cost drivers such as application experience; required
reliability and so on drive a software project. In this phase, effort
estimation is carried out for the project based on COCOMO
model using tool available by University of Southern California
[
It represents the summary level scenario of all the features in a project. It consists of actors, preconditions involved in the scenario.
It represents various classes, its attributes and methods, association between the classes for the actors considered in the use cases. Sequence diagram
It represents the dynamic behaviour of the system or software with respect to the objects of the classes and its functions.
At the end of this phase, the team will be able to identify the modules that can be implemented. The modules can be identified based on the class diagrams and the sequence diagrams. A software project involves risks such as personnel shortfalls, wrong software function implementation and so on. The next phase involved risk analysis and mitigation using risk management toolkit [12]. A risk matrix was prepared with XLS sheet with common fields as shown in the table 3 with an example of risk Personnel shortfalls. Once the risks are listed down, the priority and the rank of the risks is maintained with mitigation steps to control it.
1
Implementation or Coding was carried out in the next phase.
During coding, we also followed unit testing approach where the
students carried out unit testing with JUnit framework [
To keep track of their activities the team had to submit the Weekly Status Report as shown in the fig 1, which has the information about their role and tasks accomplished, major decision that were part of the plan and the milestones achieved. The activities carried out in each week are summarized in the table 4 and tools used for each phase and tasks carried out as described above are shown in the table 5.
Project planning scheduling and
Effort estimation using COCOMO model
and mitigation
Requirements and
Analysis Planning and scheduling Effort estimation
Design Risk analysis and mitigation Unit Testing It provides a GUI for providing the requirements in a list with dependencies between them. A gantt chart is prepared using this tool, that gives the overall schedule and resource planning for the project Using this tool, effort in terms of person months is estimated with staffing profile required for each phase as shown in the fig.
Different sequence and collaboration diagrams, use case diagrams are drawn based on the features and requirements enlisted using OSRMT.
A risk matrix of different risks and their probabilities, severity and mitigation steps to control the risk is prepared A unit test for each module is designed and executed.
Fig 1.Weekly Status Reports
In this course of Software Engineering, we conducted surveys by designing course outcomes that can be satisfied by the students after learning this course. The main aim of these surveys is to improve the curriculum of Software Engineering course using the feedback from the students. The analysis and the results are as shown in the table 6 and table 7. Table 6 lists the course outcomes and their results. Table 7 lists the survey questions formed and its results. From these survey results and feedback from the students we infer the following results.
A consistent SRS is prepared using the principles of requirement management.
Ability to plan, schedule and estimate the effort for various activities in the project to accomplish its goals and objectives.
Design and identify the modules of the system for problem using different UML diagrams.
Implement the specification and testing effectively.
Inculcate project management principles in a team and as an individual efficiently.
Sl.no 1 2 3 4
Identify a problem statement, trace the requirements and write unambiguous, correct and consistent SRS
and develop a risk management plan for the potential risks in the project
specification of a software artifact intended to accomplish goals Sl.no 1 2 3
practical approach to understand the Software principles and development process
The similar approach has been adopted in virtual lab developed
for teaching software engineering at IIT Kharagpur [
While calculating the metrics in planning phase ie, LOC, Effort, Schedule and COST in virtual labs they have used the COCOMO model, using the cost drivers they estimated the metrics in virtual labs. In our practical approach, we have estimated effort using COCOMO Model II tool and we have estimated the schedule using Gnatt Chart and Pert Chart using the ProjectLibre tool. In the next phase, designing their problem statement using Use-case, Collaboration and Sequence diagram in virtual labs, but we have designed our problem statement using Use-case diagram, The class diagram to identify the classes and modules, identifying the aggregation and association. The dynamic behavior using sequence diagram using StarUML tool. During the process of identifying the cyclomatic complexity we have assigned them to implement the prime modules and to identify the cyclomatic complexity metrics for the implemented modules. Finally, in virtual labs they developed the test cases for the modules, but in our practical approach we have we generated the automated unit test cases using Junit Testframework and manual testing for the different modules.
Software engineering education plays a key role for the students
to understand the principles of software development and its
practices in software industry. The practical tool based approach
for Software engineering followed helps the students to
understand practically about the principles, phases and practices
about software development in real time environment. The
approach we have introduced in the course is in par with virtual
labs introduced in [
Credits (L:T:P): 3:0:0 Type of Course: Lecture Appendix Course Code: CS515 Core/ Elective: Core
Objectives of the course are to: 1. Provide an understanding of the principles of software engineering in a broader system context and the notions of software engineering process and management. 2. Identify the processes, techniques and deliverables that are associated with requirement engineering including system requirement and system modeling 3. Analyze the various steps involved in the design process and the different design approaches which include functionoriented design and object-oriented design 4. Identify the importance of testing in assuring the quality of software with an understanding of managing risks during the progress of the project 5. Appreciate the need for web engineering The Software Problem & Processes: Cost, Schedule & Quality, Scale & Change, Software Processes: Process & Project, Component Software Processes, Software Development Process Models, Project Management Process Requirements Analysis & Project Planning: Requirements Analysis & Specification: Value of a Good SRS, Requirements Process, Requirements Specification, Functional Specification with Use Cases, Other Approaches for Analysis, Planning a Software Project: Effort Estimation, Project Schedule & Staffing, Quality Planning, Risk Management Planning, Project Monitoring Plan Design, Coding & Unit Testing: Design: Design Concepts, Function-oriented Design, Object-oriented Design, Detailed Design, Metrics, Coding & Unit Testing: Programming Principles & Guidelines, Incrementally Developing Code, Managing Evolving Code, Unit Testing, Code Inspection, Metrics Testing & Risk Management: Testing Concepts, Testing Process, Black-box Testing, White-box Testing, Metrics, Risk Analysis & Management: Introduction, Risk Identification, Risk Estimation, Risk Exposure, Risk Mitigation, Risk Management Plans Web Engineering: The Need for Web Engineering: Introduction, Web Applications vs Conventional Software, The Need for an Engineering Approach, Empirical Assessment, Conclusions
1. Pankaj Jalote: A Concise Introduction to Software Engineering , Springer, 2008 (Chapters: 1-4, 6-8) 2. David Gustafson: Software Engineering, Schaum's Outline Series, McGraw Hill, 2002 (Chapters: 6) 3. Emilia Mendes, Nile Mosley: Web Engineering, Springer, 2006 (Chapter: 1)
1. Roger S. Pressman: Software Engineering A Practitioner's Approach, 7th Edition, McGraw Hill, 2010
The course will be delivered through task and role based team learning concepts
At the end of the course the students should be able to: 1. Demonstrate an understanding of the principles and techniques of Software Engineering 2. Understand the activities in project management, requirement engineering process and to identify the different types of system models 3. Apply the knowledge of design engineering in software development 4. Formulate different testing methods and tools 5. Recognize the need for web engineering
1. Demonstrate an understanding of the principles and techniques of
Software Engineering 2. Understand the activities in project management, requirement engineering process and to identify the different types of system models 3. Apply the knowledge of design engineering in software development 4. Formulate different testing methods and tools 5. Recognize the need for web engineering 1 X 2 X X X 3 X
X X X
X X
X
Credits (L:T:P) 0:0:1 Type of Course: Practical sessions
4 5 6 7 8 9 10 11 X
X
X 12
X X
1 X X X X X 2 X X X X X X X X X
At the end of the course the students should be able to 1. Identify a problem statement, trace the requirements and write unambiguous, correct and consistent SRS 2. Prepare a project plan and estimate effort required for the project 3. Identify, analyze and develop a risk management plan for the potential risks in the project 4. To create a specification of a software artifact intended to accomplish goals 5. To perform exhaustive testing of the code