The following is a compendum of all the lesson objectives, listed in a single place to simplify studying for the final exam.

Lesson 1

  1. Know the reasons for most Software Failures and the ways in which they manifest.
  2. Understand how personal software development must change to Software Engineering when the program will be used by others, developed by teams, and maintained/changed through its lifetime.
  3. Comprehend the essential attributes of Acceptability, Dependability/Security/Safety, Efficiency, and Maintainability.
  4. Understand how Quality, Schedule, and Budget must be balanced by the software engineer.
  5. Describe how varying degrees of software engineering are needed based upon the type of software being developed.
  6. Understand the four Fundamental Activities common to all software development processes.
  7. Describe the difference between Computer Science and Software Engineering.
  8. Describe how Heterogeneity, Business/Social Change, Security and Trust, and Scale affect different types of software.
  9. Know the Eight Principles of the ACM/IEEE-CS Software Engineering Code of Ethics and Professional Practice.

Lesson 2

  1. Understand the concept of a Software Process and Software Process Model.
  2. Analyze the three general software process models, their options, and characteristics of the software system being developed, the environment it will be used in, and the customer to determine a most appropriate software process to hybrid processes.
  3. Understand the activities each of the fundamental activities of a software process.
  4. Understand why software processes need to be organized to cope with changes in system requirements and design.
  5. Understand the notion of software process improvement and factors that affect software process quality.

Lesson 3

  1. Know the Agile Manifesto
  2. Analyze the Principles of the Agile Manifesto
  3. Understand how Extreme Programming uses incremental planning, small releases, simple designs, refactoring, test-first development, pair programming, collective ownership, on-site customer, continuous integration, and sustainable pace for software development
  4. Understand the process, activities, roles, and tools of the Scrum Process

Lesson 4

  1. Understand the Scrum Process and the Objectives and Mechanisms for each of the Scrum Activities
  2. Understand the Roles and Responsibilities for each in the Scrum process
  3. Understand the Purpose of each Scrum Tool
  4. Write and Refine Product Backlog Items (PBIs)
  5. Prioritize and Sequence PBIs to Sprints

Lesson 5

  1. Understand the distinction between User Requirements and System Requirements
  2. Understand the distinction between Functional Requirements and Non-Functional Requirements
  3. Understand the implications of use of “shall,” “will,” or “may” in the statement of a requirement.
  4. Write requirements at a level of detail that is appropriate to the purpose and audience.

Lesson 6

  1. Understand the contents, purpose, and use of a Requirements Specification Document.
  2. Use natural language, structured specifications, tabular formats, and graphical models to specify requirements.
  3. Assess the spectrum of Requirements Specifications tools, formality, and details to determine an appropriate approach for a given software project.
  4. Apply Requirements Validation tools to ensure that stated requirements are valid, consistent, complete, realistic, and verifiable.
  5. Devise Requirements Management processes to support identification, change, and traceability with appropriate tool support.

Lesson 7

  1. Understand the concept and components of a Use Case.
  2. Write a Use Case.
  3. Practice eliciting requirements with interviews and prototypes.

Lesson 8

  1. Understand how a Model is used as an abstraction of a system to better elaborate requirements and/or describe the system’s design.
  2. Understand how different models of a system are needed for describing the Context, Interactions, Structure, and Behavior of the system.
  3. Read and create Context Models

Lesson 9

  1. Read and create Interaction Models

Lesson 10

  1. Create UML Class Diagrams to model the object-oriented structure of a software product.
  2. Understand the components, purpose, and functional decomposition development of a Structure Chart.

Lesson 11

  1. Understand how Data Flow Diagrams and UML Activity Diagrams can be used to specify the data flow of a software product.
  2. Create a UML State Diagram to model the event-driven behavior of a software system.

Lesson 12

Practice developing System Models using

  • OV-1 Diagrams
  • Context Diagrams
  • UML Activity Diagrams
  • UML Use Case Diagrams
  • UML Sequence Diagrams
  • UML Class Diagrams
  • UML State Diagrams

Lesson 13

  1. Understand the uses, design decisions, and non-functional characteristics related to Software Architectures
  2. Understand the 4+1 Architectural Views
  3. Understand and apply the Model-View-Controller Architectural Pattern

Lesson 14

  1. Understand the purpose, concepts, advantages, and disadvantages of each of the following architectural patterns: Model-View-Controller, Layered, Repository, Client-Server, Pipe and Filter, Data-Centered, Call and Return.
  2. Choose an appropriate architectural pattern (or composition of patterns) to meet the requirements of a given system.

Lesson 16

Review the Chapter 6 reading paying particular note to how each pattern works, when it best applies, and its advantages / disadvantages.

  • Model-View-Controller
  • Layered
  • Repository
  • Client-Server
  • Pipe and Filter
  • Call-and-Return

Lesson 17

  1. Know what a design pattern is, how they are expressed, and why they are useful
  2. Understand the purpose and use of creational design patterns: factory, singleton, builder, and prototype
  3. Understand how the creational design patterns are implemented and used in Java

Lesson 18

