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.
C# Beginners Tutorial: A C# video tutorial series of 200 videos that start from the basics and also cover Windows Forms (i.e. GUI programming).
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

Design principles and guidelines considered in this course

While we encourage you to explore the vast array of principles, guidelines and refactoring techniques that exist out there, you should at least consider the following:

Further, you should of course also exercise basic "housekeeping" of your code:

Indent properly.
Be consistent in the "style" you write code (e.g. whitespace, cuddled curly-brackets, etc.).
Use sensible variable names.
Never leave old commented code.
Never leave "dead" code.

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?(Note that many have argued that this pattern is an anti-pattern)
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.