Browse by Tags: software engineering

In this session we look at how to think systematically about a problem and create a solution. We look at the definition and characteristics of an algorithm, and see how through modularisation and decomposition we can then choose a set of methods to create. We also compare this somewhat procedural approach, with the way that design works in Object Oriented Systems. We also have a brief look at codings style in Java, with the help of the Google Java Style Guide: https://google.github.io/styleguide/javaguide.html

In this session we build on inheritance and look at overriding methods and dynamic binding. Together these give us Polymorphism - the third pillar of Object Oriented Programming - and a very powerful feature that allows us to build methods that deal with superclasses, but whose calls get redirected when we pass in sub-classes.

In this session we look at the sorts of errors that occur in programs, and how we can use different testing and debugging strategies (such as unit testing and inspection) to track them down. We also look at error handling within the program and at how we can use Exceptions to manage errors in a more sophisticated way. These slides are based on Chapter 6 of the Book 'Objects First with BlueJ'

In this session we look at some of the basics of good code design, including avoiding duplication and designing for loose coupling and high cohesion.

In this session we look at the how to use noun verb parsing to try and identify the building blocks of a problem, so that we can start to create object oriented solutions. We also look at some of the challenges of software engineering, and the processes that software engineers use to meet them, and finally we take a look at some more Design Patterns that may help us reuse well known and effective solutions in our own designs.

These are slides that support the balloon debate session for Programming 1. In it we discuss the pros and cons of different languages, and discuss the current popularity of different languages and approaches

These are the resources used for the Computer Science course Programming Principles, designed to teach students the fundamentals of computer programming and object orientation via learning the Java language. We also touch on some software engineering basics, such as patterns, software design and testing. The course assumes no previous knowledge of programming, but there is a fairly steep learning curve, and students are encouraged to practice, practice, practice!

Material for Programming I Coursework 2019

Ground Controllers 8 - Inheritance.

Ground Controllers 9 - File Reader

We discuss different features of IDEs and review IDEs such as BlueJ and IntelliJ

Introduction slides to the Space Cadets optional stream for COMP1202 (Programming I)

Space Cadets Challenge 1 Report

Space Cadets Challenge 2 Review

Space Cadets Challenge 3 Review

Space Cadets Challenge 4 Review (Use Acrobat Reader for animation)

Space Cadets Challenge 5 Review

Space Cadets Challenge 6 Review

This is the coursework description for Programming I.

We take a look at the OOtumlia airlines case study on class diagrams

Event-B Model for a Dentist Appointment System

Revisit Activity and Sequence Diagrams

COMP1216 Coursework 1 for the academic year 2020-21.

Coursework 1. Requirements Analysis, Specification, and Design of a COVID vaccination tracking system

Description of Coursework 2 for COMP1216 (2020-21)

Requirement Analysis

Functional Modelling with UML Use Cases and Use Case Diagrams.

Object modelling with UML

Dynamic Modelling with UML

Modelling with Sets in Event-B

Modelling using Relations in Event-B

Model a hotel reception system in Event-B

Managing room allocation in multiple hotels in Event-B

Port Management system in Event-B

Introducing Event-B (Contexts, machines)

Modelling using Relations in Event-B - Order Pairs - Cartesian Product - Relations - Domain/Range of relations - Relational Image

Revision

Material for COMP1216 Software Modelling & Design (AY2021-22)

- "Chameleons of three colours" riddle

Coursework 2: Event-B modelling of an auction system

MULTI elevator coursework

Introduction to Advanced Software Modelling & Design

Proof-based Verification in Event-B

- Constructing Proof Trees - Inference Rules - Applying inference rules backwardly to construct proof trees

A refresher on Set Theory

- Tree file system - Transitive Closure

Debugging Models with Proof and Judgement - Strengthen Guards - Modify Actions - Strengthen Invariants - Weaken Invariants

- Abstraction & Refinement - Extension Refinement

Slides from Prof Michael Butler

Reasoning about looping programs

Introduction to Ada programming language

Verification in Dafny

Introductory slides on SPARK

Revision lecture

Exercises for Propositional Logic Proof in Rodin Platform

Exercises for Predicate Logic and Set Theory Proof in Rodin Platform

Model a Routing System using transitive closure

Fixing models using failing proofs

Exercises on Hoare Logic

Exercises on Hoare Logic in SPARK - Flow analysis - Pre-/Post-conditions - Loops: Invariants, Variants

Exercise using the Elevator System in SPARK

Some useful proof rules

This lecture about data refinement from Event-B models and generating SPARK/Ada from the model

Two lectures that introduce the idea of modelling in the large, and contrasts hard system and soft system modelling. The second lecture goes into detail on a number of specific methods for analysing a system (CATWOE and CSH) and on modelling a system (Systems Diagrams and Personas).

We illustrate the modelling activities using the SmarTaxi Case Study

This is the revision session for our Programming Principles course. We remind ourselves of the three pillars of object oriented programming, look ahead to the exam, and share some parting advice.

This is a presentation for our year one INFO1008 course of Computational Systems. It covers the need for requirements capture and the difficulty of building a specification based on user information. We present UML Use Cases and Use Case diagrams as a way of capturing requirements from the users point of view in a semi-structured way.

This presentation describes the evolution of Software Development Lifecycles (SDLCs) from the first formally proposed linear models including, the Waterfall (Royce 1970) through to iterative prototyping models (Spiral and Win-Win Spiral) and incremental, iterative models used in Agile Methods. We discuss the problems iinherent in each prpoosal and how successive models attempt to solve them.

In this session we look at how to model flow of control and interactions between components using UML Activity and Sequence Diagrams. This is an introductory session and so for Activity Diagrams we only cover branching, forks and joins and swim lanes, and for Sequence we cover lifelines, messages and returns, and alt, par and opt frames.

In this session we look at UML Class Diagrams and how they fit into both the family of UML models, and also the software engineering process. We look at some basic features of class diagrams including properties, operations, associations, generalisation, aggregation and composition.

In this lecture we cover how UML Use Cases can be used for requirements capture. We look at the anatomy of a Use Case Description, and the way in which use cases can be brought together in a use case diagram. We also look at the way that use cases can be derived from problems using noun verb analysis.

This presentation gives an overview of TIDT's development process at time of writitng in March 2016. We were and still are developing our process. It is an agile process based on DSDM and Scrum.

Building software for Web 2.0 and the Social Media world is non-trivial. It requires understanding how to create infrastructure that will survive at Web scale, meaning that it may have to deal with tens of millions of individual items of data, and cope with hits from hundreds of thousands of users every minute. It also requires you to build tools that will be part of a much larger ecosystem of software and application families. In this lecture we will look at how traditional relational database systems have tried to cope with the scale of Web 2.0, and explore the NoSQL movement that seeks to simplify data-storage and create ultra-swift data systems at the expense of immediate consistency. We will also look at the range of APIs, libraries and interoperability standards that are trying to make sense of the Social Media world, and ask what trends we might be seeing emerge.