Computer science MSc curriculum structure
The online MSc Computer Science curriculum is made of seven compulsory 10-credit units followed by four 10-credit units selected from a range of optional choices, and ending in a 70-credit dissertation phase, totalling to 180 credits. Each unit teaches you the technical skills to develop a digital career.
The course is delivered in four phases:
- Phase 1: Foundation: This phase focusses on the core principles of computer science, including programming, software engineering and the foundations of computation, this phase provides the essential theoretical and practical knowledge for advanced study.
- Phase 2: Core Applications: In this phase you will apply the principles you learned in phase one to various computing environments.
- Phase 3: Further Applications: In this phase you will choose from a pool of optional units to further apply your knowledge in new areas of application.
- Phase 4: Dissertation: You will undertake an individual research or developmental project, applying your knowledge and skills to a piece of work that contributes to the field of computer science.
Students have between two years and three months and five years to successfully complete all of the units, including a final research-based project. Students in receipt of a Postgraduate Loan must complete the course in three years. Each 10 credit unit is 8 weeks in duration, and the units are run consecutively. Over the year, there are three short breaks – in December, April, and August.
The course begins with an induction to help you get to know the faculty team, your fellow students and the virtual online environment.
Occasionally we make changes to our programmes in response to, for example, feedback from students, developments in research and the field of studies, and the requirements of accrediting bodies. You will be advised of any significant changes to the advertised programme, in accordance with our Terms and Conditions.
Curriculum overview
Learn more about the online MSc Computer Science curriculum from Ben Ralph, Lead Director of Studies.
The MSA Computer Science Online course provides a broad understanding of a range of computer science topics with an emphasis on exploring the fundamental principles of computer science and its application in a real life setting. Beginning with the principles of programming, software engineering, and mathematical computation, it will go on to introduce you to emerging ideas in areas such as AI, human computer interaction, cybersecurity, and programming. The course comprises 13 units designed in three phases. Phase one will develop your knowledge of core principles and their application. In phase two, you will explore further the application of the principles to different computing environments. Following on from phase two, this Masters course ends with the dissertation phase, providing the opportunity for you to apply the knowledge and skills that you've acquired throughout the course in a research based dissertation project. Our course is fully online, giving you the flexibility to study around your own schedule. You will study one unit at a time in phase order with all coursework will be submitted electronically. Your course is delivered via our Virtual Learning environment and all your course materials will be available via the VLE. Each ten credit unit is 8 weeks long and your learning material will be a mix of short videos, reading, practise exercises, and independent research. A typical week might include an introductory video, reading and examples, formative coding exercises, and peer discussion forums. Some units will contain group work, but the focus is on individual activity. Your graded assignments will vary between units and could include things like coding exercises, quizzes, problem sheets, written essays, reflective reports, and video representations.
Phase 1 compulsory units
This unit introduces students to the development of computer software, including problem analysis, establishing requirements, designing, implementing, and evaluating. This is a practical unit which will set up students with the programming skills that will be used in later units.
You’ll learn to:
- Describe the design of a computer program separately from its implementation
- Explain the basic concepts of procedural and object-orientated programming in the design and implementation of computer programs
- Explain debugging and testing methods and how they contribute to robust code
- Design, construct and evaluate simple data structures and algorithms
- Plan, organise and implement program code to support reuse and maintainability of the software (project)
- Provide a critical review of software in terms of quality, design, reuse and robustness, and offer solutions to correct issues encountered
Topics covered in this unit may include (but are not limited to) the following:
- An introduction to a programming language such as Java or C
- Procedural Control: Introduction to procedural system development. Discussion of control structures: sequence, selection, iteration and recursion.
- Objects: Introduction to object-oriented system development. Introduction of objects and classes, inheritance, and polymorphism. Comparison of procedural and object programming.
- Introductions to scope and extent, abstract data types. Design methods for such systems.
In this unit, students examine how problems are analysed to create requirements specifications, how systems are designed through abstract models, how to plan, test, and maintain software, and how to organise these processes into a software life cycle. They will learn how software engineering is a collaborative process that involves conversations, not just with clients, but with fellow engineers too. Students will learn to think about the software they are producing and to build functioning teams that can work together to deliver software to clients. There will be content about implementation in general, and we will talk about program design from an object-oriented perspective.
You’ll learn to:
- Identify issues and appropriate solutions for the design and implementation of complex software problems
- Perform evaluations of design solutions to determine if they are fit for purpose
- Demonstrate an understanding of the principles of software development paradigms and their relationship to the appropriateness of an eventual software solution
- Critically evaluate and contrast contemporary software engineering paradigms for defined software engineering problems, given a set of relevant development constraints
Topics covered in this unit may include (but are not limited to) the following:
- The building blocks of software
- Software design paradigms: Waterfall, Iterative, Agile, (for example: Scrum, XP, Kanban), Test-Driven Development (TDD)
- Software engineering concepts
- Principles for engineering complex software systems
This unit will go back to the early days of computing, long before any physical machines existed which would be recognisable today as computers. Do computational problems exist which have no possible ‘method’ for solving? And when a ‘method’ exists, on which resources does it rely upon, and what is its cost? In this unit, students will learn that to answer these questions, they must investigate formally what a 'method' actually is, and appreciate its limits, as well as learn about some unsolvable problems. Students will learn some techniques that are used in many modern systems, including the core component of how compilers are able to process source code when programming. This unit also covers how formal computation models can be used to reason about the relative speed or complexity of various algorithms without needing to write any actual code.
You’ll learn to:
- Demonstrate an understanding of the fundamental models of computation and the corresponding classes of formal languages, suitably expressed
- Design and apply algorithms for specific computational problems involving languages and computational models of appropriate types (e.g. automata)
- Prove formally that some computational problems are undecidable within a particular class of computational models
- Demonstrate an understanding of the role of grammars in the context of parsing algorithms, by applying the theoretical knowledge to concrete cases
- Give upper bounds on complexities of some decidable computational problems
Phase 2 compulsory units
In this unit, which builds upon the Software Engineering 1 unit, students will further develop their understanding of the concepts and methods required for developing large software intensive systems. The main focus of this unit is to give students practical experience of software engineering as a practice. To do this, students will be undertaking a group project where they will be working in a small agile team developing software.
You’ll learn to:
- Critically evaluate and contrast contemporary software engineering paradigms for defined software engineering problems, given a set of relevant development constraints
- Compare and contrast the roles, responsibilities, benefits, and drawbacks of different team organization structures for software development, given a set of relevant development constraints
Topics covered in this unit may include (but are not limited to) the following:
- The building blocks of software
- Software design paradigms: Waterfall, Iterative, Agile, (for example: Scrum, XP, Kanban), Test-Driven Development (TDD)
- The effect of the programming language on design and implementation issues. Team structures.
Students will be introduced to cloud computing and will learn how moving to a cloud platform, particularly for databases, has many advantages but also some challenges to overcome, including legal and professional considerations.
You’ll learn to:
- Understand the nature, capture, formal description, and representation of data and its processing
- Be conversant with emerging data exchange and database developments such as big data, data mining, meta data, and the semantic web
- Critically review the migration towards cloud-based data storage in the context of its professional, legal, and ethical implications
- Practically demonstrate how programs and users can interact with databases through query languages
Topics covered in this unit may include (but are not limited to) the following:
- Data modelling methodologies such as UML and the e-r model
- Relational model, relational algebra, SQL and normalization
- Metadata, the semantic web, data exchange methods, and formats such as XML
- Datamining, big data and pattern discovery in large datasets
- Cloud-based, distributed data storage, and its professional, legal and ethical implications
This unit looks at programming from the perspective of functions. Students will be introduced to the lambda calculus, a mathematical theory developed in the 1930s, which uses functions as its main basis. Students will also discover how functions can be used as the main component within programming by developing programs using Haskell, a functional programming language. Students will explore how functional programming can create complex structures to work efficiently and robustly with minimal side effects and how recursion can be central to creating such effective code.
You’ll learn to:
- Define and explain the syntax and semantics of the lambda-calculus and its role as a model of computation
- Demonstrate the difference between reduction orders and explain their relationship with call-by-name, call-by-value, and call-by-need evaluation
- Define and explain the simply typed lambda calculus, Hindley-Milner polymorphism, and type inference
- Write programs over structured datatypes in a typed higher-order functional programming language
- Formally reason about and prove properties of functional programs using the formalism of the typed lambda-calculus
This unit gives a broad overview of some foundational topics in artificial intelligence, introducing some of the techniques that are used in this field. Students will implement theoretical knowledge in a practical way, with programming exercises to accompany many of the algorithms discussed, where students can apply these algorithms to solve new problems.
You’ll learn to:
- Demonstrate understanding of a range of AI techniques, their strengths, and their limitations
- Demonstrate understanding of the fundamentals of probability theory and its role in AI
- Apply various AI techniques to simple problems
- Understand a wide range of artificial intelligence (AI) techniques, their advantages, and their disadvantages
- Appreciate AI as a mechanism to deal with computationally difficult problems in a practical manner
- Understand the concepts of formal AI and put them into practice
- Write small to medium-sized programs for aspects of AI
- Critically evaluate state-of-the-art AI applications
Topics covered in this unit may include (but are not limited to) the following:
- Goals and foundations of AI
- Problem solving (uninformed, heuristic, and adversarial search; constraint satisfaction)
- Logical reasoning (propositional logic, first-order logic, logic programming)
- Probabilistic reasoning (probability models, Bayesian networks)
- Machine learning (possible topics include nearest-neighbour methods, reinforcement learning, neural networks)
Phase 3 optional units
Choose 40 credits of optional units to further apply your knowledge in new areas of application. These could include topics such as deep learning, cybersecurity, theory of human computer interaction and entrepreneurship.
Phase 4 compulsory units
The aims of this unit are to prepare students for their dissertation research project, giving them an advanced level of understanding of what a research project is, what the various research themes are in the Department of Computer Science at the University of Bath, and how to find and critically evaluate relevant literature. Throughout this unit, students will develop a feasible project proposal that will lead to an effective dissertation. As part of their research proposal students will need to start thinking about project methodologies and the ethical considerations needed for their project.
You’ll learn to:
- Summarise and critique research papers in Computer Science and AI
- Distinguish various research themes in the selected field with a broad understanding of suitable approaches and methodologies
- Determine which research topic they would like to work on for their dissertation
- Critically analyse and review previous work in the chosen subject area
- Create a feasible project proposal for the dissertation
- Understand the principles of structuring a dissertation
- Reason for methodological and ethical considerations of their chosen topic
Topics covered in this unit may include (but are not limited to) the following:
- Selecting an appropriate topic for a dissertation research project
- Researching relevant academic literature
- Assessing the relevance of research publications
- Assessing the quality of secondary research resources, such as web resources
- Critical analysis of research papers
- Preparation of a research proposal
Students will follow an appropriate problem-solving route, building on the detailed dissertation project proposal written in the Research Project Preparation unit. The student will analyse possible problem solutions based on an extensive literature and technological review of related research work and choose appropriate methods and approaches. This will lead to the implementation of the chosen solution, its testing and evaluation. In most cases the project will be a synthesis of both an analytical and a computational approach to solving or investigating a substantial computer science problem. However, projects will vary in style, and some may be more experimentally based, and some may be purely theoretical. A comprehensive dissertation will be submitted at the completion of the project.
After completing the research you will be able to:
- Identify the tasks to be completed in a research project, plan a scheme of work, and complete the project to a professional standard
- Conduct independent research, following the ethical principles and processes
- Assemble and create the necessary analysis, design and development tools, carry out the development of the solution of a technical problem in Computer Science, and evaluate the effectiveness of the solution against common standards of quality
- Demonstrate the successful completion of these tasks in a well-structured and coherently written dissertation, which will include a discussion of the research outcomes of the work, and future directions
- Evaluate and critique the project
This degree will give me the foundations I need in multiple areas to be able to build upon when new technology comes out. Should I wish to move from web development into security or artificial intelligence then I will already have a background in those areas to get me started and give me a jumpstart into that part of the technology industry.
Jess Crees