This
module is designed to develop a range of professional skills of students
using a team project as the vehicle. Each student will work on a
project within their team given a set of attributes that the project
must contain.
The projects are based on typical industrial scenarios and incorporate the concepts of specifications, design, and implementation. Within the project, students will learn about sustainability, project and time management, design, legal issues, health and safety, data analysis and presentation, team reporting, company organisagtion, and self evaluation.
Module Directory
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Describe the processes involved in project management and produce a project management plan.
2. Use project management tools and techniques.
3. Explain and justify their team's finished product.
4. Report and reflect on their individual contribution to the team's effort.
5. Demonstrate an understanding of professional, legal and ethical issues that affect the work of professionals in their discipline.
6. Demonstrate the ability to research and use system development tools.
7. Produce a Curriculum Vitae, and cover letter.
1. Describe the processes involved in project management and produce a project management plan.
2. Use project management tools and techniques.
3. Explain and justify their team's finished product.
4. Report and reflect on their individual contribution to the team's effort.
5. Demonstrate an understanding of professional, legal and ethical issues that affect the work of professionals in their discipline.
6. Demonstrate the ability to research and use system development tools.
7. Produce a Curriculum Vitae, and cover letter.
Syllabus
The module consists of two parallel strands:
The module consists of two parallel strands:
- The major strand will consist of team project, which will be based on a simple but realistic development scenario chosen to maximise the students' experience within a collaborative group environment.
- The project will be on a topic directly relevant to the students' degree course and will typically involve developing a product through the specification and design stages.
- The second strand consists of a series of professional development lectures including topics such as project management, legal and ethical issues, accounting, entrepreneurship, communication skills (including change management), project-risk analysis and control, and careers guidance.
This module aims to equip students with the main principles guiding the activities involved in software development throughout its lifecycle, including software requirements, object-oriented analysis and design, software validation and testing, software maintenance and software evolution, and configuration management processes and tools.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Demonstrate an understanding of the principles of software engineering
2. Demonstrate an ability to carry out software requirements specification, object-oriented analysis and design, and software testing
3. Demonstrate an understanding of object orientation and relate object-oriented models to corresponding object-oriented programming constructs
4. Represent the outcome of each stage in the software lifecycle using standard modeling notations
5. Demonstrate a basic understanding of architectural styles and design patterns
6. Demonstrate an understanding of software reliability issues
Outline Syllabus
- Introduction to software engineering
- Lifecycle models
- Software modeling notations
- Requirements analysis and specification
- Principles of software design
- Functional and non-functional requirements and the need to verify and validate them through a variety of techniques
- Principles of object-oriented design
- Introduction to design patterns and architectural styles
- Validation and testing, including unit testing, and testing against requirements
- Software reliability and quality
- Evolution and maintenance
- Configuration management processes and tools
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Demonstrate an understanding of the principles of software engineering
2. Demonstrate an ability to carry out software requirements specification, object-oriented analysis and design, and software testing
3. Demonstrate an understanding of object orientation and relate object-oriented models to corresponding object-oriented programming constructs
4. Represent the outcome of each stage in the software lifecycle using standard modeling notations
5. Demonstrate a basic understanding of architectural styles and design patterns
6. Demonstrate an understanding of software reliability issues
Outline Syllabus
- Introduction to software engineering
- Lifecycle models
- Software modeling notations
- Requirements analysis and specification
- Principles of software design
- Functional and non-functional requirements and the need to verify and validate them through a variety of techniques
- Principles of object-oriented design
- Introduction to design patterns and architectural styles
- Validation and testing, including unit testing, and testing against requirements
- Software reliability and quality
- Evolution and maintenance
- Configuration management processes and tools
This module extends the student's knowledge and skills in object-oriented application programming by a treatment of further Java language principles and of important Application Programming Interfaces (APIs). The Java Collections API is explored in some detail with emphasis on how to utilise these classes to best effect. Students will also be introduced to third-party APIs, since an important part of application programming is the process of understanding and using such APIs. The module will give students core programming skills that are required for Years 2 and 3 of the Computer Science degree schemes.
Learning Outcomes
After completing this module, students will be expected to be able to:
Outline Syllabus
Application Programming and APIs
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Demonstrate
knowledge of core Java application libraries.
2. Explain
the event-driven model underlying Java GUIs.
3. Write
Java programs with interactive graphical user interfaces (GUIs).
4. Demonstrate
knowledge of how Java programs interact with databases.
5. Write
Java programs that make efficient use of the Java collections package.
6. Demonstrate
an understanding of design patterns appropriate to Java GUIs.
Outline Syllabus
- Java Language
- Review of inheritance, abstract classes and interfaces
- Exceptions
- Generics
Application Programming and APIs
- The Collections framework
- User interface programming with AWT and Swing, event handling
- Relational database interfacing with JDBC
- Object serialization and object databases
This module extends the student's knowledge and skills in object-oriented application programming by a treatment of further Java language principles and of important Application Programming Interfaces (APIs). The Java Collections API is explored in some detail with emphasis on how to utilise these classes to best effect. Students will also be introduced to third-party APIs, since an important part of application programming is the process of understanding and using such APIs. The module will give students core programming skills that are required for Years 2 and 3 of the Computer Science degree schemes.
Learning Outcomes
After completing this module, students will be expected to be able to:
Outline Syllabus
Application Programming and APIs
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Demonstrate
knowledge of core Java application libraries.
2. Explain
the event-driven model underlying Java GUIs.
3. Write
Java programs with interactive graphical user interfaces (GUIs).
4. Demonstrate
knowledge of how Java programs interact with databases.
5. Write
Java programs that make efficient use of the Java collections package.
6. Demonstrate
an understanding of design patterns appropriate to Java GUIs.
Outline Syllabus
- Java Language
- Review of inheritance, abstract classes and interfaces
- Exceptions
- Generics
Application Programming and APIs
- The Collections framework
- User interface programming with AWT and Swing, event handling
- Relational database interfacing with JDBC
- Object serialization and object databases
Aims
Data structures and algorithms lie at the heart of Computer Science as they are the basis for the efficient solution of programming tasks. In this module, students will study core algorithms and data structures, as well as being given an introduction to algorithm analysis and basic computability.
The module will give students core algorithmic skills that are required for Years 2 and 3 of the Computer Science degree schemes.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Demonstrate an understanding of core data types such as stacks, queues, trees, and graphs.
2. Implement core data types in Java and write programs that make efficient use of them.
3. Reason about the time and space complexity of programs.
4. Demonstrate knowledge of commonly used algorithms.
5. Explain the main concepts of computability and how some problems have no algorithmic solution.
Syllabus
Data types
Abstract data types
Lists, stacks, queues, trees, sets, graphs
Algorithms
Divide and conquer
Sorting and searching
Algorithms: binary search trees, minimum cost spanning trees, shortest paths, parse trees
Algorithm analysis: time and space complexity
Basic computability, incomputable functions and the halting problem
Data structures and algorithms lie at the heart of Computer Science as they are the basis for the efficient solution of programming tasks. In this module, students will study core algorithms and data structures, as well as being given an introduction to algorithm analysis and basic computability.
The module will give students core algorithmic skills that are required for Years 2 and 3 of the Computer Science degree schemes.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Demonstrate an understanding of core data types such as stacks, queues, trees, and graphs.
2. Implement core data types in Java and write programs that make efficient use of them.
3. Reason about the time and space complexity of programs.
4. Demonstrate knowledge of commonly used algorithms.
5. Explain the main concepts of computability and how some problems have no algorithmic solution.
Syllabus
Data types
Abstract data types
Lists, stacks, queues, trees, sets, graphs
Algorithms
Divide and conquer
Sorting and searching
Algorithms: binary search trees, minimum cost spanning trees, shortest paths, parse trees
Algorithm analysis: time and space complexity
Basic computability, incomputable functions and the halting problem
Module Description
The aims of this module are to extend the principles of SQL database modelling laid down in the first year, to describe the field of Information Retrieval, to introduce the concept of NoSQL databases and hence to compare the strengths and weaknesses of all three approaches to information access.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Understand SQL database modelling and normalisation;
2. Appreciate the principles of Information Retrieval;
3. Apply and evaluate IR in a practical context;
4. Discuss differences between models such as SQL, IR and NoSQL.
Outline Syllabus
SQL Database Design Principles
- Entity Relationship Modelling
- Normalisation
- Modelling in a Realistic Scenario
Principles of Information Retrieval
- Term Weighting Models
- Word Frequency, Stemming and Stoplists
- Inverted Indexing, TF*IDF and OKAPI
- Implementation of Phrase and Wildcard Searches
- Performance Evaluation in a Practical Task
Introduction to NoSQL Databases
Comparison of SQL, IR and NoSQL paradigms
Learning & Teaching Methods
Lectures, Laboratories and Classes
Assessment
This module is 70% Exam and 30% Coursework
Aims
The aim of this module is to provide an understanding of the principles that underlie the design of web applications, and to provide practical experience of the technologies used in their construction.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Design and implement HTML and JavaScript form-based input systems.
2. Write Java Server Pages (JSPs) and Java classes that implement key web application components (e.g. a shopping basket for an on-line shop).
3. Use appropriate techniques to manage session state.
4. Design and implement data models, databases and data bound classes to support web applications.
Syllabus
Overview of E-commerce technologies
Client side: HTML, Java Applets, Javascript, Cascading Stylesheets
Server side: Web servers
Serving dynamic content
Java servlets, Java Server Pages (JSP)
XML
Web-based User Interface Design
HTML form elements
Designing form-pages
Using JQuery
Limitations of HTML forms
JavaScript and the Document Object Model
Example JavaScript input components
JSP and Java Servlets
The servlet API and Lifecycle
A hello-world servlet
Servlet input and output streams
Reading parameters and posted data
Session tracking with URL encoding and Cookies
Techniques for dynamic generation of HTML
Enhancing web applications with Ajax
Databases for web applications
Data modelling for e-commerce applications
XML
Reasons for using XML
Syntax of well-formed XML documents
Validating XML with DTDs
Designing XML document structures
The aim of this module is to provide an understanding of the principles that underlie the design of web applications, and to provide practical experience of the technologies used in their construction.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Design and implement HTML and JavaScript form-based input systems.
2. Write Java Server Pages (JSPs) and Java classes that implement key web application components (e.g. a shopping basket for an on-line shop).
3. Use appropriate techniques to manage session state.
4. Design and implement data models, databases and data bound classes to support web applications.
Syllabus
Overview of E-commerce technologies
Client side: HTML, Java Applets, Javascript, Cascading Stylesheets
Server side: Web servers
Serving dynamic content
Java servlets, Java Server Pages (JSP)
XML
Web-based User Interface Design
HTML form elements
Designing form-pages
Using JQuery
Limitations of HTML forms
JavaScript and the Document Object Model
Example JavaScript input components
JSP and Java Servlets
The servlet API and Lifecycle
A hello-world servlet
Servlet input and output streams
Reading parameters and posted data
Session tracking with URL encoding and Cookies
Techniques for dynamic generation of HTML
Enhancing web applications with Ajax
Databases for web applications
Data modelling for e-commerce applications
XML
Reasons for using XML
Syntax of well-formed XML documents
Validating XML with DTDs
Designing XML document structures
Module Description
The aim of this module is to provide an introduction to the C++ programming language. The contents covered by this module
include three parts: (1) basic concepts and features of C++ programming (e.g., operator overloading),
(2) C++ Standard Template Library, and (3) inheritance, function overriding and exceptions.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Explain the basic concepts and features of C++.
2. Describe the underlying memory model and explain the role of the execution stack and the heap.
3. Write object oriented programs that incorporate basic C++ features such as pointer, reference, inheritance, function overriding, operator overloading, exceptions, etc.
4. Make effective use of the C++ Standard Template Library.
Outline Syllabus
Overview
- paradigms: procedural + object-oriented vs purely object-oriented
- pointers and references
- C++ functions: call by value and call by reference
- class definition
- memory management
- the C++ Standard Template Library
A model of memory
- static and dynamic memory
- the execution stack: existence of local variables, parameter passing
- the heap: dynamic memory allocation
- memory management in C++
C++ language features
- pointers: declaring and using pointer variables, the operator *
- references: declaring and using reference variables, the operator &
- functions: call by value and call by reference, function overloading
- arrays: array identifiers, static and dynamic arrays, arrays as parameters, arrays as results
- class definition: private and public members
- inheritance
- function overriding (polymorphism)
- operator overloading
- constructors, destructors, copy constructors and the assignment operator
This course considers security as it relates to a single computer at an introductory level. Cryptography is introduced and the various scenarios that involve encryption and authentication are investigated. There will be practical work that will give students an opportunity to explore key security tools. The management and planning issues are covered in policy and risk management.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Identify and describe common security vulnerabilities.
2. Describe the nature of malicious code and how it can spread, be identified and removed.
3. Compare the performance of various cryptographic schemes.
4. Explain the principles of risk analysis and use risk analysis to select controls.
Outline Syllabus
Principles of security
- Confidentiality, integrity and availability (CIA)
- Vulnerabilities, threats, controls
- Forensics and recovery of systems
Secure Applications
- Common problems in applications
- Detailed example of stack based buffer overflow
Malware and malicious code
- Viruses, trojans, worms
- History and classification
- Anatomy of a virus and how viruses spread
- Identifying viruses and antivirus software
Cryptography
- Applications of encryption to computer security
- Types of encryption algorithms
- Examples of encryption algorithms commonly used
- Public-key cryptography
User authentication
-Methods of user authentication
-Biometric access control (e.g. fingerprint, iris etc.)
-Other techniques (e.g. smartcard)
Security policy
-Example security policy
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Identify and describe common security vulnerabilities.
2. Describe the nature of malicious code and how it can spread, be identified and removed.
3. Compare the performance of various cryptographic schemes.
4. Explain the principles of risk analysis and use risk analysis to select controls.
Outline Syllabus
Principles of security
- Confidentiality, integrity and availability (CIA)
- Vulnerabilities, threats, controls
- Forensics and recovery of systems
Secure Applications
- Common problems in applications
- Detailed example of stack based buffer overflow
Malware and malicious code
- Viruses, trojans, worms
- History and classification
- Anatomy of a virus and how viruses spread
- Identifying viruses and antivirus software
Cryptography
- Applications of encryption to computer security
- Types of encryption algorithms
- Examples of encryption algorithms commonly used
- Public-key cryptography
User authentication
-Methods of user authentication
-Biometric access control (e.g. fingerprint, iris etc.)
-Other techniques (e.g. smartcard)
Security policy
-Example security policy
This course considers security as it relates to a single computer at an introductory level. Cryptography is introduced and the various scenarios that involve encryption and authentication are investigated. There will be practical work that will give students an opportunity to explore key security tools. The management and planning issues are covered in policy and risk management.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Identify and describe common security vulnerabilities.
2. Describe the nature of malicious code and how it can spread, be identified and removed.
3. Compare the performance of various cryptographic schemes.
4. Explain the principles of risk analysis and use risk analysis to select controls.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Identify and describe common security vulnerabilities.
2. Describe the nature of malicious code and how it can spread, be identified and removed.
3. Compare the performance of various cryptographic schemes.
4. Explain the principles of risk analysis and use risk analysis to select controls.
Module Definition
This
module introduces students to more advanced programming constructs and
techniques and build on their knowledge from the first two years. This
will include a review of Java, Threads and synchronisation, File I/O
sockets, client/server, JSON and web services.
Aims
The aim of this module is to introduce the students to more advanced programming constructs and techniques.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Demonstrate an understanding of the programming constructs and techniques introduced to this module; and
2. Use these constructs and techniques in the design and implementation of programs
3. Critically reflect on program designs.
Outline Syllabus
. Java Review
. Threads and synchronisation
. File I/O, sockets and client/server
. JSON and web services
. Collections
. Streams
. Recursion and program optimisation
. Design patterns
. Introduction to functional programming in Haskell
. Miscellaneous
Aims/ Learning Outcomes
The aim of this module is to introduce the students to formal languages and compilers.
After completing this module, students will be expected to be able to:
1. Demonstrate an understanding of formal languages
2. Describe formal languages using BNF notation
3. Explain the link between finite state automata and regular expressions
4. Describe the syntax and semantics of basic programming language elements
5. Demonstrate an understanding of the structure of compilers and their main components
6. Implement key parts of a compiler for a simple language
Syllabus
Introduction to formal languages
-Regular and context-free grammars
-Backus-Naur Form notation (BNF)
-Finite state automata
-Introduction to compilers
-Syntax and semantics of basic programming languages elements
-Lexical analysis
-Parsing
-Static analysis
-Code Generation
As humans we are adept in understanding the meaning of texts and conversations. We can also perform tasks such as summarize a set of documents to focus on key information, answer questions based on a text, and when bilingual, translate a text from one language into fluent text in another language. Natural Language Engineering (NLE) aims to create computer programs that perform language tasks with similar proficiency.
This course provides a strong foundation to understand the fundamental problems in NLE and also equips students with the practical skills to build small-scale NLE systems. Students are introduced to three core ideas of NLE: a) gaining an understanding the core elements of language--- the structure and grammar of words, sentences and full documents, and how NLE problems are related to defining and learning such structures, b) identify the computational complexity that naturally exists in language tasks and the unique problems that humans easily solve but are incredibly hard for computers to do, and c) gain expertise in developing intelligent computing techniques which can overcome these challenges.
The aim of this module is to introduce key ideas and techniques used in the design and implementation of natural language engineering applications. We will primarily cover statistical methods, and will look at the use of such methods in applications.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Describe and formalize how language problems can be solved computationally.
2. Understand and implement techniques for language modelling, speech tagging, and syntactic parsing.
3. Understand and implement techniques for computational semantics and discourse processing.
4. Understand, implement and use algorithms such as Viterbi decoding, and basic supervised classification.
5. Understand how NLE techniques can be used to design and implement applications such as text summarization, sentiment analysis and writing quality prediction.
Outline Syllabus
Language models
Topic classification and topic modeling
Part-of-speech tagging
Sentiment analysis and text classification
Lexical semantics
NLE applications such as text summarization, and identifying writing quality
This course provides a strong foundation to understand the fundamental problems in NLE and also equips students with the practical skills to build small-scale NLE systems. Students are introduced to three core ideas of NLE: a) gaining an understanding the core elements of language--- the structure and grammar of words, sentences and full documents, and how NLE problems are related to defining and learning such structures, b) identify the computational complexity that naturally exists in language tasks and the unique problems that humans easily solve but are incredibly hard for computers to do, and c) gain expertise in developing intelligent computing techniques which can overcome these challenges.
The aim of this module is to introduce key ideas and techniques used in the design and implementation of natural language engineering applications. We will primarily cover statistical methods, and will look at the use of such methods in applications.
Learning Outcomes
After completing this module, students will be expected to be able to:
1. Describe and formalize how language problems can be solved computationally.
2. Understand and implement techniques for language modelling, speech tagging, and syntactic parsing.
3. Understand and implement techniques for computational semantics and discourse processing.
4. Understand, implement and use algorithms such as Viterbi decoding, and basic supervised classification.
5. Understand how NLE techniques can be used to design and implement applications such as text summarization, sentiment analysis and writing quality prediction.
Outline Syllabus
Language models
Topic classification and topic modeling
Part-of-speech tagging
Sentiment analysis and text classification
Lexical semantics
NLE applications such as text summarization, and identifying writing quality
Module Description
This
module provides students with a working knowledge of modern software
development techniques for large software systems gained through a
series of lectures, a 6-week team project and hands-on laboratories.
Aims
The aim of this course is to provide students with a working knowledge of modern software development techniques for large software systems.
Learning Outcomes
Upon completion of this course students will be able to
1. Understand the issues involved in large-scale software development and how they can be managed with modern practices, techniques and tools
2. Make effective use of modern tools and techniques for the cooperative development of software including version control, ticketing systems, build tools, etc.
3. Make effective use of modern bug prevention and detection techniques as well as refactoring techniques.
4. Make use of modern practices and techniques for the effective development of software within teams
Syllabus
The course will focus on powerful technologies such as:
1. agile software development,
2. extreme programming
3. working effectively in teams,
4. revision control systems,
5. unit and acceptance testing,
6. integrated development environments,
7. build tools,
8. ticketing systems,
9. refactoring.
Module Description
This
module provides students with a working knowledge of modern software
development techniques for large software systems gained through a
series of lectures, a 6-week team project and hands-on laboratories.
Aims
The aim of this course is to provide students with a working knowledge of modern software development techniques for large software systems.
Learning Outcomes
Upon completion of this course students will be able to
1. Understand the issues involved in large-scale software development and how they can be managed with modern practices, techniques and tools
2. Make effective use of modern tools and techniques for the cooperative development of software including version control, ticketing systems, build tools, etc.
3. Make effective use of modern bug prevention and detection techniques as well as refactoring techniques.
4. Make use of modern practices and techniques for the effective development of software within teams
Syllabus
The course will focus on powerful technologies such as:
1. agile software development,
2. extreme programming
3. working effectively in teams,
4. revision control systems,
5. unit and acceptance testing,
6. integrated development environments,
7. build tools,
8. ticketing systems,
9. refactoring.