Computer Science for Visiting Students: Courses Available

• Computer Science for Visiting Students: Courses Available
• Functional Programming
• Concurrency
• Models of Computation
• Object Oriented Programming
• Computer Graphics
• Formal Program Design
• Networks and Operating Systems
• Principles of Programming Languages
• Advanced Data Structures and Algorithms
• Compilers
• Concurrent Programming
• Numerical Analysis
• Computer Architecture
• Useful Links

Functional Programming

This is a first course in programming. You will use a programming language called Haskell, which allows programs to be viewed as mathematical functions. This makes the language very powerful, so that we can easily construct programs that would be difficult or very large in other languages. An important theme of the course is how to apply mathematical reasoning to programs, so as to prove that a program performs its task correctly, or to derive it by algebraic manipulation from a simpler but less efficient program for the same problem. You gain hands-on experience of programming through two lab exercises: the first one aims to make you acquainted with the mechanics of writing Haskell programs, and the second one tackles a more challenging programming task of simulating the world of an imaginary animal. This demonstration shows you more about this problem.

[Core course, supported by tutorials in College.]

Concurrency

Computer networks, multiprocessors and parallel algorithms, though radically different, all provide examples of processes acting in parallel to achieve some goal. All benefit from the efficiency of concurrency yet require careful design to ensure that they function correctly. The concurrency course introduces the fundamental concepts of concurrency using the notation of Communicating Sequential Processes. By introducing communication, parallelism, deadlock, live-lock, etc., it shows how CSP represents, and can be used to reason about, concurrent systems. Students are taught how to design interactive processes and how to modularise them using synchronisation. One important feature of the module is its use of both algebraic laws and semantic models to reason about reactive and concurrent designs. Another is its use of FDR to animate designs and verify that they meet their specifications.

[Core course, supported by tutorials in College.]

Models of Computation

This course introduces the classical mathematical models used to analyse computation, including finite state automata, grammars, and Turing Machines.

A computer scientist should be able to distinguish between what can be computed and what cannot. This distinction can only be made with a good scientific model of computers and computation. This course introduces the powerful idea of using a mathematical model to analyse computation.

This course describes a number of different models of computation which were proposed and analysed over the past century. Many of these models were found to be equivalent, in the sense that they allow exactly the same computations to be carried out. Other models were shown to be less powerful, but simpler to implement, and so useful for some purposes.

[Core course, supported by tutorials in College.]

Object Oriented Programming

Students attending this course are expected to acquire advanced skills in object-oriented programming and design. The course particularly focuses on the design aspects of object-oriented programming and concepts such as responsibility and collaboration analysis, and designing for change. All examples in this course are given in the Java programming language, and the design aspects are presented in UML by means of class and sequence diagrams.

All the material in this course is based on a single case study of building a vector graphics application. The course starts by specifying the application requirements, and then continues by designing the application architecture. The design is firmly grounded in the responsibility analysis of the system's components, the principle of the separation of concerns, loose coupling and high cohesion, and design by contract.

The requirements are successively modified and amended with fresh functionality such adding new graphical objects. The course analyzes how the changes in the requirements impact the system's architecture, and how the principles of object-oriented programming can be used to minimize this impact. Significant attention is paid to the role of design patterns in object-oriented design as a means of developing software architectures that are resilient to change in the requirements.

[Core course, supported by tutorials in College.]

Computer Graphics

This course is an introductory course in Computer Graphics, and covers a wide range of the field of interactive computer graphics at all levels of abstraction, and with emphasis on both theory and practice. It follows a standard textbook in the field, with additional material used to keep the course up-to-date.

[Options course, supported by centrally organised classes.]

Formal Program Design

The aim is to show how procedural programs can be developed rigorously from their mathematical specifications. In the first part, the emphasis is primarily on how to derive loops from invariants; this activity is called algorithm refinement.

The second part of the course deals with specification and data refinement. It shows how modules and systems can be specified abstractly, how algorithms can be developed using abstract datatypes, and how such abstract datatypes can be implemented using concrete datatypes, and that implementation formally justified.

