Skip to navigation | Skip to main content | Skip to footer
Menu
Menu

COMP23420: Software Engineering (2012-2013)

This is an archived syllabus from 2012-2013

Software Engineering
Level: 2
Credit rating: 20
Pre-requisites: Either COMP16121 and COMP16212 or COMP16920. Students should also have taken COMP23420 (week zero of the second year, first semester).
Co-requisites: No Co-requisites
Duration: this course unit covers both semesters.
Lectures: In semester one, week A will have one hour of lecture and one two hour workshop. In week B there will be one hour of lecture and one two hour coursework session held in laboratory space. In semester two, each week will have one hour of lecture. In this semester there is a team based project where you will apply the techniques you have learnt to a significant software engineering task.
Labs: The coursework in semester one is an individual project where the requirements gathering, functional modelling, static modelling and behavioural modelling are undertaken for a software system. In semester two there is a team based project where these phases are applied to a new case study and then extended to include the implementation phase. This project will include three iterations of the process that you have learnt.
Course Leader: John Sargeant
Additional Lecturers: Kung-Kiu Lau, Robert Stevens, Liping Zhao
Course leader: John Sargeant

Additional staff: view all staff
Timetable
SemesterEventLocationDayTimeGroup
w0 WORKSHOP Uni Place 4.204 Thu 09:00 - 15:00 -
w0 WORKSHOP Uni Place 4.205 Thu 09:00 - 15:00 -
w0 WORKSHOP Uni Place 4.206 Thu 09:00 - 15:00 -
w0 WORKSHOP Uni Place 5.206 Thu 09:00 - 15:00 -
w0 Lecture Uni Place TH A (3.102) Wed 09:00 - 12:00 -
w0 LUNCH Mercury Thu 12:00 - 15:00 -
w0 LUNCH Mercury Wed 12:00 - 15:00 -
w0 WORKSHOP Uni Place 4.204 Wed 14:00 - 17:00 -
w0 WORKSHOP Uni Place 4.205 Wed 14:00 - 17:00 -
w0 WORKSHOP Uni Place 4.206 Wed 14:00 - 17:00 -
w0 WORKSHOP Uni Place 5.206 Wed 14:00 - 17:00 -
w0 Lecture Uni Place TH A (3.102) Thu 15:00 - 17:00 -
Sem 1 Lecture 1.1 Mon 10:00 - 11:00 -
Sem 1 A WORKSHOP Collab Fri 09:00 - 11:00 I
Sem 1 A WORKSHOP Collab Wed 09:00 - 11:00 G
Sem 1 A WORKSHOP Collab Fri 11:00 - 13:00 H
Sem 1 B Lab G23 Fri 09:00 - 11:00 I
Sem 1 B Lab G23 Wed 09:00 - 11:00 G
Sem 1 B Lab G23 Fri 11:00 - 13:00 H
Sem 2 Lab G23 Fri 09:00 - 11:00 I
Sem 2 Lab G23 Thu 11:00 - 13:00 G
Sem 2 Lab G23 Fri 11:00 - 13:00 F
Sem 2 Lecture 1.1 Tue 14:00 - 15:00 -
Assessment Breakdown
Exam: 60%
Coursework: 15%
Lab: 25%

Themes to which this unit belongs
  • Agile Methods
  • Software Engineering

Introduction

The developmentt of software systems is a challenging process. Customers expect reliable and easy to use software to be developed within a set budget and to a tight deadline. As we come to depend upon software in so many aspects of our lives its increasing size and complexity, together with more demanding users, means the consequences of failure are increasingly severe. Experience from nearly 40 years of software engineering has shown that programming ('cutting code') is only one of a range of activities necessary for the creation of software systems that meet customer needs. The rest of the time is spent on: planning and acquiring resources for the project; investigating the business and technical contexts for the system; eliciting and documenting user requirements; creating a design for the system; and integrating, verifying and deploying the completed components.

