Software Engineering in
Computer Science Curricula 2013
(CS2013)
Richard LeBlanc
Seattle University
leblanc@seattleu.edu
CS2013 Timeline
• February 2012:
Strawman draft (alpha) public release
– Includes: Body of Knowledge, Characteristics of Graduates
• March 2013:
Ironman draft (beta) public release
– Incorporates feedback on Strawman draft
– Includes: Body of Knowledge, Characteristics of Graduates,
Curricula and Course Exemplars, Professional Practice,
Institutional Challenges
• June 30, 2013: Comment period for Ironman draft closes
• Fall 2013: Final report released (general availability)
CS2013 Steering Committee
ACM
IEEE-CS
•
Mehran Sahami, Chair (Stanford)
•
Steve Roach, Chair (U. of Texas, El Paso)
•
Andrea Danyluk (Williams College)
•
•
Sally Fincher (Univ. of Kent)
Ernesto Cuadros-Vargas
(Universidad Católica San Pablo, Peru)
•
Kathleen Fisher (Tufts University)
•
Ronald Dodge (US Military Academy)
•
•
Dan Grossman (Univ. of Washington) •
Beth Hawthorne (Union County Coll.) •
•
Randy Katz (UC Berkeley)
•
Brian Robinson (ABB corporation)
•
Rich LeBlanc (Seattle University)
•
Remzi Seker (U. of Arkansas, Little Rock)
•
Dave Reed (Creighton)
•
Alfred Thompson (Microsoft)
Robert France (Colorado State)
Amruth Kumar (Ramapo College of NJ)
Member of SE KA Subcommittee:
Tony Cowling, University of Sheffield, UK
Knowledge Areas in CS2013
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
AL - Algorithms and Complexity
AR - Architecture and Organization
CN - Computational Science
DS - Discrete Structures
GV - Graphics and Visual Computing
HC - Human-Computer Interaction
IAS - Information Assurance and Security
IM - Information Management
IS - Intelligent Systems
NC - Networking and Communications
OS - Operating Systems
PBD - Platform-based Development
PD - Parallel and Distributed Computing
PL - Programming Languages
SDF - Software Development Fundamentals
SE - Software Engineering
SF - System Fundamentals
SP - Social and Professional Issues
Software Development Fundamentals
A new "foundational" KA that includes SE topics
– Content from old Programming Fundamentals, Software
Engineering, and Algorithms and Complexity areas
– Identifies foundational (paradigm-independent)
concepts and skills (paradigms moved to Programming
Languages)
– Meant to be covered early
– Includes a Knowledge Unit called Development
Methods
Topics moved from 2001/2008 SE KA
• High-level topics under Development Methods:
– Program comprehension
– Program correctness
– Simple refactoring
– Modern programming environments
– Debugging strategies
– Documentation and programming style
• Greatest emphasis on correctness, including:
– specifications
– code reviews
– several aspects of testing
Curricular Organization (Part 1)
• Three-tiered classification of Body of Knowledge Units
– Core-Tier1: essential topics, all of which are required for any
undergraduate CS program
– Core-Tier2: important foundational topics, the vast majority
(no less than 80%) of which should be in a CS program
• Still considered “Core” topics – ideally all Tier2 topics would be
included in an undergraduate program, if possible
• Tiering allows for flexibility to locally customize curricula
– Elective: additional topics that can be included to complete
an undergraduate CS program
• Covering just “core” material is insufficient for a complete
curriculum
Curricular Organization (Part 2)
• Knowledge Areas are not (necessarily) courses
• For example, introductory programming course might
include:
Software Development Fundamentals (key concepts) +
Programming Languages (paradigm/language) +
Platform (e.g., mobile devices or robots)
Curricular Organization (Part 3)
• Guidance provided on depth of coverage for learning
outcomes in each Knowledge Area
– 3 levels of depth: Familiarity, Usage, and Assessment
– Familiarity: know what it means
– Usage: can apply concept (e.g., write the code to use it)
– Assessment: can compare/contrast/select appropriate
method/strategy for different situations
The Software Engineering Knowledge Area
Software engineering is the discipline concerned with the application of theory, knowledge,
and practice to effectively and efficiently build reliable software systems that satisfy the
requirements of customers and users. This discipline is applicable to small, medium, and
large-scale systems…
SE. Software Engineering (6 Core-Tier1 hours, 20 Core-Tier2 hours)
Core Tier-1
hours
SE/Software Processes
2
Core Tier-2
hours
Includes
electives?
1
Y
SE/Software Project Management
2
Y
SE/Tools and Environments
2
N
SE/Requirements Engineering
1
3
Y
SE/Software Design
3
5
Y
SE/Software Construction
2
Y
SE/Software Verification and Validation
3
Y
SE/Software Evolution
2
Y
Example of Knowledge Unit (Topics)
SE/Software Processes
[2 Core-Tier1 hour, 1 Core-Tier2 hours]
Topics:
[Core-Tier1]
•
•
•
•
Systems level considerations, i.e., the interaction of software with its intended environment
Introduction to software process models (e.g., waterfall, incremental, agile)
Phases of software life-cycles
Programming in the large vs. individual programming
[Core-Tier2]
•
Applying software process models
[Elective]
•
•
•
•
Software quality concepts
Process improvement
Software process capability maturity models
Software process measurements
…
Example KU Learning Outcomes
[Core-Tier1]
1. Describe how software can interact with and participate in various systems including
information management, embedded, process control, and communications systems.
[Familiarity]
2. Describe the difference between principles of the waterfall model and models using
iterations. [Familiarity]
3. Describe the different practices that are key components of various process model.
[Familiarity]
4. Differentiate among the phases of software development. [Familiarity]
5. Describe how programming in the large differs from individual efforts with respect to
understanding a large code base, code reading, understanding builds, and understanding
context of changes. [Familiarity]
[Core-Tier2]
1. Explain the concept of a software life cycle and provide an example, illustrating its phases
including the deliverables that are produced. [Familiarity]
2. Compare several common process models with respect to their value for development of
particular classes of software systems taking into account issues such as requirement
stability, size, and non-functional characteristics. [Usage]
Remaining Concerns and Challenges
• Are there enough core hours allocated to SE?
• Is there sufficient emphasis on software change/
working with an existing code base/ open source
software?
• How can we make the SE KA description (or
structure) look more friendly to teaching agile
processes?
Engaging the Community
• Website: cs2013.org
– Dissemination of drafts (e.g., Strawman report)
• Opportunities for involvement
– Comment on Body of Knowledge
– Mapping exemplar courses/curricula to Body of Knowledge
– Pedagogic approaches and instructional designs
– Share institutional challenges (and solutions to them)
Bounding Size of Curriculum
Knowledge Area
AL-Algorithms and Complexity
AR-Architecture and Organization
CN-Computational Science
DS-Discrete Structures
GV-Graphics and Visual Computing
HC-Human-Computer Interaction
IAS-Security and Information Assurance
IM-Information Management
IS-Intelligent Systems
NC-Networking and Communication
OS-Operating Systems
PBD-Platform-based Development
PD-Parallel and Distributed Computing
PL-Programming Languages
SDF-Software Development Fundamentals
SE-Software Engineering
SF-Systems Fundamentals
SP-Social and Professional Issues
Total Core Hours
All Tier1 + All Tier2 Total
All Tier1 + 90% of Tier2 Total
All Tier1 + 80% of Tier2 Total
CS2013
Tier1
Tier2
19
9
0
16
1
0
37
4
2
1
4
4
2
6
1
9
0
10
3
7
4
11
0
0
5
10
8
20
43
0
6
21
18
9
11
5
164
142
306
291.8
277.6
Bounding Size of Curriculum
Knowledge Area
AL-Algorithms and Complexity
AR-Architecture and Organization
CN-Computational Science
DS-Discrete Structures
GV-Graphics and Visual Computing
HC-Human-Computer Interaction
IAS-Security and Information Assurance
IM-Information Management
IS-Intelligent Systems
NC-Networking and Communication
OS-Operating Systems
PBD-Platform-based Development
PD-Parallel and Distributed Computing
PL-Programming Languages
SDF-Software Development Fundamentals
SE-Software Engineering
SF-Systems Fundamentals
SP-Social and Professional Issues
Total Core Hours
All Tier1 + All Tier2 Total
All Tier1 + 90% of Tier2 Total
All Tier1 + 80% of Tier2 Total
CS2013
Tier1
Tier2
19
9
0
16
1
0
37
4
2
1
4
4
2
6
1
9
0
10
3
7
4
11
0
0
5
10
8
20
43
0
6
21
18
9
11
5
164
142
306
291.8
277.6
CS2008
Core
31
36
0
43
3
8
0
11
10
15
18
0
0
21
47
31
0
16
290
CC2001
Core
31
36
0
43
3
8
0
10
10
15
18
0
0
21
38
31
0
16
280
2007
LACS
69
40
0
49
0
5
0
0
4
10
9
0
0
47
39
20
0
11
303
Course Exemplars
Name of Course, Location of Institution, Instructor, Course URL
Knowledge Areas that contain topics and learning outcomes covered in the course
Knowledge Area
Total Hours of Coverage
Name (e.g., Systems Fundamentals (SF))
Number
Where does the course fit in your curriculum?
What is covered in the course? (Short description, and/or a concise list of topics)
What is the format of the course? (Contact hours? Lecture, lab, discussion?)
How are students assessed? (Assignments: number and type, expected workload)
Course textbooks and materials
Why do you teach the course this way? (Course rationale and goals)
Body of Knowledge coverage
KA
Knowledge Unit
XY
Full name of KU
Additional topics/comments
Topics Covered
Hours
Num