Browse by Tags: software engineering

Up a level
Export as [feed] Atom [feed] RSS 1.0 [feed] RSS 2.0
Number of items: 75.
  1. collection
    COMP1004 Programming Principles
    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!

    Shared with the World by
  2. [img] [img]
    COMP1202 - Space Cadets - 00 - Introduction
    Introduction slides to the Space Cadets optional stream for COMP1202 (Programming I)

    Shared with the University by
  3. [img] [img]
    COMP1202 - Space Cadets - 01 - Challenge 1 Review
    Review of Challenge 1 for Space Cadets

    Shared with the University by
  4. [img] [img]
    COMP1202 - Space Cadets - 02 - Challenge 2 Review
    Review of Challenge 2

    Shared with the University by
  5. [img] [img]
    COMP1202 - Space Cadets - 03 - Challenge 3 Review
    Space Cadets Challenge 3 Review

    Shared with the University by
  6. [img]
    COMP1202 - Space Cadets - 04 - Challenge 4 Review
    Review of Challenge 4 of the Space Cadets (Use Acrobat Reader for animation)

    Shared with the University by
  7. [img] [img]
    COMP1202 - Space Cadets - 05 - Challenge 5 Review
    Review of Challenge 5 for the Space Cadets

    Shared with the University by
  8. [img] [img]
    COMP1202 - Space Cadets - 06 - Challenge 6 Review
    Challenge 6

    Shared with the University by
  9. [img] [img]
    COMP1216 - A Case Study on Class Diagrams
    We take a look at the OOtumlia airlines case study on class diagrams

    Shared with the University by
  10. [img] [img]
    COMP1216 - Activity and Sequence Diagrams Revisited
    Revisit Activity and Sequence Diagrams

    Shared with the University by
  11. [img] [img]
  12. [img] [img]
  13. [img] [img]
    COMP1216 - Design Patterns
    Shared with the University by
  14. [img] [img]
  15. [img] [img]
  16. [img] [img]
  17. [img] [img]
    COMP1216 - Problem Class 1
    Requirement Analysis

    Shared with the University by
  18. [img] [img]
    COMP1216 - Problem Class 4
    Dynamic Modelling

    Shared with the University by
  19. [img] [img]
    COMP1216 - Problem Class 5
    Modelling with Sets

    Shared with the University by
  20. [img] [img]
    COMP1216 - Problem Class 9
    Shared with the University by
  21. [img] [img]
    COMP1216 - Problem class 2
    Functional Modelling

    Shared with the University by
  22. [img] [img]
    COMP1216 - Problem class 3
    Object modelling

    Shared with the University by
  23. [img] [img]
    COMP1216 - Problem class 6
    Modelling using Relations

    Shared with the University by
  24. [img] [img]
    COMP1216 - Problem class 7
    Model a hotel reception system in Event-B

    Shared with the University by
  25. [img] [img]
    COMP1216 - Problem class 8
    Managing room allocation in multiple hotels

    Shared with the University by
  26. [img]
  27. [img]
    COMP1216 - Relations in Event-B
    Modelling using Relations in Event-B - Order Pairs - Cartesian Product - Relations - Domain/Range of relations - Relational Image

    Shared with the University by
  28. [img] [img]
    COMP1216 - Revision
    Revision

    Shared with the University by
  29. [img] [img]
    COMP1216 - Solving Puzzles with Invariants
    - "Chameleons of three colours" riddle

    Shared with the University by
  30. [img] [img]
    COMP1216 - Test Design
    Shared with the University by
  31. collection
  32. [img] [img]
  33. [img] [img]
    COMP2214 - Lecture 00 - Introduction
    Introductory slides

    Shared with the University by
  34. [img]
    COMP2214 - Lecture 01 - Proof-based verification in Event-B
    Proof-based verification in Event-B

    Shared with the University by
  35. [img]
  36. [img]
  37. [img] [img]
    COMP2214 - Lecture 04 - Set Theory
    A refresher on Set Theory

    Shared with the University by
  38. [img]
    COMP2214 - Lecture 05 - Tree File
    - Tree file system - Transitive Closure

    Shared with the University by
  39. [img]
  40. [img]
  41. [img] [img]
    COMP2214 - Lecture 08 - Extension Refinement
    - Abstraction & Refinement - Extension Refinement

    Shared with the University by
  42. [img] [img]
  43. [img] [img]
  44. [img] [img]
  45. [img]
    COMP2214 - Lecture 13 - Contracts
    Slides from Prof Michael Butler

    Shared with the University by
  46. [img]
    COMP2214 - Lecture 14 - Loops
    Reasoning about looping programs

    Shared with the University by
  47. [img] [img]
    COMP2214 - Lecture 15 - Verification in Dafny
    Verification in Dafny

    Shared with the University by
  48. [img] [img]
  49. [img]
  50. [img]
  51. [img]
  52. [img]
  53. [img] [img]
    COMP2214 - Lecture 21 - Revision
    Revision lecture

    Shared with the University by
  54. [img]
    COMP2214 - Proof rules
    Some useful proof rules

    Shared with the University by
  55. [img] [img]
    COMP2214 - Tutorial 04 - Fixing models using failing proofs
    Fixing models using failing proofs

    Shared with the University by
  56. [img] [img]
  57. [img] [img]
  58. [img] [img]
  59. collection
  60. [img] [img]
  61. [img] [img]
    Introduction to Soft Systems Modelling
    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).

    Shared with the World by
  62. [img]
    Preview
    Programming Principles: Balloon Debate
    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

    Shared with the World by
  63. [img]
    Preview
    [img]
    Preview
    Programming Principles: Computational Thinking
    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

    Shared with the World by
  64. [img]
    Preview
    Programming Principles: Conclusions
    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.

    Shared with the World by
  65. [img] [img]
    Preview
    Programming Principles: Designing Applications
    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.

    Shared with the World by
  66. [img] [img]
    Preview
    Programming Principles: Polymorphism
    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.

    Shared with the World by
  67. [img] [img]
    Programming Principles: Software Design
    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.

    Shared with the University by
  68. [img] [img]
    Programming Principles: Testing and Debugging
    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'

    Shared with the University by
  69. [img]
    Preview
    Requirements Capture: Using UML Use Cases
    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.

    Shared with the World by
  70. [img]
    Preview
    Software Development Life Cycles and Process Models
    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.

    Shared with the World by
  71. [img]
    Preview
    System Design: UML Activity and Sequence Diagrams
    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.

    Shared with the World by
  72. [img]
    Preview
    System Design: UML Class Diagrams
    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.

    Shared with the World by
  73. [img]
    System Design: Using UML Use Cases
    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.

    Shared with the World by
  74. [img]
    Preview
    [img]
    TIDT's Development Process
    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.

    Shared with the World by
  75. [img]
    Preview
    The Web 2.0 Development Survival Guide
    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.

    Shared with the World by
This list was generated on Sun Aug 25 11:24:59 2019 UTC.