2nd Year Tutorials

Hands-on hardware: Arduino micro-controllers

The Arduino system encompasses a range of both hardware and software for electronics prototyping: the core components are a single-board hardware platform (based on an AVR processor) and a development environment (based on the Processing and Wiring programming environments). One of the most compelling features of the system as a whole is the ease with which one can interface with other physical components (e.g., sensors, motors, lights etc.); as a result, it is often used within "hardware hacking" projects. There is a documentary available which does a great job of motivating the describing the project.

The aim of this tutorial series is very open-ended: the idea is to explore Arduino (using a development kit per-student), and to apply the resulting experience to a limited but unspecified project. Example topics therefore include (but are not limited to)

Hands-on hardware: Papilio FPGAs

The aim of Papilio is somewhat similar to Arduino, in the sense it represents a "starter" kit. The major difference however, is that Papilio is even more focused on hardware development: each device houses a Xilinx Spartan 3E FPGA. Rather than a micro-controller, or processor, capable of executing the software you write, an FPGA can be reconfigured with a hardware design (roughly, a circuit).

FPGAs blur the boundary between hardware and software: they can be repeatedly reconfigured like software, but are programmed and have performance characteristics like hardware. They are commercially useful as a result (e.g., allowing a high-performance device that can be fixed or upgraded in the field), but also act as an accessible way to develop both high-performance and/or embedded solutions. Arguably, this makes them valuable to know about alongside alternatives in each case (e.g., GPU acceleration for high-performance, or micro-controllers for embedded contexts).

The aim of this tutorial series is very open-ended: the idea is to explore Papilio (using a development kit per-student), and to apply the resulting experience to a limited but unspecified project. Example topics therefore include (but are not limited to)

Introductory cryptography: side-channel and fault attacks

The security of a system, or cryptographic scheme, is often assessed in theory (or on paper) only. However, the modern attack landscape dictates this approach is extended to consider attacks that rely on features of an implementation, not just the theory. The aim of this tutorial series will be to offer a "light-weight" version of modules you might take later in your course, and cover issues such as (but not limited to)

Intermediate cryptography: an introduction to elliptic curves

Since it was invented in the late 1970s, the RSA scheme for public key encryption has been the de facto choice for most applications; this includes systems such as SSL that we all use routinely. Although RSA is fairly simply to describe, and acts as motivation for study of number theory, to ensure security it needs increasingly large key sizes (to keep pace with advances in cryptanalyis): current recommendation cites 3072-bit keys, or more, for example. This acts to make RSA less attractive, in the sense that increased key size implies an impact on efficiency.

A more modern alternative is Elliptic Curve Cryptography (ECC) which resolves some of the problems with RSA, and is increasingly used as a replacement. In addition, it acts as one example of the more generic "group-based" approach to designing cryptographic schemes.

The aim of this tutorial series is to introduce the basics of ECC, which is interesting from a number of points of view: first, from a theoretical perspective, as an example of applied number theory and state-of-the-art cryptography, and second, from a practical perspective, as an example of applied computational complexity and algorithms. Example topics include (but are not limited to)

Practical high-performance computing

The topic of High-Performance Computing (HPC) is often discussed with an implicit requirement for "exotic" hardware; for example, large super-computers. The reality is rather different in that most commodity processors now house HPC-related hardware that you can easily harness using a normal C compiler. The aim of this tutorial series is to show how this is possible: think of it as part computer architecture, part data structures and algorithms, and part advanced C programming. This is a broad topic, but the idea would be to cover (and use) some of the following technologies