 |
Detailed Descriptions of Proposed Courses |
| << Bibliography for Software Engineering Education |
| Contributors, Reviewers and Index >> |
Appendix
A: Detailed Descriptions of Proposed
Courses
In this
appendix, we provide details of
the courses referred to in
Chapter 6. Some of the
courses
are
taken from the CCCS
volume, whereas others are
new courses being introduced
in this
software
engineering volume. For the
new courses, the following is
provided: a full course
description,
a list of prerequisites, learning
objectives, and a listing of the
anticipated coverage of
SEEK
(Chapter 4) provided by the course. In
some cases, teaching
modules, suggested labs and
exercises, and
other pedagogical guidance is provided.
For CCCS courses, we just
list the SEEK
coverage.
In most
cases, coverage of SEEK is considerably
less than the 40
lecture-equivalent-hours that is
used as a
benchmark for a `complete' course.
This leaves space for
institutions and instructors to
tailor
the courses, covering extra
material or covering the
given material in more
depth.
CCCS
introductory courses
Since these
courses are taken directly
from the CCCS volume,
the reader should consult
that
volume
for more details [ACM 2001].
Note that other CCCS
courses could be substituted
for
these.
CS101I Programming Fundamentals
This course
is taken directly from the
Computer Science Volume
(CCCS)
Course
description:
Introduces
the fundamental concepts of procedural
programming. Topics include
data types,
control
structures, functions, arrays,
files, and the mechanics of
running, testing, and
debugging.
The course
also offers an introduction to the
historical and social context of
computing and an
overview of
computer science as a
discipline.
Prerequisites:
No
programming or computer science
experience is required. Students
should
have
sufficient facility with
high-school mathematics to solve
simple linear equations and
to
appreciate
the use of mathematical
notation and formalism.
Syllabus:
· Computing
applications: Word processing;
spreadsheets; editors; files and
directories
·
Fundamental
programming constructs: Syntax and
semantics of a higher-level
language;
variables,
types, expressions, and assignment;
simple I/O; conditional and
iterative control
structures;
functions and parameter passing; structured
decomposition
·
Algorithms
and problem-solving: Problem-solving strategies;
the role of algorithms in
the
problem-solving
process; implementation strategies for
algorithms; debugging strategies;
the
concept and
properties of algorithms
·
Fundamental
data structures: Primitive
types; arrays; records;
strings and string processing
·
Machine
level representation of data: Bits,
bytes, and words; numeric
data representation and
number
bases; representation of character
data
·
Overview of
operating systems: The role
and purpose of operating systems; simple
file
management
SE2004
Volume 8/23/2004
83
·
Introduction
to net-centric computing: Background and
history of networking and
the
Internet;
demonstration and use of networking
software including e-mail,
telnet, and FTP
·
Human-computer
interaction: Introduction to design
issues
·
Software
development methodology: Fundamental
design concepts and principles;
structured
design;
testing and debugging strategies;
test-case design; programming
environments;
testing and
debugging tools
·
Social
context of computing: History of
computing and computers; evolution of
ideas and
machines;
social impact of computers and
the Internet; professionalism,
codes of ethics, and
responsible
conduct; s, intellectual
property, and software
piracy.
Total
hours of SEEK coverage:
39
CMP.cf
(30 core hours of 140) -
Computer Science
foundations
CMP.cf.1
(13 core hours of 39) -
Programming Fundamentals
CMP.cf.2 (3
core hours of 31) - Algorithms, Data
Structures/Representation
CMP.cf.3 (2
core hours of 5) - Problem solving
techniques
CMP.cf.6 (1
core hour of 1) - Basic concept of a
system
CMP.cf.7 (1
core hour of 1) - Basic user human
factors
CMP.cf.8 (1
core hour of 1) - Basic developer human
factors
CMP.cf.9 (7
core hours of 12) - Programming
language basics
CMP.cf.10 (1
core hour of 10) - Operating
system basics key concepts
from CCCS
CMP.cf.12 (1
core hour of 5) - Network communication
basics
CMP.tl (1
core hour of 4) - Construction
Tools
PRF.pr (4
core hours of 20) -
Professionalism
PRF.pr.2 -
Codes of ethics and professional
conduct
PRF.pr.3 -
Social, legal, historical, and
professional issues and
concerns
PRF.pr.6 -
The economic impact of
software
MAA.rfd (1
core hour of 3) - Requirements
fundamentals
DES.con (1
core hour of 3) - Software design
concepts
DES.con.1 -
Definition of design
VAV.rev (1
core hour of 6) - Reviews
VAV.rev.1 -
Desk checking
VAV.tst (1
core hour of 21) -
Testing
VAV.tst.1 -
Unit testing
CS102I The Object-Oriented
Paradigm
This course
is taken directly from the
Computer Science Volume
(CCCS)
Course
description:
Introduces
the concepts of object-oriented
programming to students with a
background in the
procedural
paradigm. The course begins with a
review of control structures and
data types with
emphasis on
structured data types and
array processing. It then moves on to
introduce the object-
oriented
programming paradigm, focusing on
the definition and use of
classes along with
the
fundamentals
of object-oriented design. Other topics
include an overview of
programming
language
principles, simple analysis of
algorithms, basic searching and
sorting techniques, and
an
introduction to software engineering
issues.
SE2004
Volume 8/23/2004
84
Prerequisites:
CS101I
Syllabus:
· Review
of control structures, functions, and
primitive data types
·
Object-oriented
programming: Object-oriented design;
encapsulation and information-
hiding;
separation of behavior and implementation;
classes, subclasses, and
inheritance;
polymorphism;
class hierarchies
·
Fundamental
computing algorithms: simple
searching and sorting algorithms
(linear and
binary
search, selection and insertion
sort)
·
Fundamentals
of event-driven programming
·
Introduction
to computer graphics: Using a
simple graphics API
·
Overview of
programming languages: History of
programming languages; brief
survey of
programming
paradigms
·
Virtual
machines: The concept of a
virtual machine; hierarchy of
virtual machines;
intermediate
languages
·
Introduction
to language translation: Comparison of
interpreters and compilers;
language
translation
phases; machine-dependent and
machine-independent aspects of
translation
·
Introduction
to database systems: History and
motivation for database
systems; use of a
database
query language
·
Software
evolution: Software maintenance;
characteristics of maintainable
software;
reengineering;
legacy systems; software
reuse
Total
hours of SEEK coverage:
36
CMP.cf
(30 core hours of 140) -
Computer Science
foundations
CMP.cf.1
(13 core hours of 39) -
Programming Fundamentals
CMP.cf.2 (3
core hours of 31) - Algorithms, Data
Structures/Representation
CMP.cf.3 (3
core hours of 5) - Problem solving
techniques
CMP.cf.4 (3
core hours of 5) - Abstraction -- use and
support for
CMP.cf.5 (2
core hours of 20) - Computer
organization
CMP.cf.9 (5
core hours of 12) - Programming
language basics
CMP.cf.11 (1
core hour of 10) - Database
basics
CMP.ct (1
core hour of 20) - Construction
technologies
DES.con.4 -
Design principles
DES.hci (3
core hours of 12) - Human
computer interface design
DES.hci.1 -
General HCI design principles
VAV.fnd (1
core hour of 5) - V&V terminology and
foundations
VAV.fnd.1 -
Objectives and constraints of
V&V
EVO.pro (1
core hour of 6) - Evolution
processes
EVO.pro.1 -
Basic concepts of evolution and
maintenance
SE2004
Volume 8/23/2004
85
CS103
Data Structures and
Algorithms
This course
is taken directly from the
Computer Science Volume
(CCCS)
Course
description:
Builds on
the foundation provided by
the CS101I-102I
sequence to
introduce the
fundamental
concepts of
data structures and the
algorithms that proceed from
them. Topics include
recursion,
the
underlying philosophy of object-oriented
programming, fundamental data
structures
(including
stacks, queues, linked lists, hash tables, trees, and
graphs), the basics of
algorithmic
analysis,
and an introduction to the principles of
language translation.
Prerequisites:
CS102I; discrete mathematics at the
level of CS105 is also desirable.
Syllabus:
· Review
of elementary programming concepts
·
Fundamental
data structures: Stacks; queues; linked
lists; hash tables; trees; graphs
·
Object-oriented
programming: Object-oriented design;
encapsulation and information
hiding;
classes;
separation of behavior and implementation;
class hierarchies;
inheritance;
polymorphism
·
Fundamental
computing algorithms: O(N
log N) sorting algorithms; hash tables,
including
collision-avoidance
strategies; binary search trees; representations of
graphs; depth- and
breadth-first
traversals
·
Recursion:
The concept of recursion;
recursive mathematical functions;
simple recursive
procedures;
divide-and-conquer strategies; recursive
backtracking; implementation of
recursion
·
Basic
algorithmic analysis: Asymptotic
analysis of upper and average
complexity bounds;
identifying
differences among best, average, and
worst case behaviors; big
"O," little "o,"
omega, and
theta notation; standard complexity
classes; empirical measurements of
performance;
time and space tradeoffs in
algorithms; using recurrence
relations to analyze
recursive
algorithms
·
Algorithmic
strategies: Brute-force algorithms;
greedy algorithms;
divide-and-conquer;
backtracking;
branch-and-bound; heuristics; pattern
matching and string/text
algorithms;
numerical
approximation algorithms
·
Overview of
programming languages: Programming
paradigms
·
Software
engineering: Software validation;
testing fundamentals, including test
plan creation
and test
case generation; object-oriented
testing
Total
hours of SEEK coverage:
31
CMP.cf
(30 core hours of 140) -
Computer Science
foundations
CMP.cf.1
(13 core hours of 39) -
Programming Fundamentals
CMP.cf.2
(15 core hours of 31) -
Algorithms, Data
Structures/Representation
CMP.cf.4 (2
core hours of 5) - Abstraction -- use and
support for
CMP.cf.9 -
Programming language
basics
VAV.tst (1
core hour of 21) -
Testing
VAV.tst.2 -
Exception handling
SE2004
Volume 8/23/2004
86
Intermediate
fundamental computer science
courses (Int)
This is a
sample of CCCS courses that can be
used to teach required material in
SEEK. Other
combinations
of CCCS courses could be
used, or new courses could
be created to cover the
same
material. If
this particular sequence of
three courses is used, then
the students will be
taught
much
material beyond the
essentials specified in SEEK. We
believe many software
engineering
programs
will want to provide as much
computer science as this, or
even more.
CS220
Computer Architecture
This course
is taken directly from the
CCCS volume.
Course
description:
Introduces
students to the organization and
architecture of computer systems,
beginning with the
standard von
Neumann model and then
moving forward to more
recent architectural concepts.
Prerequisites:
introduction
to computer science (any
implementation of CS103 or CS112),
discrete
structures (CS106 or CS115)
Syllabus:
· Digital
logic: Fundamental building
blocks (logic gates,
flip-flops, counters, registers,
PLA);
logic
expressions, minimization, sum of product
forms; register transfer
notation; physical
considerations
(gate delays, fan-in,
fan-out)
·
Data
representation: Bits, bytes, and
words; numeric data
representation and number
bases;
fixed- and
floating-point systems; signed and
twos-complement representations;
representation
of nonnumeric data (character
codes, graphical data);
representation of records
and
arrays
·
Assembly
level organization: Basic organization of
the von Neumann machine;
control unit;
instruction
fetch, decode, and execution;
instruction sets and types (data
manipulation,
control,
I/O); assembly/machine language
programming; instruction formats;
addressing
modes;
subroutine call and return
mechanisms; I/O and interrupts
·
Memory
systems: Storage systems and their
technology; coding, data
compression, and data
integrity;
memory hierarchy; main
memory organization and operations;
latency, cycle time,
bandwidth,
and interleaving; cache memories
(address mapping, block
size, replacement and
store
policy); virtual memory
(page table, TLB); fault
handling and reliability
·
Interfacing
and communication: I/O fundamentals:
handshaking, buffering, programmed
I/O,
interrupt-driven
I/O; interrupt structures:
vectored and prioritized, interrupt
acknowledgment;
external
storage, physical organization, and
drives; buses: bus protocols,
arbitration, direct-
memory
access (DMA); introduction to
networks; multimedia support;
raid architectures
·
Functional
organization: Implementation of simple
datapaths; control unit:
hardwired
realization
vs. microprogrammed realization;
instruction pipelining; introduction
to
instruction-level
parallelism (ILP)
·
Multiprocessor
and alternative architectures:
Introduction to SIMD, MIMD, VLIW,
EPIC;
systolic
architecture; interconnection networks;
shared memory systems; cache
coherence;
memory
models and memory
consistency
SE2004
Volume 8/23/2004
87
·
Performance
enhancements: RISC architecture;
branch prediction; prefetching;
scalability
·
Contemporary
architectures: Hand-held devices;
embedded systems; trends in
processor
architecture
Total
hours of SEEK coverage:
15
CMP.cf
(15 core hours of 140) -
Computer Science
foundations
CMP.cf.5
(15 core hours of 20) -
Computer organization
CS226
Operating Systems and
Networking
This course
is taken directly from the
CCCS volume.
Course
description:
Introduces
the fundamentals of operating systems
together with the basics of
networking and
communications.
Prerequisites:
introduction
to computer science (any
implementation of CS103 or CS112),
discrete
structures (CS106 or CS115)
Syllabus:
· Introduction
to event-driven programming
·
Using
APIs: API programming; class
browsers and related tools;
programming by example;
debugging in
the API environment
·
Overview of
operating systems: Role and purpose of
the operating system;
history of
operating
system development; functionality of a
typical operating
system
·
Operating
system principles: Structuring
methods; abstractions, processes, and
resources;
concepts of
application program interfaces;
device organization; interrupts; concepts
of
user/system
state and protection
·
Introduction
to concurrency: Synchronization
principles; the "mutual
exclusion" problem and
some
solutions; deadlock
avoidance
·
Introduction
to concurrency: States and state
diagrams; structures; dispatching and
context
switching;
the role of interrupts;
concurrent execution; the
"mutual exclusion" problem
and
some
solutions; deadlock; models and
mechanisms; producer-consumer problems
and
synchronization
·
Scheduling
and dispatch: Preemptive and
nonpreemptive scheduling; schedulers
and
policies;
processes and threads; deadlines and
real-time issues
·
Memory
management: Review of physical
memory and memory management
hardware;
overlays,
swapping, and partitions; paging and
segmentation; placement and
replacement
policies;
working sets and thrashing;
caching
·
Introduction
to distributed algorithms: Consensus and
election; fault
tolerance
·
Introduction
to net-centric computing: Background and
history of networking and
the
Internet;
network architectures; the range of
specializations within net-centric
computing
SE2004
Volume 8/23/2004
88
·
Introduction
to networking and communications: Network
architectures; issues
associated
with
distributed computing; simple
network protocols; APIs for
network operations
·
Introduction
to the World-Wide Web: Web
technologies; characteristics of web
servers;
nature of
the client-server relationship;
web protocols; support tools
for web site creation
and
web
management
·
Network
security: Fundamentals of cryptography;
secret-key algorithms;
public-key
algorithms;
authentication protocols; digital
signatures; examples
Total
hours of SEEK coverage:
16
CMP.cf
(16 core hours of 140) -
Computer Science
foundations
CMP.cf.2 (3
core hours of 31) - Algorithms, Data
Structures/Representation
CMP.cf.10 (9
core hours of 10) - Operating
system basics key concepts
from CCCS
CMP.cf.12 (4
core hours of 5) - Network communication
basics
CS270T
Databases
This course
is taken directly from the
CCCS volume.
Course
description:
Introduces
the concepts and techniques of database
systems.
Prerequisites:
introduction
to computer science (any
implementation of CS103 or CS112),
discrete
structures (CS106 or CS115)
Syllabus:
· Information
models and systems: History and
motivation for information
systems;
information
storage and retrieval; information
management applications; information
capture
and
representation; analysis and indexing;
search, retrieval, linking, navigation;
information
privacy,
integrity, security, and preservation;
scalability, efficiency, and
effectiveness
·
Database
systems: History and motivation
for database systems;
components of database
systems;
DBMS functions; database
architecture and data independence
·
Data
modeling: Data modeling; conceptual
models; object-oriented model;
relational data
model
·
Relational
databases: Mapping conceptual
schema to a relational schema; entity
and
referential
integrity; relational algebra and
relational calculus
·
Database
query languages: Overview of
database languages; SQL;
query optimization;
4th-
generation
environments; embedding non-procedural
queries in a procedural language;
introduction
to Object Query
Language
·
Relational
database design: Database
design; functional dependency;
normal forms; multi-
valued
dependency; join dependency;
representation theory
·
Transaction
processing: Transactions; failure and
recovery; concurrency
control
·
Distributed
databases: Distributed data storage;
distributed query processing;
distributed
transaction
model; concurrency control; homogeneous
and heterogeneous solutions;
client-
server
SE2004
Volume 8/23/2004
89
·
Physical
database design: Storage and
file structure; indexed
files; hashed files;
signature
files;
b-trees; files with dense
index; files with variable
length records; database
efficiency
and
tuning
Total
hours of SEEK coverage:
13
CMP.cf
(11 core hours of 140) -
Computer Science
foundations
CMP.cf.2 (2
core hours of 31) - Algorithms, Data
Structures/Representation
CMP.cf.11 (9
core hours of 10) - Database
basics
MAA.md (2
core hours of 19) -
Modeling
Mathematics
fundamentals courses
CS105 Discrete
Structures I
This course
is taken directly from the
CCCS volume.
Course
description:
Introduces
the foundations of discrete mathematics
as they apply to computer science,
focusing
on providing
a solid theoretical foundation
for further work. Topics
include functions,
relations,
sets,
simple proof techniques,
Boolean algebra, propositional logic,
digital logic,
elementary
number
theory, and the fundamentals of
counting.
Prerequisites:
Mathematical
preparation sufficient to take calculus
at the college level.
Syllabus:
· Introduction
to logic and proofs: Direct
proofs; proof by contradiction;
mathematical
induction
·
Fundamental
structures: Functions (surjections,
injections, inverses, composition);
relations
(reflexivity,
symmetry, transitivity, equivalence
relations); sets (Venn
diagrams,
complements,
Cartesian products, power sets);
pigeonhole principle; cardinality
and
countability
·
Boolean
algebra: Boolean values; standard
operations on Boolean values; de
Morgan's laws
·
Propositional
logic: Logical connectives;
truth tables; normal forms
(conjunctive and
disjunctive);
validity
·
Digital
logic: Logic gates,
flip-flops, counters; circuit
minimization
·
Elementary
number theory: Factorability;
properties of primes; greatest
common divisors and
least common
multiples; Euclid's algorithm;
modular arithmetic; the Chinese
Remainder
Theorem
·
Basics of
counting: Counting arguments;
pigeonhole principle; permutations
and
combinations;
binomial coefficients
Total
hours of SEEK coverage:
24
CMP.cf (3
core hours of 140) - Computer
Science foundations
CMP.cf.5 (3
core hours of 20) - Computer
organization
FND.mf
(21 core hours of 56) -
Mathematical foundations
SE2004
Volume 8/23/2004
90
FND.mf.1 (6
core hours of 6) - Functions, Relations
and Sets
FND.mf.2 (5
core hours of 9) - Basic Logic
FND.mf.3 (4
core hours of 9) - Proof
Techniques
FND.mf.4 (6
core hours of 6) - Basic Counting
FND.mf.10 -
Number Theory
CS106 Discrete
Structures II
This course
is taken directly from the
CCCS volume.
Course
description:
Continues
the discussion of discrete mathematics
introduced in CS105. Topics in the
second
course
include predicate logic, recurrence
relations, graphs, trees, matrices,
computational
complexity,
elementary computability, and discrete
probability.
Prerequisites:
CS105
Syllabus:
· Review
of previous course
·
Predicate
logic: Universal and existential
quantification; modus ponens and modus
tollens;
limitations
of predicate logic
·
Recurrence
relations: Basic formulae; elementary
solution techniques
·
Graphs and
trees: Fundamental definitions; simple
algorithms ; traversal strategies;
proof
techniques;
spanning trees; applications
·
Matrices:
Basic properties; applications
·
Computational
complexity: Order analysis; standard
complexity classes
·
Elementary
computability: Countability and
uncountability; diagonalization proof to
show
uncountability
of the reals; definition of
the P and NP classes; simple
demonstration of the
halting
problem
·
Discrete
probability: Finite probability
spaces; conditional probability,
independence, Bayes'
rule;
random events; random
integer variables; mathematical
expectation
Total
hours of SEEK coverage:
27
CMP.cf (5
core hours of 140) - Computer
Science foundations
CMP.cf.2 (5
core hours of 31) - Algorithms, Data
Structures/Representation
FND.mf
(19 core hours of 56) -
Mathematical foundations
FND.mf.2 (4
core hours of 9) - Basic Logic
FND.mf.3 (5
core hours of 9) - Proof
Techniques
FND.mf.4 (0
core hours of 6) - Basic Counting
FND.mf.5 (4
core hours of 5) - Graphs and
Trees
FND.mf.6 (6
core hours of 9) - Discrete
Probability
MAA.md (3
core hours of 19) -
Modeling
SE2004
Volume 8/23/2004
91
MA271
Statistics and Empirical Methods
for Computing
This is a
new course introduced as part of
this Software Engineering
volume, even though
the
topics
covered are not in the
domain of software engineering per
se. The need for
this course is
motivated by
a desire to teach basic probability and
statistics in an applied manner
that will be
seen as
relevant to software engineering
students. It may be possible to
substitute a more
generic
statistics
course, but the experience of
many educators is that students
easily forget their
statistics
background because they do
not see how it is relevant
to their chosen career. It is hoped
that
this course will rectify that to
some extent.
Course
description:
Principles
of discrete probability with applications
to computing. Basics of descriptive
statistics.
Distributions,
including normal (Gaussian),
binomial and Poisson. Least squared
concept,
correlation
and regression. Statistical tests most
useful to software engineering:
t-test, ANOVA
and
chi-squared. Design of experiments and
testing of hypotheses. Statistical
analysis of data
from a
variety of sources. Applications of
statistics to performance analysis,
reliability
engineering,
usability engineering, cost estimation,
as well as process control
evaluation.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Make
design and management decisions based on a good
understanding of probability and
statistics
·
Design and
conduct experiments to evaluate
hypotheses about software
quality and process.
·
Analyze
data from a variety of
sources.
·
Appreciate
the importance of empirical
methods in software
engineering.
Sample
labs and assignments:
· Building
spreadsheets using data gathered
from experiments of various
kinds, and using
native
statistical functions in spreadsheets to
assist in hypothesis
testing.
·
Use of
statistics applications such as SAS or
SPSS.
Additional
teaching considerations:
· Some
educators like to show the
derivation of statistical techniques
from first principles,
and
spend
much time in a statistics course
discussing and proving theorems. We
suggest that
material
taught in this way tends to be
readily forgotten by all but
the most
mathematically
inclined
computing students, and is therefore
often a waste of time. We suggest
instead, that
statistics
techniques be taught as `cookbook'
methods, although with
enough of their
rationale
explained so students can subsequently
expand their knowledge.
Using this
approach,
students can in a later (optional) course
be taught more of the
mathematical
underpinnings
of statistics and/or a wider
variety of data analysis
techniques.
·
The
use of spreadsheets, in addition to
statistical applications is suggested,
since all software
companies
have spreadsheet software,
but not all have, or
are willing to obtain, the
more
powerful,
complex, and expensive statistics
applications. Students will be more
likely to
believe
they can apply statistics
later if they know how to do
this using
spreadsheets.
SE2004
Volume 8/23/2004
92
·
This course
could be linked to other SE
courses being taught in
parallel, for example
SE212,
SE321, or SE323.
Whether or not those courses
are taught in parallel, they
should also
provide
exercises to reinforce the
material learned in this
course.
Total
hours of SEEK coverage:
18
FND.mf (3
core hours of 56) - Mathematical
foundations
FND.mf.6 (3
core hours of 9) - Discrete
Probability
FND.ef
(15 core hours of 23) -
Engineering foundations for
software
FND.ef.1 -
Empirical methods and experimental
techniques
FND.ef.2 -
Statistical analysis
Non-technical
(NT) compulsory
courses
In the
following series of courses, total
SEEK coverage in each course is far
less than 40 hours,
so there is
considerable freedom for
institutions to tailor these
courses to more closely fit
their
needs.
NT272
Engineering Economics
Courses
like this are widely
taught in engineering faculties,
particularly in North America.
The
course
presented below can be used in an
engineering program for any
type of engineering. It
could be
tailored more specifically to
the needs of software
engineering.
Course
description:
The
scope of engineering economics;
mesoeconomics; supply, demand, and production;
cost-
benefit
analysis and break-even analysis;
return on investment; analysis of
options; time value
of
money;
management of money: economic analysis,
accounting for risk.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Analyze
supply and demand for
products.
·
Perform
simple break-even analyses
·
Perform
simple cost-benefit analyses.
·
Analyze
the economic effect of
alternative investment decisions,
marketing decisions, and
design decisions,
considering the time value
of money and potential
risk.
Total
hours of SEEK coverage:
13
FND.ef (2
core hours of 23) - Engineering
foundations for
software
FND.ef.5 -
Engineering design
FND.ec
(10 core hours of 10) -
Engineering economics for
software
MGT.pp (1
core hour of 6) - Project
planning
NT181
Group Dynamics and
Communication
Course
description:
SE2004
Volume 8/23/2004
93
Essentials of
oral, written, and graphical
communication for software engineers.
Principles of
technical
writing; types of documents and
strategies for gathering information and
writing
documents,
including presentations. Appropriate
use of tables, graphics, and references.
How to
be
convincing and how to express
rationale for one's decisions or
conclusions. Basics of how
to
work
effectively with others;
notion of what motivates
people; concepts of group
dynamics.
Principles
of effective oral communication,
both at the interpersonal
level and when making
presentations to
groups. Strategies for listening,
persuasion, and negotiation.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Write
clear, concise, and accurate technical
documents following well-defined
standards for
format and
for including appropriate tables,
figures, and references.
·
Review
written technical documentation to detect
problems of various
kinds
·
Develop and
deliver a good quality formal
presentation.
·
Negotiate
basic agreements with
peers.
·
Participate
in interactions with others in
which they are able to get
their point across, and
are
also able to
listen to and appreciate the
points of others, even when
they disagree, and
are
able to
convey to others that they
have listened.
Additional
teaching considerations:
· Some
students will have poor
writing skills, so one objective of
this course should be to
help
students
improve those skills. However, it is
suggested that remedial help
in grammar,
sentence
structure etc. should not be
part of the main course, since it will
waste the time of
those
students who do not need
it. Remedial writing help
should, therefore, be
available
separately
for those who need it.
The writing of all students
should be very critically
judged;
it should
not be possible to pass this course
unless the student learns to
write well.
·
Instructors
should have students write
several documents of moderate size,
emphasizing
clarity,
usefulness, and writing quality. It is
suggested that complex
document formats be
avoided.
·
Students
could be asked to write
requirements, to describe how
something works, or to
describe
how to do something. These topics will
best prepare students for
the types of writing
they will
need to do as a software engineer.
The topics assigned should
be interesting to
students, so
that they feel more
motivated: For example, they
could be asked to describe
a
game.
Total
hours of SEEK coverage:
11
PRF.psy (3
core hours of 5) - Group dynamics /
psychology
PRF.com (8
core hours of 10) - Communications
skills
MAA.rsd.1 -
Requirements documentation
basics
NT291
Professional Software Engineering
Practice
Course
description:
History of
computing and software engineering.
Principles of professional software
engineering
practice and
ethics. Societal and environmental
obligations of the software
engineer. Role of
SE2004
Volume 8/23/2004
94
professional
organizations. Intellectual property and
other laws relevant to
software engineering
practice.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Make
ethical decisions when faced with
ethical dilemmas, with
reference to general
principles
of ethics as well as codes of
ethics for engineering,
computing, and software
engineering.
·
Apply
concern for safety,
security, and human rights to
engineering and management
decision-making.
·
Understand
basics of the history of
engineering, computing, and software
engineering.
·
Describe and
apply the laws that
affect software engineers, including
laws regarding
,
patents, and other intellectual
property.
·
Describe the
effect of software engineering decisions
on society, the economy,
the
environment,
their customers, their
management, their peers, and
themselves.
·
Describe the
importance of the various
different professional societies
relevant to software
engineering
in the state, province or country, as
well as internationally.
·
Understand
the role of standards and
standards-making bodies in engineering
and software
engineering.
·
Understand
the need for continual
professional development as an engineer
and a software
engineer.
Additional
teaching considerations:
· It is
suggested that this course be
taught in part using presentations by
guest speakers. For
example,
there could be talks by an
expert on ethics, a representative of a
professional
society, an
intellectual property expert,
etc.
·
Students
should be asked to read and
discuss articles relevant to
the course from the
popular,
trade, and
academic press.
·
Students
should be asked to debate
various ethical
issues.
·
Care
should be taken to present both
sides of certain issues. In
particular, we feel that
the
case
both for and against the
licensing of software engineers should be
presented, since
respected
leaders of the profession
still have diametrically opposite
views on this.
Another
issue
where it is important to present both
sides include patenting of
software. We believe it
is entirely
acceptable for the instructor to present
his or her `political'
opinions on these
issues as
long as students are able to
learn how the `other
side' thinks and are not
penalized
for
opposing the instructor's
views.
Total
hours of SEEK coverage:
14
PRF.pr
(13 core hours of 20) -
Professionalism
PRF.pr.1 -
Accreditation, certification, and
licensing
PRF.pr.2 -
Codes of ethics and professional
conduct
SE2004
Volume 8/23/2004
95
PRF.pr.3 -
Social, legal, historical, and
professional issues and
concerns
PRF.pr.4 -
The nature and role of
professional societies
PRF.pr.5 -
The nature and role of
software engineering
standards
PRF.pr.6 -
The economic impact of
software
QUA.cc (1
core hour of 2) - Software quality
concepts and culture
QUA.cc.2 -
Society's concern for
quality
QUA.cc.3 -
The costs and impacts of bad
quality
SE+CS
introductory courses - first
year start
SE101
Introduction to Software Engineering and
Computing
This course
is a first course in computing, taught
with a software engineering emphasis. It
is
designed to
be taught along with SE102
as replacements for any of the
CS101 and CS102
courses
from the CCCS volume.
The CS courses do teach software
engineering basics;
however,
the
idea is that this course
would start with the SE
material, and teach all the
material as a means
to the end
of solving software engineering
problems for
customers.
Course
Description:
Overview of
software engineering: Systems;
customers, users, and their requirements.
General
principles
of computing: Problem solving,
abstraction, division of the
system into
manageable
components,
reuse, simple interfaces. Programming
concepts: Control constructs;
expressions;
use of
APIs; simple data including
arrays and strings; classes and
inheritance. Design
concepts:
Evaluation
of alternatives. Basics of
testing.
Prerequisites:
High
school education with good
grades and a sense of rigor and
attention to
detail
developed through science and
mathematics courses.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Develop
simple statements of requirements.
·
Appreciate
the advantage of alternative sets of
requirements and designs for
very simple
programs.
·
Write
small programs in some
language.
·
Systematically
test and debug small programs.
Additional
teaching considerations: Since this
is a first course in computing, the
challenge will
be to
motivate students about
software engineering before
they know very much
about
programming.
One way to do this is to
study simple programs from
the outside (as black
boxes),
looking at
the features they provide
and discussing how they
could be improved. This
needs to
be done,
though, with sufficient
academic rigor.
The course
could be approached in two
parallel streams (i.e., two
mini-courses that are
synchronized).
One stream looks at higher-level
software engineering issues,
while another
teaches
programming.
Total
hours of SEEK coverage:
35
SE2004
Volume 8/23/2004
96
CMP.cf
(19 core hours of 140) -
Computer Science
foundations
CMP.cf.1 (9
core hours of 39) - Programming
Fundamentals
CMP.cf.3 (2
core hours of 5) Problem solving
techniques
CMP.cf.4 (1
core hour of 5) - Abstraction -- use and
support for
CMP.cf.5 (2
core hours of 20) - Computer
organization
CMP.cf.6 (1
core hour of 1) - Basic concept of a
system
CMP.cf.7 (1
core hour of 1) - Basic user-human
factors
CMP.cf.8 (1
core hour of 1) - Basic developer-human
factors
CMP.cf.9 (2
core hours of 12) - Programming
language basics
CMP.ct (2
core hours of 20) - Construction
technologies
CMP.tl (1
core hour of 4) - Construction
Tools
FND.ef (2
core hours of 23) - Engineering
foundations for
software
FND.ef.3 -
Measuring individual's
performance
FND.ef.4 -
Systems development
FND.ef.5 -
Engineering design
PRF.pr (2
core hours of 20) -
Professionalism
MAA.tm (1
core hour of 12) - Types of
models
MAA.rfd (2
core hours of 3) - Requirements
fundamentals
MAA.er (1
core hour of 4) - Eliciting
requirements
MAA.rsd (1
core hour of 6) - Requirements
specification & documentation
DES.con (1
core hour of 3) - Software design
concepts
DES.str (1
core hour of 6) - Software design
strategies
DES.dd (1
core hour of 12) - Detailed
design
VAV.tst (1
core hour of 21) -
Testing
SE102
Software Engineering and Computing
II
This course
is the successor to SE101
for students following a
software-oriented introductory
computing
sequence
Course
Description:
Requirements,
design, implementation, reviewing, and
testing of simple software
that interacts
with
the operating system,
databases, and network, and that
involves graphical user
interfaces.
Use of
simple data structures, such
as stacks and queues. Effective use of
the facilities of a
programming
language. Design and analysis of
simple algorithms, including those
using
recursion.
Use of simple design patterns such as
delegation. Drawing simple UML
class,
package, and
component diagrams. Dealing with
change: Evolution principles;
handling
requirements
changes; problem reporting and
tracking.
Prerequisite:
SE101
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Develop
clear, concise, and sufficiently formal
requirements for extensions to an
existing
system,
based on the true needs of
users and other
stakeholders
·
Design
software, so that it can be changed
easily.
SE2004
Volume 8/23/2004
97
·
Design
simple algorithms with
recursion.
·
Analyze
basic algorithms to determine
their efficiency.
·
Draw
simple diagrams representing software
designs.
·
Write
medium-sized programs, in
teams.
·
Develop
simple graphical user
interfaces.
·
Conduct
inspections of medium-sized
programs.
Additional
teaching considerations:
As with
SE101, students need to be reminded
regularly of the principles of
software engineering.
Total
hours of SEEK coverage:
36
CMP.cf
(23 core hours of 140) -
Computer Science
foundations
CMP.cf.1
(12 core hours of 39) -
Programming Fundamentals
CMP.cf.3 (3
core hours of 5) - Problem-solving
techniques
CMP.cf.4 (1
core hour of 5) - Abstraction -- use and
support for
CMP.cf.9 (4
core hours of 12) - Programming
language basics
CMP.cf.10 (1
core hour of 10) - Operating
system basics key concepts
from CCCS
CMP.cf.11 (1
core hour of 10) - Database
basics
CMP.cf.12 (1
core hour of 5) - Network communication
basics
PRF.pr (1
core hour of 20) -
Professionalism
MAA.md (1
core hour of 19) -
Modeling
MAA.rv (1 core
hour of 3) - Requirements
validation
DES.str (1
core hour of 6) - Software design
strategies
DES.dd (1
core hour of 12) - Detailed
design
DES.nst (1
core hours of 3) - Design notations and
support tools
VAV.fnd (1
core hour of 5) - V&V terminology and
foundations
VAV.rev (1
core hour of 6) - Reviews
VAV.tst (2
core hours of 21) -
Testing
VAV.par (1
core hour of 4) - Problem analysis and
reporting
EVO.pro (1
core hour of 6) - Evolution
processes
SE2004
Volume 8/23/2004
98
Software
engineering core courses
SE200
Software Engineering and Computing
III
This is a
third course for students
who have followed the
sequence SE101 and SE102.
Course
Description:
Software
process; planning and tracking
ones work. Analysis,
architecture, and design of simple
client-server
systems using UML, with an emphasis on
class and state diagrams.
Evaluating
designs.
Implementing designs using
appropriate data structures,
frameworks, and APIs.
Prerequisite:
SE102
Learning
objectives:
· Upon
completion of this course, students will
have the ability
to:
·
Plan
the development of a simple
system.
·
Measure and
track their progress while
developing software.
·
Create good
UML class and state diagrams.
·
Implement
systems of significant complexity.
Additional
teaching considerations:
This course
is a good place to start to expose
students to moderately sized existing
systems. They
can
therefore learn and practice
the essential skills of reading and
understanding code written
by
others.
In contrast
with SE201, this course should balance SE
learning with continued
learning of
programming
and basic computer science.
It is
suggested that a core subset of UML be
taught, rather than trying
to cover all
features.
Total
hours of SEEK coverage:
38
CMP.cf
(18 core hours of 140) -
Computer Science
foundations
CMP.cf.1 (5
core hours of 39) - Programming
Fundamentals
CMP.cf.2 (6
core hours of 31) - Algorithms, Data
Structures/Representation
CMP.cf.4 (1
core hour of 5) - Abstraction -- use and
support for
CMP.cf.9 (6
core hours of 12) - Programming
language basics
CMP.ct (3
core hours of 20) - Construction
technologies
FND.ef (1
core hour of 23) - Engineering
foundations for
software
PRF.pr (2
core hours of 20) -
Professionalism
MAA.md (1
core hour of 19) -
Modeling
DES.con (2
core hours of 3) - Software design
concepts
DES.str (1
core hour of 6) - Software design
strategies
DES.ar (2
core hours of 9) - Architectural
design
DES.hci (4
core hours of 12) - Human
computer interface design
DES.ev (1
core hour of 3) - Design
Evaluation
VAV.fnd (1
core hour of 5) - V&V terminology and
foundations
SE2004
Volume 8/23/2004
99
VAV.rev (1
core hour of 6) - Reviews
PRO.imp (1
core hour of 10) - Process
Implementation
MGT.con (1
core hour of 2) - Management
concepts
SE201
Introduction to Software
Engineering
This is a
first course in software engineering
for students who have
taken CS101 and CS102.
Course
description:
Principles
of software engineering: Requirements,
design and testing. Review of principles
of
object
orientation. Object oriented
analysis using UML. Frameworks and
APIs. Introduction to
the
client-server architecture. Analysis,
design and programming of simple servers and
clients.
Introduction
to user interface technology.
Prerequisite:
CS102
Learning
objectives
Upon
completion of this course, students will
have the ability
to:
· Develop
clear, concise, and sufficiently formal
requirements for extensions to an
existing
system,
based on the true needs of
users and other
stakeholders
·
Apply design
principles and patterns while
designing and implementing simple
distributed
systems-based
on reusable technology
·
Create UML
class diagrams which model
aspects of the domain and
the software
architecture
·
Create UML
sequence diagrams and state machines
that correctly model system
behavior
·
Implement a
simple graphical user interfaces
for a system
·
Apply
simple measurement techniques to
software
·
Demonstrate
an appreciation for the
breadth of software
engineering
Suggested
sequence of teaching modules:
1. Software
engineering and its place as an
engineering discipline
2. Review of
the principles of object
orientation
3. Reusable
technologies as a basis for
software engineering: Frameworks and
APIs.
Introduction
to client-server computing
4.
Requirements analysis
5. UML class
diagrams and object-oriented analysis;
introduction to formal modeling
using OCL
6. Examples
of building class diagrams to model
various domains
7. Design
patterns (abstraction-occurrence,
composite, player-role, singleton,
observer,
delegation,
façade, adapter, observer, etc.)
8. Use cases
and user-centered design
9.
Representing software behavior:
Sequence diagrams, state machines,
activity diagrams
10.
General software design principles:
Decomposition, decoupling, cohesion,
reuse, reusability,
portability,
testability, flexibility,
etc.
11.
Software architecture: Distributed
architectures, pipe-and-filter,
model-view-controller, etc.
12.
Introduction to testing and project
management
SE2004
Volume 8/23/2004
100
Sample
labs and assignments:
· Evaluating
the performance of various
simple software
designs
·
Adding
features to an existing
system
·
Testing a
system to verify conformance to test
cases
·
Building a
GUI for an application
·
Numerous
exercises building models in UML,
particularly class diagrams and state
machines
·
Developing a
simple set of requirements
(to be done as a team) for
some innovative
client-
server
application of very small
size
·
Implementing
the above, using reusable
technology to the greatest
extent possible
Additional
teaching considerations:
This course
is a good place to start to expose
students to moderately sized existing
systems. With
such
systems, they can learn and practice
the essential skills of reading and
understanding code
written by
others.
It is
assumed that students
entering this course will have had
little coverage of software
engineering
concepts previously, but have had
two courses that give
them a very good
background
in programming and basic computer
science. The opposite assumptions are
made for
SE200.
It is
suggested that a core subset of UML be
taught, rather than trying
to cover all
features.
Rather
than OCL, instructors may
choose to introduce a different
formal modeling
technique.
Total
hours of SEEK coverage:
34
CMP.ct (4
core hours of 20) - Construction
technologies
CMP.ct.1 -
API design and use
CMP.ct.2 -
Code reuse and
libraries
CMP.ct.3 -
Object-oriented run-time
issues
FND.ef (3
core hours of 23) - Engineering
foundations for
software
FND.ef.1 -
Empirical methods and experimental
techniques
FND.ef.4 -
Systems development
FND.ef.5 -
Engineering design
PRF.pr (1
core hour of 20) -
Professionalism
MAA.md (2
core hours of 19) -
Modeling
MAA.md.1 -
Modeling principles
MAA.md.2 -
Pre & post conditions,
invariants
MAA.md.3 -
Introduction to mathematical models and
specification languages
MAA.tm (1
core hour of 12) - Types of
models
MAA.rfd (1
core hour of 3) - Requirements
fundamentals
MAA.er (1
core hour of 4) - Eliciting
requirements
MAA.rsd (1
core hour of 6) - Requirements
specification & documentation
MAA.rsd.3 -
Specification languages
MAA.rv (1 core
hour of 3) - Requirements
validation
SE2004
Volume 8/23/2004
101
DES.con (2
core hours of 3) - Software design
concepts
DES.str (3
core hours of 6) - Software design
strategies
DES.ar (2
core hours of 9) - Architectural
design
DES.hci (1
core hour of 12) - Human
computer interface design
DES.dd (2
core hours of 12) - Detailed
design
DES.nst (1
core hour of 3) - Design notations and
support tools
DES.ev (1
core hour of 3) - Design
Evaluation
VAV.fnd (1
core hour of 5) - V&V terminology and
foundations
VAV.rev (1
core hour of 6) - Reviews
VAV.tst (2
core hours of 21) -
Testing
VAV.par (1
core hour of 4) - Problem analysis and
reporting
PRO.imp (1
core hour of 10) - Process
Implementation
MGT.con (1
core hour of 2) - Management
concepts
SE211
Software Construction
This course
is part of Core Software Engineering
Package I; it fits into slot
A in the curriculum
patterns.
Course
Description:
General
principles and techniques for
disciplined low-level software design.
BNF and basic
theory of
grammars and parsing. Use of parser
generators. Basics of language and
protocol
design.
Formal languages. State-transition and table-based
software design. Formal methods
for
software
construction. Techniques for
handling concurrency and inter-process
communication.
Techniques
for designing numerical
software. Tools for
model-driven construction.
Introduction
to
Middleware. Hot-spot analysis and
performance tuning.
Prerequisite:
(SE201
or SE200), CS103 and CS105.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Apply
a wide variety of software
construction techniques and tools,
including state-based
and
table-driven approaches to low-level
design of software
·
Design
simple languages and protocols suitable
for a variety of
applications
·
Generate
code for simple languages and
protocols using suitable
tools
·
Create
simple formal specifications of
low-level software modules,
check the validity of
these
specifications, and generate code
from the specifications
using appropriate
tools
·
Design
simple concurrent
software
·
Analyze
software to improve its
efficiency, reliability, and
maintainability
Suggested
sequence of teaching modules:
1. Basics of
formal languages; syntax and
semantics; grammars; Backus
Naur Form. Parsing;
regular
expressions and their relationship to
state diagrams
SE2004
Volume 8/23/2004
102
2. Lexical
Analysis; tokens; more
regular expressions and transition
networks; principles of
scanners
3. Using
tools to generate scanners; applications
of scanners. Relation of scanners and
compilers
4. Parsing
concepts; parse trees; context
free grammars, LL Parsing
5. Overview
of principles of programming languages.
Criteria for selecting
programming
languages and
platforms
6. Tools
for automating software design and
construction. Modeling system
behavior with
extended
finite state machines
7.
SDL
8.
Representing concurrency, and analyzing
concurrent designs
Sample
labs and assignments:
· Use of
software engineering tools to
create designs
·
Use of
parser generators to generate
languages
Additional
teaching considerations:
Students
come to this course with a basic
knowledge of finite state
machines and concurrency;
this course
should therefore cover more
advanced material.
Total
hours of SEEK coverage:
36
CMP.ct
(10 core hours of 20) -
Construction technologies
CMP.ct.6 -
Error handling, exception
handling, and fault
tolerance
CMP.ct.7 -
State-based and table driven
construction techniques
CMP.ct.8 -
Run-time configuration and
internationalization
CMP.ct.9 -
Grammar-based input processing
CMP.ct.10 -
Concurrency primitives
CMP.ct.11 -
Middleware
CMP.ct.12 -
Construction methods for
distributed software
CMP.ct.14 -
Hot-spot analysis and performance
tuning
CMP.tl (3
core hours of 4) - Construction
Tools
CMP.fm (8
core hours of 8) - Formal construction
methods
FND.mf
(11 core hours of 56) -
Mathematical foundations
FND.mf.5 (1
core hour of 5) - Graphs and Trees
FND.mf.7 (4
core hours of 4) - Finite State
Machines, regular expressions
FND.mf.8 (4
core hours of 4) - Grammars
FND.mf.9 (2
core hours of 4) - Numerical precision,
accuracy, and errors
MAA.md (4
core hours of 19) -
Modeling
SE2004
Volume 8/23/2004
103
SE212
Software Engineering Approach to
Human Computer
Interaction
This course
is part of Core Software Engineering
Packages I and II; it fits into
slot B in the
curriculum
patterns.
Course
Description:
Psychological
principles of human-computer interaction.
Evaluation of user interfaces.
Usability
engineering.
Task analysis, user-centered design, and
prototyping. Conceptual models
and
metaphors.
Software design rationale. Design of
windows, menus, and commands.
Voice and
natural
language I/O. Response time
and feedback. Color, icons, and sound.
Internationalization
and
localization. User interface
architectures and APIs. Case studies and
project.
Prerequisite:
SE201 or
SE200
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Evaluate
software user interfaces using
heuristic evaluation and user observation
techniques
·
Conduct
simple formal experiments to
evaluate usability
hypotheses.
·
Apply user
centered design and usability engineering
principles as they design a wide
variety
of software
user interfaces
Suggested
sequence of teaching modules:
1.
Background to human-computer interaction.
Underpinnings from psychology and
cognitive
science
2. More
background. Evaluation techniques:
Heuristic evaluation
3. More
evaluation techniques: Videotaped user
testing; cognitive
walkthroughs
4. Task
analysis. User-centered design
5. Usability
engineering processes; conducting
experiments
6.
Conceptual models and
metaphors
7. Designing
interfaces: Coding techniques
using color, fonts, sound,
animation, etc.
8. Designing
interfaces: Screen layout,
response time, feedback, error
messages, etc.
9. Designing
interfaces for special devices. Use of
voice I/O
10.
Designing interfaces:
Internationalization, help systems, etc.
User interface
software
architectures
11.
Expressing design rationale for user
interface design
Sample
labs and assignments:
· Evaluation
of user interfaces using heuristic
evaluation
·
Evaluation
of user interfaces using videotaped
observation of users
·
Paper
prototyping of user interfaces, then
discussing design options in order to
arrive at a
consensus
design
·
Writers-workshop
for style critiquing of
prototypes presented by
others
·
Implementation
of a system with a significant user
interface component using a
rapid
prototyping
environment
SE2004
Volume 8/23/2004
104
Additional
teaching considerations:
· Some
students naturally find it
hard to relate to the needs
of users, while others find
the
material in
this course so intuitive that
they are overconfident in
this course. Students
should
be taught to
obtain informed consent from
users when involving them in
the evaluation of
user
interfaces.
·
A strategy
that works well for
this course is to teach process issues
during one lecture
each
week, and
design issues during another
lecture each week, in effect
running two courses
in
parallel.
·
When task
analysis is discussed, it should be
compared to use case
analysis.
·
The
`writers workshop' format
works well for teaching
design in this course. Small groups
of
students
present paper prototypes of their UI
designs to the class. Other
students in the class
then
express what they like
about the designs. Next, the
other students provide
constructive
criticism.
Total
hours of SEEK coverage:
25
CMP.ct (1
core hour of 20) - Construction
technologies
CMP.ct.8 -
Run-time configuration and
internationalization
CMP.tl.2 -
GUI builders
FND.ef (3
core hours of 23) - Engineering
foundations for
software
PRF.psy (1
core hour of 5) - Group dynamics /
psychology
MAA.md (4
core hours of 19) -
Modeling
MAA.tm (1
core hour of 12) - Types of
models
MAA.rfd.5 -
Analyzing quality
DES.hci (6
core hours of 12) - Human
computer interface design
VAV.fnd (1
core hour of 5) - V&V terminology and
foundations
VAV.fnd.4 -
Metrics & Measurement
VAV.rev (1
core hour of 6) - Reviews
VAV.rev.3 -
Inspections
VAV.tst.9 -
Testing across quality
attributes
VAV.hct (6
core hours of 6) - Human computer user
interface testing and
evaluation
QUA.pda (1
core hour of 4) - Product
assurance
QUA.pda.6 -
Assessment of product quality
attributes
SE213
Design and Architecture of Large
Software Systems
This course
is part of Core Software Engineering
Package II; it fits into
slot A in the
curriculum
patterns.
Course
Description:
Modeling and
design of flexible software at the
architectural level. Basics of
model-driven
architecture.
Architectural styles and patterns.
Middleware and application
frameworks.
Configurations
and configuration management. Product
lines. Design using
Commercial Off-
The-Shelf
(COTS) software.
Prerequisites:
SE201 or
SE200, and CS103
SE2004
Volume 8/23/2004
105
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Take
requirements for simple systems and
develop software architectures and
high-level
designs
·
Use
configuration management tools
effectively, and apply change management
processes
properly
·
Design
simple distributed
software
·
Design
software using COTS
components
·
Apply a
wide variety of frameworks and
architectures in designing a wide
variety of software
·
Design and
implement software using
several different middleware
technologies
Additional
teaching considerations:
Students
will be taking this before coverage of
low-level design. Students, therefore,
need tools
and packages
that allow them to implement
their designs without much
concern for low-level
details.
Total
hours of SEEK coverage:
28
MAA.md (5
core hours of 19) -
Modeling
MAA.tm (5
core hours of 12) - Types of
models
DES.str (2
core hours of 6) - Software design
strategies
DES.ar (5
core hours of 9) - Architectural
design
EVO.pro (3
core hours of 6) - Evolution
processes
EVO.pro.1 -
Basic concepts of evolution and
maintenance
EVO.pro.2 -
Relationship between evolving
entities
EVO.ac (2
core hours of 4) - Evolution
Activities
MGT.con (1
core hour of 2) - Management
concepts
MGT.pp (1
core hour of 6) - Project
planning
MGT.cm (4
core hours of 5) - Software configuration
management
SE221
Software Testing
This course
is part of Core Software Engineering
Package II; it fits into
slot C in the
curriculum
patterns.
Course
Description:
Testing
techniques and principles: Defects
vs. failures, equivalence
classes, boundary
testing.
Types of
defects. Black-box vs. Structural
testing. Testing strategies: Unit
testing, integration
testing,
profiling, test driven development.
State based testing;
configuration testing;
compatibility
testing; web site testing.
Alpha, beta, and acceptance
testing. Coverage criteria.
Test
instrumentation and tools. Developing
test plans. Managing the
testing process.
Problem
reporting,
tracking, and analysis.
Prerequisites:
SE201 or
SE200
SE2004
Volume 8/23/2004
106
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Analyze
requirements to determine appropriate
testing strategies.
·
Design and
implement comprehensive test
plans
·
Apply a
wide variety of testing
techniques in an effective and efficient
manner
·
Compute test
coverage and yield according to a variety
of criteria
·
Use
statistical techniques to evaluate
the defect density and the
likelihood of faults.
·
Conduct
reviews and inspections.
Additional
teaching considerations:
This course
is intended to be 95% testing,
with deep coverage of a wide
variety of testing
techniques.
The course
should build skill and
experience in the student,
preferably with production
code.
Note
that usability testing is
covered in SE212.
Total
hours of SEEK coverage:
23
MAA.rfd (1
core hour of 3) - Requirements
fundamentals
MAA.rfd.4 -
Requirements characteristics
VAV.fnd (2
core hours of 5) - V&V terminology and
foundations
VAV.rev (1
core hour of 6) - Reviews
VAV.tst
(14 core hours of 21) -
Testing
VAV.tst.2 -
Exception handling
VAV.par (3
core hours of 4) - Problem analysis and
reporting
QUA.pda (2
core hours of 4) - Product
assurance
SE311
Software Design and
Architecture
This course
is part of Core Software Engineering
Package I; it fits into slot
D in the curriculum
patterns.
Course
Description:
An in-depth
look at software design. Continuation of
the study of design patterns,
frameworks,
and
architectures. Survey of current
middleware architectures. Design of
distributed systems
using
middleware. Component based design.
Measurement theory and appropriate
use of metrics
in design.
Designing for qualities such
as performance, safety, security,
reusability, reliability,
etc.
Measuring internal qualities and
complexity of software. Evaluation and
evolution of
designs.
Basics of software evolution,
reengineering, and reverse
engineering.
Prerequisites:
SE211
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
SE2004
Volume 8/23/2004
107
·
Apply a
wide variety of design patterns,
frameworks, and architectures in
designing a wide
variety of
software
·
Design and
implement software using
several different middleware
technologies
·
Use sound
quality metrics as objectives
for designs, and then measure and
assess designs to
ensure the
objectives have been
met
·
Modify
designs using sound change
control approaches
·
Use reverse
engineering techniques to recapture
the design of software
Suggested
sequence of teaching modules:
1. In-depth
study of design patterns, building on
material learned
previously.
2.
Application of design patterns to several
example applications
3. In-depth
study of middleware architectures
including COM, Corba, and
.Net
4. Extensive
case studies of real designs.
5. Basics of
software metrics; measuring
software qualities
6.
Reengineering and reverse engineering
techniques.
Sample
labs and assignments:
· Building
a significant project using one or
more well known middleware
architectures.
Additional
teaching considerations:
Students
will already have a knowledge of
some basic design patterns;
this course will cover
current
pattern catalogs in significant detail,
not just limited to the
classic `Gang of Four'
patterns.
Total
hours of SEEK coverage:
33
CMP.ct (3
core hours of 20) - Construction
technologies
CMP.ct.11 -
Middleware
CMP.ct.12 -
Construction methods for
distributed software
CMP.ct.13 -
Constructing heterogeneous systems
MAA.md (4
core hours of 19) -
Modeling
MAA.tm.3 -
Structure modeling
DES.str (2
core hours of 6) - Software design
strategies
DES.ar (5
core hours of 9) - Architectural
design
DES.dd (8
core hours of 12) - Detailed
design
DES.nst (1
core hour of 3) - Design notations and
support tools
DES.ev (1
core hour of 3) - Design
Evaluation
EVO.pro (5
core hours of 6) - Evolution
processes
EVO.ac (4
core hours of 4) - Evolution
Activities
SE312
Low-Level Design of
Software
This course
is part of Core Software Engineering
Package II; it fits into
slot D in the
curriculum
patterns.
Course
Description:
SE2004
Volume 8/23/2004
108
Detailed
software design and construction in
depth. In-depth coverage of design
patterns and
refactoring.
Introduction to formal approaches to
design. Analysis of designs based on
internal
quality
criteria. Performance and maintainability
improvement. Reverse engineering.
Disciplined
approaches
to design change.
Prerequisite:
SE213
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Apply
a wide variety of software
construction techniques and tools,
including state-based
and table
driven approaches to low-level design of
software
·
Use a wide
variety of design patterns in the design
of software
·
Perform
object-oriented design and programming
with a high level of
proficiency
·
Analyze
software in order to improve
its efficiency, reliability, and
maintainability.
·
Modify
designs using sound change
control approaches
·
Use reverse
engineering techniques to recapture
the design of software
Additional
teaching considerations:
Students
will have already learned a
lot about high-level design and
architecture. This course
covers
low-level details.
Total
hours of SEEK coverage:
26
CMP.ct
(13 core hours of 20) -
Construction technologies
CMP.tl (3
core hours of 4) - Construction
Tools
CMP.fm (2
core hours of 8) - Formal construction
methods
MAA.tm (2
core hours of 12) - Types of
models
DES.dd (5
core hours of 12) - Detailed
design
EVO.ac (1
core hour of 4) - Evolution
Activities
SE313
Formal Methods in Software
Engineering
This course
is part of Core Software Engineering
Package II; it fits into
slot F in the
curriculum
patterns.
Course
Description:
Review of
mathematical foundations for
formal methods. Formal languages and
techniques for
specification
and design, including specifying syntax
using grammars and finite
state machines.
Analysis and
verification of specifications and designs. Use of
assertions and proofs.
Automated
program and
design transformation.
Prerequisite:
SE312.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Create
mathematically precise specifications and
designs using languages such as
OCL, Z,
etc.
SE2004
Volume 8/23/2004
109
·
Analyze
the properties of formal
specifications and designs
·
Use tools to
transform specifications and
designs
Total
hours of SEEK coverage:
34
CMP.fm (6
core hours of 8) - Formal construction
methods
FND.mf
(13 core hours of 56) -
Mathematical foundations
FND.mf.5 (1
core hour of 5) - Graphs and Trees
FND.mf.7 (4
core hours of 4) - Finite State
Machines, regular expressions
FND.mf.8 (4
core hours of 4) - Grammars
FND.mf.9 (4
core hours of 4) - Numerical precision,
accuracy, and errors
MAA.md (3
core hours of 19) -
Modeling
MAA.md.3 -
Introduction to mathematical models and
specification languages
MAA.tm (2
core hours of 12) - Types of
models
MAA.tm.2 -
Behavioral modeling
MAA.rsd (3
core hours of 6) - Requirements
specification & documentation
MAA.rsd.3 -
Specification languages
MAA.rv (1 core
hour of 3) - Requirements
validation
DES.dd (3
core hours of 12) - Detailed
design
DES.nst (1
core hour of 3) - Design notations and
support tools
DES.nst.6 -
Formal design analysis
DES.ev (1
core hour of 3) - Design
Evaluation
DES.ev.2 -
Evaluation techniques
EVO.ac (1
core hour of 4) - Evolution
Activities
EVO.ac.6 -
Refactoring
EVO.ac.7 -
Program transformation
SE321
Software Quality Assurance and
Testing
This course
is part of Core Software Engineering
Package I; it fits into slot
C in the curriculum
patterns.
Course
Description:
Quality:
how to assure it and verify
it, and the need for a
culture of quality. Avoidance of
errors
and other
quality problems. Inspections and
reviews. Testing, verification and
validation
techniques.
Process assurance vs.
Product assurance. Quality
process standards. Product and
process
assurance. Problem analysis and
reporting. Statistical approaches to
quality control.
Prerequisite:
SE201 or
SE200
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Conduct
effective and efficient
inspections
·
Design and
implement comprehensive test
plans
·
Apply a
wide variety of testing
techniques in an effective and efficient
manner
·
Compute test
coverage and yield, according to a
variety of criteria
SE2004
Volume 8/23/2004
110
·
Use
statistical techniques to evaluate
the defect density and the
likelihood of faults
·
Assess a
software process to evaluate
how effective it is at promoting
quality
Suggested
sequence of teaching modules:
1.
Introduction to software quality
assurance
2.
Inspections and reviews
3.
Principles of software
validation
4. Software
verification
5. Software
testing
6.
Specification based test construction
techniques
7. White-box
and grey-box testing
8. Control
flow oriented test construction
techniques
9. Data flow
oriented test construction
techniques
10.
Cleanroom approach to quality
assurance
11.
Software process
certification
Sample
labs and assignments:
· Use of
automated testing
tools
·
Testing of a
wide variety of
software
·
Application
of a wide variety of testing
techniques
·
Inspecting
of software in teams; comparison and
analysis of results
Additional
teaching considerations:
User
interface testing with end-users is
covered in SE212, so it should not be
covered here.
However
the use of test harnesses
that work through the user
interface is an appropriate
topic.
The
reason why testing is to be emphasized so
much is not that other
techniques are less
important,
but because many other
techniques (e.g., inspections) can
more easily be learned
on
the
job, whereas testing material tends to
require course-based learning to be
mastered properly.
Total
hours of SEEK coverage:
37
FND.mf (2
core hours of 56) - Mathematical
foundations
FND.mf.9 (2
core hours of 4) - Numerical precision,
accuracy, and errors
VAV.fnd (2
core hours of 5) - V&V terminology and
foundations
VAV.rev (1
core hour of 6) - Reviews
VAV.tst
(14 core hours of 21) -
Testing
VAV.par (3
core hours of 4) - Problem analysis and
reporting
PRO.con (1
core hour of 3) - Process concepts
QUA.cc (1
core hour of 2) - Software quality
concepts and culture
QUA.std (2
core hours of 2) - Software quality
standards
QUA.pro (4
core hours of 4) - Software quality
processes
QUA.pca (4
core hours of 4) - Process
assurance
QUA.pda (3
core hours of 4) - Product
assurance
SE2004
Volume 8/23/2004
111
SE322
Software Requirements Analysis
This course
is part of Core Software Engineering
Package I; it fits into slot
E in the curriculum
patterns.
Course
Description:
Domain
engineering. Techniques for
discovering and eliciting requirements.
Languages and
models
for representing requirements.
Analysis and validation techniques,
including need, goal,
and use
case analysis. Requirements in
the context of system
engineering. Specifying and
measuring
external qualities: performance,
reliability, availability, safety,
security, etc.
Specifying
and analyzing requirements for
various types of systems:
embedded systems,
consumer
systems, web-based systems, business systems, systems
for scientists and
other
engineers.
Resolving feature interactions.
Requirements documentation standards.
Traceability.
Human
factors. Requirements in the
context of agile processes.
Requirements management:
Handling
requirements changes.
Prerequisites:
SE201 or
SE200.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Discover
or elicit requirements using a
variety of techniques
·
Organize and
prioritize requirements
·
Apply
analysis techniques such as
needs analysis, goal
analysis, and use case
analysis
·
Validate
requirements according to criteria
such as feasibility, clarity,
freedom from
ambiguity,
etc.
·
Represent
functional and non-functional
requirements for different
types of systems using
formal and
informal techniques
·
Specify and
measure quality
attributes
·
Negotiate
among different stakeholders in
order to agree on a set of
requirements
·
Detect and
resolve feature
interactions
Suggested
sequence of teaching modules:
1. Basics of
software requirements
engineering
2.
Requirements engineering process:
requirements elicitation, specification,
analysis, and
management
3. Types of
requirements: functional, non-functional,
quality attributes
4.
Requirements elicitation: identifying
needs, goals, and requirements.
Customers and other
stakeholders.
Interviews and observations
5.
Requirements specification: textual and
graphical notations and languages (UML,
User
Requirements
notation). Techniques to write
high-quality requirements.
Documentation
standards
6.
Requirements analysis: inspection,
validation, completeness, detection of
conflicts and
inconsistencies.
Feature interaction analysis and
resolution
7. Goal- and
use-case-oriented modeling, prototyping, and
analysis techniques
SE2004
Volume 8/23/2004
112
8.
Requirements for typical
systems: embedded systems, consumer
systems, web-based systems,
business
systems, systems for scientists and other
engineers
9.
Requirements management: traceability,
priorities, changes, baselines, and tool
support
10.
Requirements negotiation and risk
management
11.
Integrating requirements analysis and
software processes (including
agile ones)
Sample
labs and assignments:
· Writing
good requirements.
·
Analysis of
a wide variety of existing
software systems: Measuring
qualities, and reverse-
engineering
requirements.
·
Interviewing
users, and translating the results
into prototypes
iteratively
·
Use of tools
for managing
requirements.
·
Modeling,
prototyping, and analyzing requirements
with UML/URN tools
·
Resolving
feature interactions
Additional
teaching considerations:
Those
teaching this course will have to
put special effort into
motivating students who
prefer the
technical
and programming side of software
engineering. It would be useful to
give examples
where
bad requirements have led to
disasters (economic or physical).
Interaction with real
or
simulated
customers would also be
beneficial.
Total
hours of SEEK coverage:
18
MAA.tm (9
core hours of 12) - Types of
models
MAA.rfd (1
core hour of 3) - Requirements
fundamentals
MAA.er (2
core hours of 4) - Eliciting
requirements
MAA.rsd (4
core hours of 6) - Requirements
specification & documentation
MAA.rv (1 core
hour of 3) - Requirements
validation
MAA.rfd.6 (1
core hour of 3) - Requirements
management
SE323
Software Project
Management
This course
is part of Core Software Engineering
Package I; it fits into slot
F in the curriculum
patterns.
Course
Description:
Project
planning, cost estimation, and
scheduling. Project management tools.
Factors influencing
productivity
and success. Productivity metrics.
Analysis of options and risks.
Planning for
change.
Management of expectations. Release and
configuration management. Software
process
standards
and process implementation. Software
contracts and intellectual property.
Approaches
to
maintenance and long-term software
development. Case studies of real
industrial projects.
Prerequisites:
SE321 and
SE322
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
SE2004
Volume 8/23/2004
113
·
Develop a
comprehensive project plan
for a significant development
effort
·
Apply
management techniques to projects that
follow agile methodologies, as
well as
methodologies
involve larger-scale iterations or
releases
·
Effectively
estimate costs for a project
using several different
techniques.
·
Apply
function point measurement
techniques
·
Measure
project progress, productivity and other
aspects of the software
process
·
Apply
earned-value analysis
techniques
·
Perform
risk management, dynamically
adjusting project
plans
·
Use
configuration management tools
effectively, and apply change management
processes
properly
·
Draft and
evaluate basic software licenses,
contracts, and intellectual property
agreements,
while
recognizing the necessity of
involving legal
expertise
·
Use
standards in project management,
including ISO 10006 (project management
quality)
and ISO
12207 (software development process)
along with the SEI's CMM
model
Suggested
sequence of teaching modules:
1. Basic concepts of
project management
2. Managing
requirements
3. Software
lifecycles
4. Software
estimation
5. The
project plan
6.
Monitoring the
project
7. Risk
analysis
8. Managing
quality
9. People
problems
Sample
labs and assignments:
· Use a
commercial project management tool to
assist with all aspects of
software project
management.
This includes creating
Gantt, PERT, and Earned Value
charts
·
Make cost
estimates for a small system
using a variety of
techniques
·
Developing a
project plan for a
significant system
·
Writing a
configuration management plan
·
Using change
control and configuration management
tools
·
Evaluating a
software contract or
license
Total
hours of SEEK coverage:
26
MAA.mgt (2
core hours of 3) - Requirements
management
PRO.con (2
core hours of 3) - Process
concepts
PRO.imp (9
core hours of 10) - Process
Implementation
MGT.con (1
core hour of 2) - Management
concepts
SE2004
Volume 8/23/2004
114
MGT.pp (3
core hours of 6) - Project
planning
MGT.per (1
core hour of 2) - Project personnel and
organization
MGT.ctl (4
core hours of 4) - Project
control
MGT.cm (4
core hours of 5) - Software configuration
management
SE324
Software Process and
Management
This course
is part of Core Software Engineering
Package II; it fits into
slot E in the
curriculum
patterns.
Course
Description:
Software
processes: standards, implementation, and
assurance. Project management with a
focus
on
requirements management and long-term
evolution: Eliciting and prioritizing
requirements,
cost
estimation, planning and tracking
projects, risk analysis,
project control, change
management.
Prerequisites:
SE201 or
SE200, plus at least two additional
software engineering
courses at
the 2 level or
higher.
Learning
objectives:
Upon
completion of this course, students will
have the ability
to:
· Elicit
requirements using a variety of
techniques
·
Organize and
prioritize requirements
·
Design
processes suitable for
different types of
project
·
Assess a
software process, to evaluate
how effective it is at promoting
quality
·
Develop a
comprehensive project plan
for a significant development
effort
·
Measure
project progress, productivity and other
aspects of the software
process
·
Effectively
estimate costs for development and
evolution of a system using
several different
techniques
·
Perform
risk management, dynamically
adjusting project
plans
·
Use
standards for quality,
process and project management
·
Perform
root cause analysis, and
work towards continual
improvement of process
Total
hours of SEEK coverage:
39
MAA.er (2
core hours of 4) - Eliciting
requirements
MAA.rsd (1
core hour of 6) - Requirements
specification & documentation
MAA.rfd.6 (3
core hours of 3) - Requirements
management
EVO.pro (2
core hours of 6) - Evolution
processes
EVO.pro.3 -
Models of software
evolution
EVO.pro.4 -
Cost models of evolution
PRO.con (3
core hours of 3) - Process
concepts
PRO.imp (9
core hours of 10) - Process
Implementation
QUA.cc (1
core hour of 2) - Software quality
concepts and culture
SE2004
Volume 8/23/2004
115
QUA.std (2
core hours of 2) - Software quality
standards
QUA.pro (4
core hours of 4) - Software quality
processes
QUA.pca (4
core hours of 4) - Process
assurance
QUA.pda (1
core hour of 4) - Product
assurance
MGT.pp (2
core hours of 6) - Project
planning
MGT.per (1
core hour of 2) - Project personnel and
organization
MGT.ctl (4
core hours of 4) - Project
control
Capstone
project course
SE400
Software Engineering Capstone
Project
The
capstone project has been
part of an engineering curriculum since
the days when the
stone
mason was
asked to carve a decorated
`capstone' to signal his
achievement of mastery of
his
craft.
Course
Description:
Development
of significant software system,
employing knowledge gained from
courses
throughout
the program. Includes
development of requirements, design,
implementation, and
quality
assurance. Students may
follow any suitable process
model, must pay attention to
quality
issues, and
must manage the project
themselves, following all
appropriate project management
techniques.
Success of the project is
determined in large part by
whether students have
adequately
solved their customer's
problem.
Prerequisites:
Completion of the level 3
courses in one of the curriculum
patterns.
Sample
deliverables:
Students
should be expected to deliver one or
several iterations of a software
system, along with
all
artifacts appropriate to the
process model they are
using. These would likely
include a project
plan
(perhaps updated regularly, and containing cost
estimations, risk analysis,
division of the
work
into tasks, etc.), requirements
(including use cases),
architectural and design
documents,
test plans,
source code, and installable
system.
Additional
teaching considerations:
· It is
anticipated that this course will
not have formal lectures,
although students would
be
expected to
attend progress presentations by other
groups.
·
It is
suggested that students be
required to have a `customer'
for whom they are
developing
their
software. This could be a
company, a professor, or several people
selected as
representing
people in the potential market.
The objective of the project
would be to solve
the
customer's problem, and the
customer would therefore
assist the instructor in
evaluating
the
work.
·
It is
strongly suggested that
students work in groups of at least
two, and preferably three
or
four, on
their capstone project. Strategies
must be developed to handle
situations where the
contribution
of team members is unequal.
·
Some
institutions may wish to
divide this course into two
parts, one per semester
for
example. In
such a case, it is suggested,
however, that if students do
not finish the
project
SE2004
Volume 8/23/2004
116
(i.e.,
the second of the two
courses), then they should
have to start from the
first course
again.
Total
hours of SEEK coverage:
28
This
material represents SEEK
units that must be practiced
in all projects. Beyond
this, different
projects
will exercise skills in different areas
of SEEK.
CMP.ct (1
core hour of 20) - Construction
technologies
PRF.psy (1
core hour of 5) - Group dynamics /
psychology
PRF.com (2
core hours of 10) - Communications
skills
PRF.pr (2
core hours of 20) -
Professionalism
MAA.tm (1
core hour of 12) - Types of
models
MAA.er (1
core hour of 4) - Eliciting
requirements
MAA.rsd (1
core hour of 6) - Requirements
specification & documentation
MAA.rv (1 core
hour of 3) - Requirements
validation
DES.str (1
core hour of 6) - Software design
strategies
DES.ar (2
core hours of 9) - Architectural
design
DES.hci (2
core hours of 12) - Human
computer interface design
DES.dd (2
core hours of 12) - Detailed
design
DES.nst (1
core hour of 3) - Design notations and
support tools
DES.ev (1
core hour of 3) - Design
Evaluation
VAV.rev (2
core hours of 6) - Reviews
VAV.tst (3
core hours of 21) -
Testing
MGT.pp (2
core hours of 6) - Project
planning
MGT.per (1
core hour of 2) - Project personnel and
organization
MGT.cm (1
core hour of 5) - Software configuration
management
SE2004
Volume 8/23/2004
117
Table of Contents:
- INTRODUCTION
- The Software Engineering Discipline
- Guiding Principles
- Overview of Software Engineering Education Knowledge
- Guidelines for SE Curriculum Design and Delivery
- Courses and Course Sequences
- Adaptation to Alternative Environments
- Program Implementation and Assessment
- Bibliography for Software Engineering Education
- Detailed Descriptions of Proposed Courses
- Contributors, Reviewers and Index