[Options course, supported by centrally organised classes.]

Networks and Operating Systems

The Networks part of the course examines the science underpinning computer communications. Topics of interest will include the underlying physical media, the way data is represented, how errors in transmission can be detected and dealt with, the way information is routed over a large network, and the details of some actual network applications.

The Operating Systems part of the course aims to understand the construction and operation of a simple operating system, to discuss the principal problems to be overcome by an operating system, and structured ways of solving those problems.

[Options course, supported by centrally organised classes.]

Principles of Programming Languages

This course use interpreters written in Haskell as a vehicle for exploring various kinds of programming languages.

Practicals: Translation between recursive and iterative algorithms in a simple functional language; Semantics of a language with call-by-name and assignable variables.

[Options course, supported by centrally organised classes.]

Advanced Data Structures and Algorithms

This course introduces students to a number of highly efficient algorithms and data structures for fundamental computational problems such as primality testing, linear optimisation, and string matching. Students are also introduced to randomised algorithms and to techniques of amortised complexity analysis.

[Options course, supported by centrally organised classes.]

Compilers

A basic knowledge of Java is recommended.

This course aims to give an introduction into compiler construction, covering the main phases of compilation. Main techniques for each phase will be described in the context of modern imperative languages and some studied through practical exercises

[Options course, supported by centrally organised classes.]

Concurrent Programming

Many challenges arise during the design and implementation of concurrent and distributed programs. The aim of this course is to understand those challenges, and to see techniques for tackling them. The main paradigm to be considered is message passing concurrency, where independent processes, with private variables, interact by passing messages.

[Options course, supported by centrally organised classes.] 

Numerical Analysis

Scientific computing pervades our lives: modern buildings and structures are designed using it, medical images are reconstructed for doctors using it, the cars and planes we travel on are designed with it, the pricing of "instruments" in the financial market is done using it, tomorrows weather is predicted with it.
The derivation and study of the core, underpinning algorithm for this vast range of applications defines the subject of Numerical Analysis. This course gives an introduction to that subject.

Through studying the material of this course students should gain an understanding of numerical methods, their derivation, analysis and applicability. They should be able to solve certain mathematically posed problems using numerical algorithms. This course is designed to introduce numerical methods – i.e. techniques which lead to the (approximate) solution of mathematical problems which are usually implemented on computers. The course covers derivation of useful methods and analysis of their accuracy and applicability.

The course begins with a study of methods and errors associated with computation of functions which are described by data values (interpolation or data fitting). Following this we turn to numerical methods of linear algebra, which form the basis of a large part of computational mathematics, science, and engineering. Key ideas here include algorithms for linear equations, least squares, and eigenvalues built on LU and QR matrix factorizations. The course will also include the simple and computationally convenient approximation of curves: this includes the use of splines to provide a smooth representation of complicated curves, such as arise in computer aided design. Use of such representations leads to approximate methods of integration. Techniques for improving accuracy through extrapolation will also be described.

The course requires elementary knowledge of functions and calculus and of linear algebra. Although there are no assessed practicals for this course, the classwork will involve a mix of written work and Matlab programming. No previous knowledge of Matlab is required. Specifically, like Numerical Solution of Differential Equations, Numerical Analysis has 16 lectures, no practicals, and 7 classes per term. There will be some simple use of Matlab which will be demonstrated both in lectures and in problem classes.

[Options course, supported by centrally organised classes.]

Computer Architecture

This course aims to give an understanding of the mechanisms which implement the programmer's idealised computer. It builds on the introduction to hardware and to simple processors in the Digital hardware course, and uses Functional Programming as a tool in simulation and description.

The Computer Architecture course aims to describe a range of architectural designs and to contrast them, highlighting the design decisions they incorporate. The designs are described and analysed at the register-transfer level of abstraction. By the end of the course, the student should understand the major architectural styles and appreciate the compromises that they encapsulate. They should be able to read outline descriptions of real processors and understand more or less in which way their designs fit into the frameworks described in the course.

[Options course, supported by centrally organised classes.]

Useful Links

For more information about Computer Science at St Anne's, click here.