This course unit builds on the programming skills you have gained in the first year, to provide you with an understanding of the major challenges inherent in real-scale software development, and with some of the tools and techniques that can be used in their attainment.

Since software engineering is a subject best learned hands-on, this is a project-based module that involves less traditional lecturing than usual. Instead, relevant skills will be acquired during fortnightly two-hour workshops, supported by a weekly one hour lecture. The understanding gained will be practiced through individual and team project assessments.

Aims

This unit aims to give students an introduction to the principles and practice of analysis, design and implementation in object orientated software engineering. Through experience of building a significant software system in a team, students will further their? experience and understanding of the
problems that arise in building such a system. They will develop the
analytical, critical and modelling skills that are required by a successful software engineer.

Assessment


The COMP23420 course unit as a whole is assessed through a range of components:

1. Three exercises in the semester one practical coursework sessions. This is assessed individually and will amount to 15% of the marks for the course.

2. three exercises in the semester two project. You will work in teams in this project and assessment is done for the team as a whole. This will amount to 20% of the marks for the course.

3. An examination at the end of each semester, covering all the material from each semester; you can expect to have to use material from semester one?s course in examinations in semester two. These exams will be taken on paper and will amount to 60% of the whole course ? 33% in semester one and 28% in semester two.

4. The careers session in Week 0 and second year tutorials are also counted towards your mark for COMP23420. There are various assessed parts of the second year tutorials over the two semesters. In total, this contributes 5% to your COMP23420 mark.

Programme outcomeUnit learning outcomesAssessment
A2 A4 B1 B2 B3 C2 C4 C5 C6 D2 D3 D4 D5Work effectively as part of a team in a software project to build a significant software application.
A2 A4 B1 B2 B3Plan software development activities, deal with problems and risks within a team.
A2 A4 B1 B2 B3 C2 C4 C5 C6 D2 D3 D4 D5Articulate reasons for design/modelling decisions made within a software project.
A2 A4 B1 B2 B3 C2 C4 C5 C6 D2 D3 D4 D5Gather, analyse and critically evaluate software requirements and resulting models that progressively refine a system specification.
A2 A4 B1 B2 B3 C2 C4 C5 C6Design UML models to represent structural and behavioural aspects of a software system.
A2 A4 B1 B2 B3 C2 C4 C5 C6Design system architectures that meet the system specification.
A2 A4 B1 B2 B3 C2 C4 C5 C6Take a set of UML models and implement a system.
A2 A4 B1 B2 B3 C2 C4 C5 C6Apply testing techniques to check that a software system correctly works, i.e. meets its specification.
A2 A4 B1 B2 B3 C2 C4 C5 C6Use tools to aid in the design, construction and testing of a software system.
A2 A4 B1 B2 B3 C2 C4 C5 C6Design user interfaces that support the system's functionality.

Syllabus

Team working

Most software projects are too large and complex to be completed by one person working alone, and instead require a team of people with complementary skills.
Even in a small team, effort must be put into ensuring that all team members are aware of their role in the total development, and are communicating well
with other relevant team members. Through the semester two project, students will gain experience in working in teams, coping with the dynamics of teams,
planning a team's resources and using team meetings to make progress in a team project, leading to the production of a non-trivial software system.

Software project planning

Students will be exposed to the basics of project planning for software engineering. Project planning approaches are used to tie the stages and phases of
the development process to resources within the project.

Software Methods

Students will gain an an awareness that different methods exist that describe and organise the various parts of the process of developing software. The course itself is organised in terms of the major phases of software development: Requirements gathering; functional, structural and behavioural modelling; system design; and system implementation. The team project of the second semester will expose students to a version of an incremental, iterative approach to software development.


Software Requirements Gathering

Requirements gathering forms the foundation for any software project. Students will learn about the basic techniques of interview used in requirements gathering. Students will learn the difference between functional and non-functional requirements and how this material is used and updated throughout the production of software. Students will learn the limitations and difficulties of this soft, but all too hard, technique.

Functional Modelling: Use Cases and Activity Diagrams

