
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

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 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
Outline Syllabus
SQL Database Design
Principles
- Modelling in a Realistic Scenario
- Relational Model and Normalisation
- SQL Database Design Using Normalisation
- Operational/transactional Systems and Business Intelligence Systems
- Concepts and Design of Data Warehouses
Principles of Information Retrieval
- Document Processing and Indexing
- Term-document Matrix and Bag-of-Words Model
- Term Weighting and Information Retrieval (IR) Models
- Performance Evaluation in a Practical Task and Relevance Judgments
NoSQL Databases
- Introduction of NoSQL Databases and Working with MongoDB
- Comparison of SQL, IR, and NoSQL paradigms
Learning & Teaching Methods
Assessment

Learning Outcomes
After completing this module, students will be expected to be able to:
1. Explain and criticise the arguments that have been advanced both for and against the possibility of artificial intelligence.
2. Explain and implement standard blind and heuristic search procedures, demonstrate an understanding of their strengths and weaknesses and of how they may be applied to solve well-defined problems.
3. Explain the operation of standard production system interpreters, and demonstrate an understanding of their relative merits.
4. Explain the operation of a range of established machine learning procedures and demonstrate an understanding of the types of problems for which they are appropriate.
5. Demonstrate an understanding of the agent-oriented approach to artificial intelligence, and explain how a multi-agent system of purely reactive agents may be built using a subsumption architecture.
Outline Syllabus
. Introduction
What AI is and is not
The debate about whether AI is possible
. Solving problems by searching
State space representation
Search trees and graphs
Blind search strategies - depth first, breadth first and iterative deepening
Heuristic search - greedy search and A* search
Hill climbing
Game playing - minimax search
Means ends analysis
Implementing search
. Using knowledge to solve problems
The importance of domain knowledge
Rule based systems
Forward chaining rule interpreters
Backward chaining rule interpreters
. Acquiring knowledge - machine learning
Decision tree induction
Neural networks - back propagation
Clustering - k means algorithm
Reinforcement learning - Q algorithm
Genetic algorithms
. Intelligent agents
Reactive v. deliberative agents
Subsumption architectures for purely reactive agents

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
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.
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.

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:
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