This is your first assignment. It is a java console application, whose specification is presented here. A useful working pattern over the next few weeks would be to complete each lab, and and then evaluate the specification (and the project of the lab) and see where you need to go with it.

The specification for Assignment 2. Also a console application, with interesting features and deployment scenarios. As with Assignment 1, the labs will directly support various aspects of the specification.

When submitting your project, please review this self-evaluation - and complete the form as outlined. A PPTX version of this form/presentation can be downloaded from the Exercises section of Lab 12.

An introduction to the lecturers, the structure and delivery of the module, assignment structure and submission, etc.

The term 'Paradigm' is sometimes used to attempt to encapsulate a mind-set associated with different movements in programming. Here we try to characterise what this means, and walk though some of the paradigms, old and new, in the field.

The history of programming languages is a facinating and continually evolving discipline. We briefly review alternative 'forces' shaping this evolution, as well as inspecting the programming 'family tree'.

Having reviewed programming languages in general, we will walk through an extended example, exploring alternatives expressions of the same programme. This may yield some insights into current programming notations trends.

The java programming language is a mature, well understood language that powers many enterprises and public web applications. Originally design for the consumer electronics market, it was quickly adopted as general purpose, versatile language relatively easy to learn and master.

The core syntax of Java is from the 'C' Family of languages, sharing many of the lexical conventions and structures of C, C++. C# and Go. The array syntax deviates a little however.

Classes are the fundamental abstraction in the language. Understanding their structure, layout and semantics is essential. In particular a clear understanding of the difference between static and regular attributes & methods + the role of the Object pseudo class is essential.

The set of control statements are largely inherited from C and C++. There are small number of these and their structure and behaviour is largely unsurprising.

Behind the language are a set of well-understood principles. These principles are independent of Java, but underpin its structure and meaning. Understanding these principles is important and is a useful starting point for comparing Java and the features of other programming languages.

Object Oriented thinking has consistently placed the inheritance relationship as a key feature of its approach. We review how this relationship is realized in Java. As you will see it is a complex relationship, and we will return to the difficulties it can cause in a later topic.

interfaces & Interface inheritance are considered a 'safer' form of inheritance. We review interfaces in general and how interface inheritance operates

All programming languages will have support for a range of common data structures. Unlike many dynamic programming language, collections are implemented as a standard library in Java. We will survey the major features of this library, focusing on the principle interfaces and implementations.

Review generic Collections and typical collection usage patterns. Summarize primary collection review performance issues. There is considerable more to collections, which should may investigate independently.

At the heart of the JDK are object I/O and Serialization capabilities, packaged into a comprehensive library for managing the life cycle of simple objects. Although the approach taken by this particular base library has to some extent been superseded by other approaches, it remains an important and influential technical approach, that can be usefully applied in simpler standalone applications.

Test Driven Development has been among the most influential approaches in recent software engineering history. Here we look at its origins, principles and some of the important benefits of the approach.

The essential elements of TDD are fairly easy to grasp. The support libraries (xUnit) are relatively straightforward, and we can expect our IDE to provide direct assistance to using these libraries. Here we look at the facilities Eclipse provides to the JUnit library.

Earlier JUnit libraries relied on Inheritance and specific design patterns to integrate the unit tests into runnable test suites. Modern JUnit relies on Java Annotations - which simplify test structure and enable more flexible structuring of tests classes.

One way of becoming familiar with TDD is to explore some simple examples of various strategies that might be employed in some simple examples. Here we look the evolution of a simple Stack class.

Another worked example, this time a simple video player manager class. These examples give us a feel for simple strategies in evolving unit tests.

We try to apply some of these practices to the Pacemaker app we are building the labs. In general many of the tests are straightforward, however there are some subtleties in the serializer tests.

Dealing with unexpected events and errors is usually delegated to the Exceptions mechanism in Java. Here we review the nature of exceptions and identify some best practices when dealing with exceptions generated from libraries and frameworks.

An introduction to DevOps (combining Development and Operations) in the Java Development Landscape.

Building and deploying Java applications can be a source of considerable complexity and ad-hoc procedures. Maven is a tool than aims to standardize this process, incorporating rigorous dependency management, repository structure and project layout best practices.

Using maven in practice will involve bootstrapping a project from scratch. With a basic example, we will step through this process.

A review of the basic structure of JUnit based tests, elaborating on the primary assert calls and annotations.

Guidelines for Composing Tests phrased using the acronym: - Right, Boundary, Inverse, Cross-check, Errors & Performance.

Understanding the evolution of the Java language through the exploration of the key features added in JDK8 and JDK9.

More TDD guidelines - this time the acronym is Conformance, Ordering, Range, Reference, Existing, Cardinality, Time.

A review of the SOLID Principles - their origin and general purpose.

SRP is a simple yet effective guideline for determining the core features of a class. It is the first of the SOLID principles.

THe second of the "SOLID" principles: "Software Entities should be open for extension but closed for modification"

HTTP is the heartbeat of the Web, and the key protocol through with both applications and services communicate. A general understanding of it is a key part of a developers knowledge base.

A short introduction to the nature and structure of APIs on the web.

An Application Programmer Interface is the published set of http endpoints and messages that a service can support. API design and implementation is a rich field of study - here we take a general overview.

Javalin is a lightweight framework for composing REST APIs in Java.

Another of the SOLID principles - this time a more subtle take on inheritance, emphasizing the core behaviours expected by the relationship.

An exploration of a fragile base class example; a common problem with implementation inheritance.

Guidelines for Composing Tests phrased using the acronym: - Fast, Isolate, Repeatable, Self-Validating, Timely

Here we introduce you to the Kotlin Programming Language and explore it in the context of Java. We will also ready Eclipse for using Kotlin.

The fourth SOLID principle states that clients should not be forced to depend upon interface members they do not use. Instead, create multiple, smaller, cohesive interfaces.

The fifth SOLID principle states that you should "Depend on abstractions, not on concretions" i.e. design software such that various modules can be separated from each other but use an abstract layer to bind them together.

An overview of Kotlin's syntax, with particular focus on the constructs we covered in Java.

An deeper overview of Kotlin's syntax, with particular focus on collections, classes and functional programming.

A walk through the structure and features of the projects introduced in Labs 08-12

TDD is a rich and mature field, with its own literature and best practices. Here we review an attempt to capture some of this best practice into a set of higher level patterns.

One of these patterns in the 'Test Double' - and is an important subset of testing strategies. Here we review 2 test double variants: Stubs & Mock Objects.