-- Main.jens - 24 Feb 2019

Times and Venues

When Where What
Monday 11:00 - 12:00 CO242 (COTTON) Tutorial
Monday 12:00 - 13:00 CO219 (COTTON) Tutorial
Monday 14:10 - 15:00 TTRLT1 (Te Toki a Rata) Lecture
Wednesday 12:00 - 14:00 CO261 (COTTON) Office Hours Jens
Wednesday 14:10 - 15:00 TTRLT1 (Te Toki a Rata) Lecture
Friday 11:00 - 12:00 CO219 (COTTON) Tutorial
Friday 14:10 - 15:00 MCLT102 (Maclaurin) Lecture

Topics by Week (tentative)

Introduction: The Problem with Software (Week 1)
We will discuss some of the challenges the software industry is currently facing, focusing on the need to manage change, and the problems caused by the increasing complexity of software as it does change. This discussion is used as motivation, and to define the scope, for the remainder of this course. slides Jens
Capturing Requirements (Week 2)
We will discuss how to capture and document requirements using the following techniques and models: use cases, user stories, test-driven and behaviour driven development. Those discussions will be focused on two aspects: how to remove ambiguity from requirements through communication with end users (in order to built the right system), and how particular techniques facilitate traceability of system features to requirements (in order to ensure a minimal system is built, avoiding feature creep). slides Jens
Architecture (Weeks 3-4)
We discuss the high-level structure of a software system, the different views stakeholders have, and the models representing those views. The focus will be on the concept of (de)composition: an architecture describes how a system is composed from parts. Component diagrams will be used to document composition. Several popular architectural patterns are discussed, including layered, component-based and service-oriented architectures. A case study on the impedance mismatch between relational databases and object-oriented programs illustrates the complexity of interfaces between parts of a system. We will introduce some lightweight tools that can be used to reverse-engineer and assess the architecture of a system. slides Jens
Don't be a git (Week 5)
On Monday and Friday, we'll discuss source code control systems. On Monday we'll outline the history of code control, and introduce git basics, and on Friday we'll look at the use of git in rather more detail. On Wednesday there will be a guest lecture: Tim Wright, Software Engineering For Real! mon fri
Special Lecture to Prepare Assignment 2: Logging Primer (week 6)
This is a special lecture on Monday to introduce the log4j logging framework, focusing on the design and usage. slides Jens
Process Automation (week 6)
We discuss the automation of processes: automation keeps the per-iteration costs down, and is therefore a key aspect of modern agile software engineering. This part is tool-focused, using Maven and the GitLab Continuous Integration and Deployment platform. We will discuss how Maven uses a standardised IDE-independent project layout following a “convention over configuration” approach, and how it provides the backbone for additional tools to be used during automated builds via plugins. slides Jens
Web Application Design and Service-Oriented Architecture (weeks 7-9)
We introduce web server programming with Java, using JEE and the Tomcat web server. This serves as a case study for many of the concepts discussed earlier, showing a complex design that uses a contract between an application (“servlet”) and a container component. The template-based JSP domain-specific language to write web applications is introduced. We discuss how modern web applications have evolved to interactive one-page applications (using AJAX and related technologies), and how this has then developed into a modern service-oriented approach where applications both provide and consume web services specified by APIs. Several protocols, data formats and standards used in this technology stack such as HTTP, JSON and OpenAPI are discussed. slides part1
Software Quality Assurance (week 10)
We discuss different approaches to software quality assurance, including static and dynamic program analysis methods, and their tradeoffs. The focus is on automated regression testing, but we also discuss static analysis, logging, monitoring and profiling. Metrics to assess test quality (coverage) and approaches to test components within complex dependencies (mocking) are discussed. slides Jens
Components and Evolution (weeks 11-12)
We discuss core ideas of component-based software engineering, and methods how to manage the evolution of software components. This focuses on the notion of incompatible changes, and how this can affect other components. The concepts discussed in this part are illustrated using Maven's repository-based dependencies management. Semantic versioning is introduced as an approach that can be used to optimise dependency management. slides Jens


Tutorial 1: Getting started with Maven details
Tutorial 2: Tests as Specification details
Tutorial 3: Log4J details
Tutorial 4: Servlets details
Tutorial 5: HTTP Services details