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