Understand the purpose, usage, and Java implementation details for the following structural design patterns:

  • adapter
  • bridge
  • composite
  • decorator
  • facade
  • flyweight
  • proxy

Lesson 19

Understand the purpose, usage, and Java implementation details for the following behavioral design patterns:

  • chain of responsibility
  • command
  • interpreter
  • iterator
  • mediator
  • memento
  • observer
  • state
  • strategy
  • template
  • visitor

Lesson 20

  1. Apply an understanding of design patterns to practical implementation issues.
  2. Understand implementation issues of reuse, configuration management, and host-target development.
  3. Understand what is meant by open source software including the reasoning behind it, the business case for it, and its licensing issues.
  4. Review key issues regarding design and implementation.

Lesson 21

  1. Know and understand the need for and usage of Version Control Systems
  2. Understand the challenges of System Building and Continuous Integration
  3. Understand the importance and processes of Change Management
  4. Understand why Release Management is a separate process and what influences release planning

Lesson 22

  1. Understand how reviews and inspections can be used to achieve software quality.

Lesson 23

  1. Discuss concepts related to user experience design
  2. Learn how to avoid making bad design decisions

Lesson 24

  1. Practice interview techniques to solicit information about future users’ mental models
  2. Practice user experience design techniques using rapid prototyping

Lesson 25

  1. Conduct ethnographic studies to assess user experiences for effectiveness and ease of use
  2. Reflect upon lessons learned from ethnographic studies and use what is learned to refine designs
  3. Present designs and the results of studies

Lesson 26

Follow through five common design activities

Five common design activities:

  1. Define the context and modes of use of the system
  2. Design the system architecture
  3. Identify the principal system objects
  4. Develop design models
  5. Specify object interfaces

Lesson 27

  1. Know HP’s Design Quality Attributes
  2. Know some common symbology used for object-oriented design classes
  3. Know the design class quality characteristics of complete and sufficient, primitiveness, high cohesion, and low coupling
  4. Apply the five common design activities to a specific development.
  5. Make use of ArgoUML to create UML diagrams and generate corresponding Java code.

Lesson 28

  1. Define fault, error, and failure as a means of defect classification

  2. Understand the difference between verification and validation as well as their implications for testing
  3. Know the three (3) stages of testing
  4. Understand the bottom-up nature of development testing and the key techniques used
  5. Understand the techniques used for unit testing
  6. Understand the techniques used for integration testing and its emphasis on interfaces
  7. Understand the techniques used for user testing and their purpose

Lesson 29

  1. Understand and apply the techniques used for development testing
  2. Understand the difference between white box and black box testing
  3. Construct flow graph and loop test cases

Lesson 31

  1. Practice writing test cases from requirements
  2. Practice test case design based on flow graphs and loop testing techniques

Lesson 32

  1. Practice test case design based on flow graphs and loop testing techniques
  2. Understand contemporary trends in automated testing, automatic test generation, and formal methods

Lesson 33

  1. Know what security engineering is
  2. Define the security dimensions of confidentiality, availability, and integrity
  3. Understand the security levels of infrastructure, applications, and operational
  4. Understand the aspects of system security management
  5. Know the terms asset, attack, control, exposure, threat, and vulnerability
  6. Apply a security risk management approach to developing security policy and security requirements

Lesson 34

  1. Employ misuse cases to identify, understand, and mitigate security threats
  2. Use security risk analysis to develop secure designs
  3. Analyze the implications of protection and distribution in architectural design decisions for secure systems
  4. Apply the design guidelines for secure systems engineering and the dependable programming guidelines to develop secure systems

Lesson 35

  1. Define the following terms:
    • Fault
    • Error
    • Failure
    • Fault avoidance
    • Fault detection
    • Fault tolerance
  2. Describe the concepts of availability and reliability
  3. Know how to write the different types of reliability requirements
  4. Understand why fault-tolerant architectures are built like they are
  5. Understand the dependable programming guidelines

Lesson 36

  1. Understand what is meant by resilience engineering and how it relies on the four Rs: recognition, resistance, recovery, and reinstatement
  2. Understand the threats and controls related to cybersecurity
  3. Apply design and implementation techniques to achieve resiliency objectives

Lesson 37

  1. Identify the principal tasks of software project managers
  2. Recognize the attributes and responsibilities of a good leader
  3. Select the appropriate organizational paradigm for a software team based on project characteristics
  4. Recognize factors that lead to unproductive teams and describe ways to prevent them

Lesson 38

  1. Understand the fundamentals of software costing and factors that affect software price
  2. Know the sections typically included in a software project plan (for plan-driven development)
  3. Understand how project scheduling is accomplished with task / milestone graphs and activity bar charts (Gantt charts)
  4. Understand the “planning game” used with agile methods
  5. Understand how COCOMO II models are used for software cost estimation

Lesson 39

  1. Understand what quality management is and why quality planning is important.
  2. Understand the various software quality attributes.
  3. Understand the concept of a quality culture and how to establish and maintain one.
  4. Understand what software standards are and what they can address.
  5. Understand how software quality management differs, but still applies when using agile methods.
  6. Understand what is meant by a software metric.