Core Knowledge and Skills
ICS 52: Introduction to Software Engineering
Other courses:
6D |
21
|
22
|
23
|
51
| 132
ICS 52
Catalog Description |
Introduction to the concepts, methods, and current practice of software
engineering. The study of large-scale software production; software life
cycle models as an organizing structure; principles and techniques
appropriate for each stage of production. Laboratory work involves a
project illustrating these elements. |
ICS 52
Course Prerequisites |
ICS 23/CSE 23 with a grade of C or better. |
ICS 52
Restrictions |
None. |
ICS 52
Knowledge Prerequisites: Skills and Concepts |
In addition to the skills and concepts introduced in previous classes,
students should have these computing skills
when they enter the class (or learn them independently in the
first week of the quarter):
- The use of a text editor (Word, etc) to create
documents.
- The use of a drawing package (PowerPoint, Visio,
etc) to create graphics for these documents.
|
ICS 52
Minimum Knowledge and Skills |
Software Life Cycle
- Mastery:
- Knowing different life cycles and their
appropriateness in different situations
- Knowing basic principles of software
engineering (such as separation of concerns, modularity, and
abstraction)
and knowing how they apply throughout the software
life cycle
- Proficiency:
- Understanding tradeoffs and relationships among
the various activities in the software life cycle
- Understand the meaning and use of a set of
basic software qualities
Requirements
- Mastery:
- Interviewing a customer to elicit requirements
- Writing a textual (non-formal) requirements
document
- Proficiency:
- Understand the structure of a requirements
document and know the appropriate kinds of information in such a
document
Architectural Design
- Mastery:
- Know the differences among interaction patterns of
a set of basic architectural styles
- Understand the difference between
architecture and module design
- Proficiency:
- Choosing an appropriate architectural style for a
particular problem
Module Design
- Mastery:
- Using provided/exported and required/imported
interfaces to define module boundaries
- Identifying and defining modules in a design
- Identifying and defining abstract data types
in a design
- Proficiency:
- Applying coupling, cohesion, fan-in, and fan-out
- Creating USES and COMPRISES diagrams
- Exposure:
- Creating a design for a non-trivial, sizeable
problem
Programming
- Mastery:
- General rules of programming style and clarity
(short rehash from earlier classes)
- Proficiency:
- Mapping a module design onto an implementation in
source code
- Exposure:
- Using existing modules and libraries in an
implementation
- Coding under a heavy deadline (requiring
tradeoffs between code quality and code functionality)
Testing
- Proficiency:
- Testing a program for failures
- Aplying white-box testing on short pieces of
code
- Applying black-box testing on short pieces of
code
- Exposure:
- Understanding the many dimensions of software
quality assurance
- Understanding the inspection and code
walk-through process
|
Return
to top of page