Once gathered, requirements have to be organised and structured in an effort to build a model of the tasks to be performed by an application. Students will learn about UML Use Cases and Activity Diagrams as a means of documenting the functionality of the software. This is the start of the process of moving from a description of what the users do to a specification
of what the system does.

Structural Modelling: domain modelling

Requirements specify what? either users do or software needs to do. It is also important to understand the domain in which the software must operate. Students
will learn about domain modelling, i.e. defining the domain model as a set of domain classes.? Although the UML notation (class and interaction diagrams)
is the same as that used for software design, domain modelling is a distinct activity from software design.

Structural Modelling: system classes

The focus will move from modelling the domain to modelling system classes, i.e. the classes of the software itself. Students will learn about system classes,
and the relationship between these and domain classes. Students will have seen the subset of UML class diagram notation that is commonly used in practice,
and? have seen how requirements specified, primarily in Use Cases, leads towards a system specification.

Behavioural modelling

With structural modelling students have encountered static modelling of both the domain in which the software will operate and the software itself. Students
will be introduced to behavioural modelling, in particular sequence diagrams that represent realisations of the use cases in software.

Introduction to User Interface Design

The interface between the user and the system is a vital part of any software system. Students will learn about the cycle of execution and evaluation by which a user operates an application. Each stage of the cycle
involves mappings from one language to another: The user's language; the interface language and the system langua ge. Students will learn how different tasks require different styles of interaction from direct manipulation; query and answer; form fill in; etc. Students will learn to choose an appropriate interaction style for a particular application and take into account human factors that affect screen design such as ergonomic considerations.


System Design: Software design based on GRASP principles

Good system designs are simple, robust, relatively easy to test, and can be often adapted to additional or changed requirements without large redesigns.
Consistently producing "good" designs requires considerable experience, but there are some general principles that can help a lot. The key skill
in OO software design is assigning responsibilities to classes, and the GRASP (General Responsibility Assignment Software Patterns) principles provide
a framework for this. A number of examples of design based on these principles will be given.

We will also provide a brief introduction to design patterns that are used to solve specific, often difficult, design problems. These, and other types
of software pattern will be covered in much more depth in a third year course unit.

System Design: Software System Architecture

Students will learn how a system's physical Architecture Layer design models the system's hardware, software and network environments. Students will learn
that in doing this, a system architecture:

list of 2 items
1. Reflects the non-functional requirements, e.g. operational, security and human-oriented requirements, and
2. Models the infrastructure, and specifies the hardware and software of that infrastructure.
list end


System Implementation: Verification and validation of software systems

Studies of system implementation in action show that errors that are found later in the development process are more costly to correct than those which
occur earlier. It is therefore in a development team's interests to be able to locate errors as soon as possible. Students will learn about strategies
for verifying that software meets its specification, (verification) and for determining whether the final system will meet the needs of the users (validation).
For most projects, verification is primarily about testing, and techniques and tools for testing will be introduced. Validation on the other hand is best
done by maintaining regular contact with users and stakeholders, and producing partial systems for users to evaluate. This requires an iterative development
method that will be employed in the team project.

System Implementation: tools

Throughout the practical coursework students will experience and learn to use various tools that are central to software engineering. These include version control systems; integrated development environments; UML drawing tools; and so on.

Reading List

Core Text
Title: Human-computer interaction (3rd edition)
Author: Dix, Alan et al.
ISBN: 0130461091
Publisher: Prentice Hall
Edition: 3rd
Year: 2004


Core Text
Title: Applying UML and patterns: an introduction to Object-Oriented analysis and design and iterative development (3rd edition)
Author: Larman, Craig
ISBN: 0131489062
Publisher: Prentice Hall
Edition: 3rd
Year: 2004


Core Text
Title: Systems analysis and design with UML (3rd edition)
Author: Dennis, Alan and Barbara Haley Wixom and David Tegarden
ISBN: 9780470400302
Publisher: Wiley
Edition: 3rd
Year: 2009