Software Engineering for Self-Directed Learners
  • Learning Outcomes

    Software Engineering

    Can explain pros and cons of software engineering

    Requirements

    Requirements

    Can explain requirements

    Can explain non-functional requirements

    Can explain prioritizing requirements

    Can explain quality of requirements

    Gathering

    Can explain brainstorming

    Can explain user surveys

    Can explain observation

    Can explain interviews

    Can explain focus groups

    Can explain prototyping

    Can explain product surveys

    Specifying

    Can explain prose

    Can explain feature list

    Can write simple user stories

    Can write more detailed user stories

    Can use user stories to manage requirements of project

    Can explain use cases

    Can use use cases to list functional requirements of a simple system

    Can specify details of a use case in a structured format

    Can optimize the use of use cases

    Can explain glossary

    Can explain supplementary requirements

    Design

    Software Design

    Can explain what is software design

    Design Fundamentals

    Can explain abstraction

    Can explain coupling

    Can reduce coupling

    Can identify types of coupling

    Can increase cohesion

    Can explain cohesion

    Object Oriented Programming

    Can describe OOP at a higher level

    Can describe how OOP relates to the real world

    Can explain the abstraction aspect of OOP

    Can explain the encapsulation aspect of OOP

    Can explain the relationship between classes and objects

    Can explain class-level members

    Can explain the meaning of enumerations

    Can explain associations

    Can explain the meaning of navigability

    Can explain the meaning of multiplicity

    Can explain dependencies among classes

    Can explain the meaning of composition

    Can explain the meaning of aggregations

    Can explain the meaning of association classes

    Can explain the meaning of inheritance

    Can explain method overriding

    Can explain method overloading

    Can explain interfaces

    Can implement abstract classes

    Can explain dynamic and static binding

    Can explain substitutability

    Can explain OOP polymorphism

    Can explain how substitutability operation overriding, and dynamic binding relates to polymorphism

    Can answer frequently asked OOP questions

    Can combine some OOP concepts

    Modeling

    Can explain models

    Can explain how models are used

    Can identify UML models

    Can use basic-level class diagrams

    Can use intermediate-level class diagrams

    Can use advanced class diagrams

    Can use basic object diagrams

    Can explain object oriented domain models

    Can explain deployment diagrams

    Can explain component diagrams

    Can explain package diagrams

    Can explain composite structure diagrams

    Can use basic-level activity diagrams

    Can draw basic sequence diagrams

    Can draw intermediate-level sequence diagrams

    Can interpret advanced sequence diagrams

    Can explain use case diagrams

    Can explain timing diagrams

    Can explain interaction overview diagrams

    Can explain communication diagrams

    Can explain state machine diagrams

    Can explain how modelling can be used before implementation

    Can use simple class diagrams and sequence diagrams to model an OO solution

    Can use intermediate class diagram and sequence diagram concepts to model an OO design

    Architecture

    Can explain Software Architecture

    Can interpret an architecture diagram

    Can draw an architecture diagram

    Can explain architectural styles

    Can identify n-tier architectural style

    Can identify the client-server architectural style

    Can identify transaction processing architectural style

    Can identify service-oriented architectural style

    Can identify event-driven architectural style

    Can name several other architecture styles

    Can explain how architectural styles are combined

    Design Patterns

    Can explain design patterns

    Can explain design patterns format

    Can explain the Singleton design pattern

    Can apply the Singleton design pattern

    Can decide when to apply Singleton design pattern

    Can explain the Abstraction Occurrence design pattern

    Can explain the Facade design pattern

    Can explain the Command design pattern

    Can explain the Model View Controller (MVC) design pattern

    Can explain the Observer design pattern

    Can combine multiple patterns to fit a context

    Can recognize some of the GoF design patterns

    Can explain pros and cons of design patterns

    Can explain how patterns exist beyond software design domain

    Can differentiate between design patterns and principles

    Design Approaches

    Can explain multi-level design

    Can explain top-down and bottom-up design

    Can explain agile design

    Implementation

    IDEs

    Can explain IDEs

    Can explain debugging

    Code Quality

    Can explain the importance of code quality

    Can explain the importance of readability

    Can explain the need for following a standard

    Can follow simple mechanical style rules

    Can follow intermediate style rules

    Can explain the need for good names in code

    Can explain the need for avoiding error-prone shortcuts

    Can explain the need for commenting minimally but sufficiently

    Refactoring

    Can explain refactoring

    Can apply some basic refactoring

    Can decide when to apply a given refactoring

    Documentation

    Can explain the two types of developer docs

    Can distinguish between top-down and bottom up documentation

    Can explain the advantages of top-down documentation

    Can write documentation in a top-down manner

    Can explain the need for comprehensibility in documents

    Can write reasonably comprehensible developer documents

    Can write minimal yet sufficient documentation

    Can explain documentation should be minimal yet sufficient

    Can write Javadoc comments

    Can explain JavaDoc

    Can explain Markdown

    Can write documents in Markdown format

    Can explain AsciiDoc

    Error Handling

    Can explain error handling

    Can explain exceptions

    Can explain how exception handling is done typically

    Can avoid using exceptions to control normal workflow

    Can explain assertions

    Can use assertions

    Can use assertions optimally

    Can explain logging

    Can use logging

    Can explain defensive programming

    Can use defensive coding to enforce compulsory associations

    Can use defensive coding to enforce 1-to-1 associations

    Can use defensive coding to enforce referential integrity of bi-directional associations

    Can explain when to use defensive programming

    Can explain the Design-by-Contract approach

    Integration

    Can explain integration

    Can explain how integration approaches vary based on timing and frequency

    Can explain how integration approaches vary based on amount merged at a time

    Can explain how integration approaches vary based on the order of integration

    Can explain build automation tools

    Can explain continuous integration and continuous deployment

    Can combine some integration concepts

    Reuse

    Can explain software reuse

    Can explain the costs and benefits of reuse

    Can explain APIs

    Can design reasonable quality APIs

    Can explain libraries

    Can make use of a library

    Can explain frameworks

    Can differentiate between frameworks and libraries

    Can explain platforms

    Can explain cloud computing

    Can distinguish between IaaS, PaaS, and SaaS

    Quality Assurance

    Quality Assurance

    Can explain software quality assurance

    Can explain validation and verification

    Can explain code reviews

    Can explain static analysis

    Can explain formal verification

    Testing

    Can explain testing

    Can explain testability

    Can explain unit testing

    Can use stubs to isolate an SUT from its dependencies

    Can explain integration testing

    Can explain system testing

    Can explain alpha and beta testing

    Can explain dogfooding

    Can explain developer testing

    Can explain the need for early developer testing

    Can explain exploratory testing and scripted testing

    Can explain the choice between exploratory testing and scripted testing

    Can explain acceptance testing

    Can explain the differences between system testing and acceptance testing

    Can explain regression testing

    Can explain test automation

    Can semi-automate testing of CLIs

    Can explain test drivers

    Can explain test automation tools

    Can explain automated GUI testing

    Can explain test coverage

    Can explain how test coverage works

    Can explain dependency injection

    Can use dependency injection

    Can explain TDD

    Can follow TDD

    Test Case Design

    Can explain the need for deliberate test case design

    Can explain positive and negative test cases

    Can explain black box and glass box test case design

    Can explain equivalence partitions

    Can apply EP for pure functions

    Can apply EP for OOP methods

    Can explain boundary value analysis

    Can apply boundary value analysis

    Can explain the need for strategies to combine test inputs

    Can explain some basic test input combination strategies

    Can apply heuristic ‘each valid input at least once in a positive test case’

    Can apply heuristic ‘no more than one invalid input in a test case’

    Can apply multiple test input combination techniques together

    Can explain test case design for use case based testing

    Can explain test case design techniques at a higher level

    Can combine test case design techniques

    Project Management

    Revision Control

    Can explain revision control

    Can explain repositories

    Can explain saving history

    Can explain using history

    Can explain remote repositories

    Can explain branching

    Can explain DRCS vs CRCS

    Can explain forking workflow

    Can explain feature branch flow

    Can explain centralized flow

    Project Planning

    Can explain work breakdown structures

    Can explain milestones

    Can explain buffers

    Can explain issue trackers

    Can explain GANTT charts

    Can explain PERT charts

    Teamwork

    Can explain common team structures

    Process Models

    Can explain SDLC process models

    Can explain sequential process models

    Can explain iterative process models

    Can explain agile process models

    Can explain XP

    Can explain scrum

    Can explain the Unified Process

    Can explain CMMI

    Can explain process models at a higher level

    Tools

    UML

    Can explain/identify class diagrams

    Can draw UML classes

    Can interpret simple associations in a class diagram

    Can interpret association navigabilities in class diagrams

    Can explain/use association roles in class diagrams

    Can explain/use association labels in class diagrams

    Can explain what is the multiplicity of an association

    Can use dependencies in a class diagram

    Can show an association as an attribute

    Can interpret enumerations in class diagrams

    Can interpret class-level members in class diagrams

    Can interpret association classes in class diagrams

    Can interpret composition in class diagrams

    Can interpret aggregation in class diagrams

    Can interpret class inheritance in class diagrams

    Can interpret abstract classes in class diagrams

    Can interpret interfaces in class diagrams

    Can explain/identify object diagrams

    Can draw UML objects

    Can interpret simple associations among objects

    Can explain/identify sequence diagrams

    Can interpret sequence diagrams with basic notation

    Can interpret sequence diagrams with object creation

    Can interpret sequence diagrams with object deletion

    Can interpret sequence diagrams with loops

    Can interpret sequence diagrams with self invocation

    Can interpret sequence diagrams with alternative paths

    Can interpret sequence diagrams with optional paths

    Can interpret sequence diagrams with parallel paths

    Can interpret sequence diagrams with reference frames

    Can interpret sequence diagrams with minimal notation

    Can explain activity diagrams

    Can interpret linear paths in activity diagrams

    Can interpret alternate paths in activity diagrams

    Can interpret parallel paths in activity diagrams

    Can use rakes in activity diagrams

    Can explain swimlanes in activity diagrams

    Can use UML notes

    Can specify constraints in UML diagrams

    Can distinguish between class diagrams and object diagrams

    Intellij IDEA

    Can setup a project in an IDE

    Can navigate code effectively using IDE features

    Can use some useful IDE productivity shortcuts

    Can step through a program using a debugger

    Can use automated refactoring features of the IDE

    Git and GitHub

    Can create a local Git repo

    Can commit using Git

    Can set Git to ignore files

    Can tag commits using Git

    Can load a specific version of a Git repo

    Can use Git to stash files

    Can clone a remote repo

    Can pull changes from a repo

    Can push to a remote repo

    Can use Git branching

    Can use Git to resolve merge conflicts

    Can create PRs on GitHub

    Can review and merge PRs on GitHub

    Can follow Forking Workflow

    Java

    Can use Java Collections

    Can use Java enumerations

    Can use Java varargs feature

    Can use JavaFX to build a simple GUI

    Can use Java8 streams

    JUnit

    Can use simple JUnit tests

    Can use intermediate features of JUnit

    Principles

    SE Principles

    Can explain single responsibility principle

    Can explain interface segregation principle

    Can explain Liskov Substitution Principle

    Can explain dependency inversion principle (DIP)

    Can explain open-closed principle (OCP)

    Can explain SOLID Principles

    Can explain separation of concerns principle

    Can explain the Law of Demeter

    Can explain Brooks' law

    Can explain YAGNI principle

    Can explain DRY principle

    Can combine some principles concepts