CSCI 265: Software Engineering
Fall 2020 Course Outline
This document is available at url:
CSCI 265 (3) Software Engineering
An exploration of the methods and tools for developing
high quality software. The course includes topics in
program design, program style, algorithm selection,
interface design, debugging and testing, system utilities,
version control, regular expressions and an introduction
to scripting languages.
Pre-requisite: CSCI 161
Course Motivation and overview
This course is intended to help you become more effective in both the design and implementation
of larger software projects. This is accomplished in a number of ways:
- through a better understanding of design principles such as data abstraction and modularity;
- through the development of clearer, more comprehensive, and more testable software specfications;
- through the application of standard coding techniques to simplify code debugging and maintenance,
including incremental development, defensive programming techniques, and adhering to a set of code
- through the use of standard tools for version control, automated program compilation, code profiling,
and automated testing.
The lectures will be used to discuss both the theories and the specific tools, languages, and techniques
we will be applying, while the labs/project will be used to apply this knowledge in practical exercises.
A more detailed list of course topics and knowledge outcomes is given
in the Topics and Knowledge Outcomes
Contact information, materials
- Lecturer: Dave Wessels, 753-3245 ext 2436, David.Wessels@viu.ca
- Office hours (zoom/discord/email):
- Wed 11:30-12:30, Fri 12:30-1:30
If you need to "see" me outside office hours please send me an email
(David.Wessels@viu.ca) to arrange a suitable time.
- Delivery mode:
in compliance with the university policies regarding the coronavirus,
the course is being delivered in a virtual/online setting: there will be no
face-to-face labs, lectures, or office hours this term.
Delivery will involve a mix of viutube/youtube videoes, supporting readings,
live Zoom sessions, VIULearn quizzes/exams, and ssh connections to the csci
servers to carry out lab/project work.
- Hardware/software requirements:
Unfortunately, given this year's course delivery mode, to complete this course
students are at a minimum going to need the ability to:
This will typically mean a student needs access to a laptop or desktop
computer running Mac, linux, or Windows, along with
sufficiently-reliable internet access. (Note that phones/tablets
by themselves are typically not sufficient.)
- reliably access the lecture/lab videos (on viutube or youtube),
- reliably access the online quizzes/exams (through VIULearn),
- reliably use ssh to connect to and conduct programming and
development exercises on the department server: csci.viu.ca.
- Textbook: these are optional, but either of the following is recommended
Kernighan and Pike
The Practice of Programming
Published 1999 by Addison Wesley
Code Complete, 2nd edition
Published 2004 by Microsoft
- Web material: online material will be available through
including links to lab and lecture videos and readings, VIULearn quizzes and exams,
lab and project exercises, sample programs, practice problems,
links to external documentation and tutorials, etc.
- Software resources we will be using on the csci server will include: C, C++, bash, make,
git, gdb, gprof, ssh
- Lectures (viutube/zoom)
- Labs (viutube/zoom)
Fri: 9:30-10:30, 10:30-11:30
- 35% Quizzes (best 5/6 quizzes, 7% each)
- 40% Project (best 5/6 lab portions 6% each, 10% for final project submission)
- 25% Final exam
- You must pass the final and you must pass the project to pass the course.
An approximate list of topics is given below,
more detail and an approximate ordering can be found at
- Introduction to our linux environment
- Introduction to software process models (waterfall, incremental, agile)
and activities within the software life cycles
- Introduction to programming in the large vs. individual programming
- Software configuration management and version control (using git)
- Shells and shell programming (using bash)
- Linking, loading, separate compilation, and automating builds (with make and C or C++)
- Applied regular expressions (in make)
- System design principles: levels of abstraction, separation of concerns,
information hiding, coupling and cohesion, re-use of standard structures
- Simple refactoring
- Debugging strategies and tools (using gdb)
- Defensive coding practices
- Verification and validation processes
- Inspections, reviews, and audits
- Shell, script, and program interaction (using bash, and C or C++)
- Testing fundamentals:
- unit, integration, validation, and system testing
- test plan creation and test case generation
- black box and white-box testing techniques
- regression testing and test automation
On successful completion of the course, the student should be able to:
- Design, implement, test, and debug software systems composed
of multiple different programs, including a mix of C++, and bash
files spread across multiple subdirectories in a file system.
- Identify common coding errors that lead to insecure programs
(e.g. buffer overflows, memory leaks, malicious code) and apply
strategies for avoiding such errors.
- Articulate design principles including separation of concerns,
information hiding, coupling and cohesion, and encapsulation.
- Conduct a personal code review (focused on common coding errors)
on a program component using a provided checklist.
- Contribute to a small-team code review focused on component correctness.
- Describe how a contract can be used to specify the behaviour of
a program component.
- Apply a variety of strategies to the testing and debugging of
- Analyze the extent to which another programmer's code meets
documentation and programming style standards.
- Describe the different practices that are key components of various
- Explain the concept of a software lifecycle and provide an example,
illustrating its phases including the deliverables that are produced.
- Describe how programming in the large differs from individual efforts
with respect to understanding a large code base, code reading,
understanding builds, and understanding context of changes.
- Demonstrate the capability to use version control (using git),
build automation (using make), and debuggers (using gdb) in support
of the development of a software product.
- Describe defensive coding practices.
- Distinguish between program validation and verification.
- Describe the role that tools can play in the validation of software.
- Describe and distinguish among the different types and levels of testing
(unit, integration, systems, and acceptance)
- Create and document a set of tests for a medium-sized code segment.
- Describe how to select good regression tests and automate them.
To work on your quizzes and experiment with the tools and languages discussed
during the semester, you will be given accounts for the computer labs.
There is a user id and password associated with each account.
Each student is responsible for their account, and for following
both the departmental and university-college policies. These may be found through
VIU's Disability Access Services
provides services to students with Learning
Disabilities, mental health disabilities, Attention Deficit Hyperactivity Disorder,
Autism, chronic medical conditions, and impairments in mobility, hearing, and vision.
If you have a disability requiring academic accommodations in this course but are
not yet registered with Disability Access Services, please contact them at
firstname.lastname@example.org. If you
are already registered with DAS, please provide me with your accommodation letter
by email (David.Wessels@viu.ca).
Appeals of Grades:
Any exercise or examination grade may be appealed. However, the
appeal must be made to the instructor, in writing and attached to the
work in question, and within 7 days of the grade being made
available to the class. The instructor reserves the right to re-grade
the entire piece of work submitted on appeal, not necessarily
just the component that the student believes is in error.
The standard VIU grading scale will be in use.
Student Academic Code of Conduct (VIU policy 96.01)
All VIU students are required to familiarize themselves with, and adhere to, the
Student Academic Code of Conduct.
Note that, even though this year's offering is being conducted in an online setting,
all quizzes, exams, lab and project work must be completed as strictly individual
work: no collaboration or outside help is permitted.