ZeePedia buy college essays online


Software Engineering - II

<<< Previous Detailed Descriptions of Proposed Courses Next >>>
 
img
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
img
·
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
img
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
img
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
img
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
img
·
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
img
·
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
img
·
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
img
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
img
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
img
·
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
img
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
img
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
img
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
img
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
img
·
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
img
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
img
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
img
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
img
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
img
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
img
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
img
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
img
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
img
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
img
·
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
img
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
img
·
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
img
·
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
img
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
img
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
img
·
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
img
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
img
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
img
(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