Software Engineering — Study material

Please do familiarize yourself with (as much as you find necessary of) the following study material before attempting to approach the corresponding lab exercises. Naturally, all of the study material is not mandatory. However, you will notice how you greatly benefit from exploring this material.

Block 1

C# Tutorial for beginners by Venkat: A C# video tutorial series of 100 videos starting from the absolute basics.
Iterators in Java by Natan Schultz: A brief video explaining what iterators are and how they implemented and used in Java.
Iterator Design Pattern by Derek Banas: Derek Banas shows how to implement the Iterator Design Pattern in Java.

Block 2

Testing

What is test-driven development?: A 5 min video giving a high-level explanation of TDD.
Test-driven development in Visual Studio using C#: A 17 min video demonstrating how test-driven development can be carried out in C#.
A TDD pair-programming session with Roy Osherove: A 2 h video of a pair-programming session with Roy Osherove. A real-world situation resulting in real-world problems.
Triangulation in Test-driven development: A blog post about an "extremer" approach to TDD that aim to result in higher test coverage.
TDD anti-patterns: Blog post on things you "should not" do.

Refactoring

What is refactoring?: Wikipedia page

Below are a number video playlists that enact and explain some of the techniques from the great book by Martin Fowler called Refactoring.

Block 3

Design patterns

Head First Design Patterns: The course book
Design Patterns Video Tutorials by Derek Banas: Video playlist explaining design patterns through examples similar to the course book.
Applied Design Datterns video tutorials by Derek Banas: Video playlist showing how design patterns can be applied while refactoring code towards the subjectively better.

Block 4

Code Contracts

Code Contracts User Manual from Microsoft Research: A user manual from Microsoft.
.NET Code Contracts video: 27 min video about code cotracts in .NET
.NET Code Contracts Project Page: The project page for Code Contracts at Microsoft Research

Principles considered in this course

Larman's creator pattern: Are objects created in the right place?
Larman’s expert pattern: Is the responsibility to do things assigned to the correct classes?
Dependency Inversion principle: Are there dependencies between concrete system parts that may cause problems to maintain and extend the code? Could these dependencies be removed, e.g. through strategically design interfaces?
The single responsibility principle: Does every single class in the solution have a single responsibility?
Open-closed principle: Is the code possible to change without making changes to the existing code?
Interface segregation principle: Are there interfaces in the code that could be logically separated into several smaller interfaces?

Patterns considered in this course

Adapter or Facade: Do you need to make an incompatible object compatible without changing its internals?
Command: Could some part of the system benefit from encapsulating method invocation?
Composite: Can the parts be treated as the whole?
Decorator: Does any class need a change in its responsibility during runtime?
Factory: Is the system suffering from high coupling and dependencies or repetitive complex instantiation of objects?
Model View Controller: Is managing the entire system overwhelming, could MVC keep it manageable?
Observer: How is different parts of the system being notified of change in state? Could an event-driven solution be beneficial?
Proxy: Are you making complex calls to objects that could be bundled and proxied?
Singleton: Do your system need to keep track of objects from a specific type? Should the solution be simplified with just having a single object of that type?
State: Does behavior vary greatly depending on an object's state?
Strategy: Are there families of algorithms where the members are virtually interchangable?
Template method: Does an algorithm consist of recurring steps who's implementations can be deferred to subclasses.