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

πŸ† Can explain multi-level design

πŸ† Can explain top-down and bottom-up design

πŸ† Can explain agile design

Design Principles

πŸ† Can explain abstraction

πŸ† Can explain coupling

πŸ† Can reduce coupling

πŸ† Can identify types of coupling

πŸ† Can increase cohesion

πŸ† Can explain cohesion

πŸ† Can explain dependency inversion principle (DIP)

πŸ† Can explain open-closed principle (OCP)

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 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

πŸ† 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 explain 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 explain 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 combine some modeling concepts

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 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

Implementation

IDEs

πŸ† Can explain IDEs

πŸ† Can explain debugging

Code Quality

πŸ† Can explain the importance of code quality

πŸ† Can explain the importance of readability

πŸ† Can follow basic guidelines for improving readability

πŸ† Can follow intermediate guidelines for improving readability

πŸ† Can follow advanced guidelines for improving 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 follow basic guidelines for naming

πŸ† Can follow intermediate guidelines for naming

πŸ† Can explain the need for avoiding error-prone shortcuts

πŸ† Can follow basic guidelines for avoiding unsafe shortcuts

πŸ† Can follow intermediate guidelines for avoiding unsafe shortcuts

πŸ† Can explain the need for commenting minimally but sufficiently

πŸ† Can follow basic guidelines for writing code comments

πŸ† Can follow intermediate guidelines for writing code comments

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 do exception handling in code

πŸ† 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

OOP Implementation

πŸ† Can implement classes

πŸ† Can implement class-level members

πŸ† Can implement associations

πŸ† Can implement dependencies

πŸ† Can implement composition

πŸ† Can implement aggregation

πŸ† Can implement association classes

πŸ† Can implement basic inheritance

πŸ† Can implement operation overriding

πŸ† Can implement overloading

πŸ† Can implement interfaces

πŸ† Can implement abstract classes

πŸ† Can implement polymorphism

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 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/identify object diagrams

πŸ† Can draw UML objects

πŸ† Can interpret object diagrams

πŸ† 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 basic activity diagram notations

πŸ† 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

Supplementary

SE Principles

πŸ† Can explain single responsibility principle

πŸ† Can explain interface segregation principle

πŸ† Can explain Liskov Substitution Principle

πŸ† Can explain dependency inversion principle

πŸ† 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

Review

πŸ† Can combine software engineering concepts