Software Engineering for Self-Directed Learners »

Learning outcomes

Software engineering

Can explain pros and cons of software engineering

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 modeling 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 the domain of software design

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 improve code quality using technique: avoid complicated expressions

Can improve code quality using technique: avoid deep nesting

Can improve code quality using technique: avoid long methods

Can improve code quality using technique: avoid magic numbers

Can improve code quality using technique: make the code obvious

Can improve code quality using technique: avoid premature optimizations

Can improve code quality using technique: do not 'trip up' reader

Can improve code quality using technique: practice KISSing

Can improve code quality using technique: SLAP hard

Can improve code quality using technique: structure code logically

Can improve code quality using technique: make the happy path prominent

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 improve code quality using technique: use nouns for things and verbs for actions

Can improve code quality using technique: use standard words

Can improve code quality using technique: avoid misleading names

Can improve code quality using technique: not too long, not too short

Can improve code quality using technique: use name to explain

Can explain the need for avoiding error-prone shortcuts

Can improve code quality using technique: avoid empty catch blocks

Can improve code quality using technique: delete dead code

Can improve code quality using technique: don't recycle variables or parameters

Can improve code quality using technique: use the default branch

Can improve code quality using technique: minimize code duplication

Can improve code quality using technique: minimize scope of variables

Can explain the need for commenting minimally but sufficiently

Can improve code quality using technique: do not repeat the obvious

Can improve code quality using technique: write to the reader

Can improve code quality using technique: explain what and why, not how

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

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 basic concepts of how RCS history is used

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 fork 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 PRs on GitHub

Can review and merge PRs on GitHub

Can follow Forking Workflow

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 concepts of principles