Catalog description:

Principles of software engineering: Introduction to all phases of the software development life cycle and associated tools and engineering methods including the unified modeling language (UML).

Prerequisite:

CSE 274

Required topics (approximate weeks allocated):

• Course Introduction (1.0)
  • The need for a software engineering and management processes
• Introduction to software life-cycle phases and engineering processes, and alternatives (1.0)
• Modeling with UML (2.0)
  • Use case diagrams, sequence diagrams, class diagrams, state charts
• Requirements elicitation and specification  (2.0)
• Design concepts (4.0)
  • Design concepts: Architecture, detail design, frameworks, APIs
  • Design principles and patterns
• Implementation concepts and tools  (1.0) 
  
  • Frameworks, APIs
  • Design to code
• Testing concepts, activities, and management  (1.0)
  • Validation, verification, strategies, and tools
  • Defect analysis and tracking
• Management concepts (1.0)
  • Change and configuration management
  • Project and team management (roles, organization, decision making)
  • Project management metrics and measures
• Mid-term test and final exam (1.0)
• Student Presentations (2.0)

Learning Outcomes

1: Explain and use the foundational aspects of software engineering.

1.1: Explain the role of a software engineer and software engineering as an engineering discipline.

1.2: Apply a contemporary analysis and design approach, such as object-oriented analysis and design to a case study.

1.3: Describe the software development life-cycle and need for associated processes: the life-cycle phases, engineering and management processes, and relationships between the phases and processes.

1.4: Describe and compare alternative software process standards and processes (e.g. waterfall, incremental, spiral, prototyping, empirical and agile methods)

1.5: Explain roles and responsibilities in a software team, and management issues of teams.

2: Develop clear, concise, and sufficiently formal life-cycle artifacts including requirements, design, implementation, and test documentation for software systems based on needs of users and stakeholders.

2.1: Explain the motivation for defining sufficiently explicit requirements.

2.2: Analyze and create a requirements specifications using scenarios, use cases, and use case diagrams from a set of customer needs.

2.3: Brainstorm alternative solutions, select from alternatives, and create designs and appropriate documentation using UML class and sequence diagrams and other appropriate methods for the problem domain.

3: Explain the value of construction technologies such as version control and design tools to assist the software development practice.

3.1: Explain the purpose of version control and apply it to manage software design or code artifacts.

3.2: Apply software tools to create design artifacts such as UML diagrams.

4: Explain software design concepts and apply them.

4.1: Describe concepts and strategies in software design including architectural design, detailed design, and user interface design.

4.2: Create UML class diagrams that represent a problem domain from a requirement specification.

4.3: Create UML sequence diagrams to express class behavior.

4.4: Evaluate alternative designs at an introductory level through reviews (e.g. review of class diagrams).

4.5: Describe general design principles: coupling, cohesion, portability, design by responsibility, etc.

4.6: Describe several design patterns (GoF, etc).

5: Demonstrate the ability to work in a team and to communicate, orally and in writing, a software design to various audiences

5.1: Work in a team to experience a portion of the software development lifecycle.

5.2: Make oral presentations of system design artifacts to users or peers.

5.3: Compile well-written design artifacts for presentation to users, peers, or the instructor.

5.4: Document a project plan, document progress, and communicate progress to users,

peers, or the instructor.

6: Explain testing and quality assurance strategies.

6.1: Distinguish between program validation and verification.

6.2: Distinguish among the different types and levels of testing (unit, integration, systems, acceptance, regression, black box, white box).

6.3: Use abuse cases to identify potential security requirements.

6.4: Describe test-driven design.