<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<HEAD>
<TITLE>2018/19 BSc Projects</TITLE>
<BASE HREF="https://nms.kcl.ac.uk/christian.urban/">
<script type="text/javascript" src="striper.js"></script>
<link rel="stylesheet" href="nominal.css">
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
</HEAD>
<BODY TEXT="#000000"
BGCOLOR="#4169E1"
LINK="#0000EF"
VLINK="#51188E"
ALINK="#FF0000"
ONLOAD="striper('ul','striped','li','first,second')">
<TABLE WIDTH="100%"
BGCOLOR="#4169E1"
BORDER="0"
FRAME="border"
CELLPADDING="10"
CELLSPACING="2"
RULES="all">
<TR>
<TD BGCOLOR="#FFFFFF"
WIDTH="75%"
VALIGN="TOP">
<H2>BSc Projects</H2>
<H4>Supervisor: Christian Urban</H4>
<H4>Email: christian dot urban at kcl dot ac dot uk, Office: Bush House N7.07</H4>
<H4>Note that besides being a lecturer at the theoretical end of Computer Science, I am also a passionate
<A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker</A> …
defined as “a person who enjoys exploring the details of programmable systems and
stretching their capabilities, as opposed to most users, who prefer to learn only the minimum
necessary.” I am always happy to supervise like-minded students.
</H4>
<H4>In 2013/14, I was nominated by the students
for the best BSc project supervisor and best MSc project supervisor awards in the NMS
faculty. Somehow I won both. In 2014/15 I was nominated again for the best MSc
project supervisor, but did not win it. ;o)
</H4>
<ul class="striped">
<li> <H4 id="regex">[CU1] Regular Expressions, Lexing and Derivatives</H4>
<p>
<B>Description:</b>
<A HREF="http://en.wikipedia.org/wiki/Regular_expression">Regular expressions</A>
are extremely useful for many text-processing tasks, such as finding patterns in hostile
<A HREF="https://www.snort.org">network traffic</A>,
lexing programs, syntax highlighting and so on. Given that regular expressions were
introduced in 1950 by <A HREF="http://en.wikipedia.org/wiki/Stephen_Cole_Kleene">Stephen Kleene</A>,
you might think regular expressions have since been studied and implemented to death. But you would definitely be
mistaken: in fact they are still an active research area. On the top of my head, I can give
you at least ten research papers that appeared in the last few years.
For example
<A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/regex-parsing-derivatives.pdf">this paper</A>
about regular expression matching and derivatives was presented in 2014 at the international
FLOPS conference. Another <A HREF="https://nms.kcl.ac.uk/christian.urban/Publications/posix.pdf">paper</A> by my PhD student and me was presented in 2016
at the international ITP conference.
The task in this project is to implement these results and use them for lexing.</p>
<p>The background for this project is that some regular expressions are
“<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>”
and can “stab you in the back” according to
this <A HREF="http://peterscott.github.io/2013/01/17/regular-expressions-will-stab-you-in-the-back/">blog post</A>.
For example, if you use in <A HREF="http://www.python.org">Python</A> or
in <A HREF="http://www.ruby-lang.org/en/">Ruby</A> (or also in a number of other mainstream programming languages) the
innocently looking regular expression <code>a?{28}a{28}</code> and match it, say, against the string
<code>aaaaaaaaaaaaaaaaaaaaaaaaaaaa</code> (that is 28 <code>a</code>s), you will soon notice that your CPU usage goes to 100%. In fact,
Python and Ruby need approximately 30 seconds of hard work for matching this string. You can try it for yourself:
<A HREF="http://talisker.inf.kcl.ac.uk/cgi-bin/repos.cgi/afl-material/raw-file/tip/progs/catastrophic.py">catastrophic.py</A> (Python version) and
<A HREF="http://talisker.inf.kcl.ac.uk/cgi-bin/repos.cgi/afl-material/raw-file/tip/progs/catastrophic.rb">catastrophic.rb</A>
(Ruby version). Here is a similar problem with the regular expression <code>(a*)*b</code> in Java:
<A HREF="http://talisker.inf.kcl.ac.uk/cgi-bin/repos.cgi/afl-material/raw-file/tip/progs/catastrophic.java">catastrophic.java</A>
</p>
<p>
You can imagine an attacker
mounting a nice <A HREF="http://en.wikipedia.org/wiki/Denial-of-service_attack">DoS attack</A> against
your program if it contains such an “evil” regular expression. But it can also happen by accident:
on 20 July 2016 the website <A HREF="http://stackstatus.net/post/147710624694/outage-postmortem-july-20-2016">Stack Exchange</A>
was knocked offline because of an evil regular expression. One of their engineers talks about this in this
<A HREF="https://vimeo.com/112065252">video</A>. A similar problem needed to be fixed in the
<A HREF="http://davidvgalbraith.com/how-i-fixed-atom/">Atom</A> editor.
A few implementations of regular expression matchers are almost immune from such problems.
For example, <A HREF="http://www.scala-lang.org/">Scala</A> can deal with strings of up to 4,300 <code>a</code>s in less than a second. But if you scale
the regular expression and string further to, say, 4,600 <code>a</code>s, then you get a <code>StackOverflowError</code>
potentially crashing your program. Moreover (beside the "minor" problem of being painfully slow) according to this
<A HREF="http://www.haskell.org/haskellwiki/Regex_Posix">report</A>
nearly all regular expression matchers using the POSIX rules are actually buggy.
</p>
<p>
On a rainy afternoon, I implemented
<A HREF="http://talisker.inf.kcl.ac.uk/cgi-bin/repos.cgi/afl-material/raw-file/tip/progs/re3.scala">this</A>
regular expression matcher in Scala. It is not as fast as the official one in Scala, but
it can match up to 11,000 <code>a</code>s in less than 5 seconds without raising any exception
(remember Python and Ruby both need nearly 30 seconds to process 28(!) <code>a</code>s, and Scala's
official matcher maxes out at 4,600 <code>a</code>s). My matcher is approximately
85 lines of code and based on the concept of
<A HREF="http://lambda-the-ultimate.org/node/2293">derivatives of regular expressions</A>.
These derivatives were introduced in 1964 by <A HREF="http://en.wikipedia.org/wiki/Janusz_Brzozowski_(computer_scientist)">
Janusz Brzozowski</A>, but according to this
<A HREF="https://www.cs.kent.ac.uk/people/staff/sao/documents/jfp09.pdf">paper</A> had been lost in the “sands of time”.
The advantage of derivatives is that they side-step completely the usual
<A HREF="http://hackingoff.com/compilers/regular-expression-to-nfa-dfa">translations</A> of regular expressions
into NFAs or DFAs, which can introduce the exponential behaviour exhibited by the regular
expression matchers in Python, Java and Ruby.
</p>
<p>
Now the authors from the
<A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/regex-parsing-derivatives.pdf">FLOPS'14-paper</A> mentioned
above claim they are even faster than me and can deal with even more features of regular expressions
(for example subexpression matching, which my rainy-afternoon matcher cannot). I am sure they thought
about the problem much longer than a single afternoon. The task
in this project is to find out how good they actually are by implementing the results from their paper.
Their approach to regular expression matching is also based on the concept of derivatives.
I used derivatives very successfully once for something completely different in a
<A HREF="https://nms.kcl.ac.uk/christian.urban/Publications/rexp.pdf">paper</A>
about the <A HREF="http://en.wikipedia.org/wiki/Myhill–Nerode_theorem">Myhill-Nerode theorem</A>.
So I know they are worth their money. Still, it would be interesting to actually compare their results
with my simple rainy-afternoon matcher and potentially “blow away” the regular expression matchers
in Python, Ruby and Java (and possibly in Scala too). The application would be to implement a fast lexer for
programming languages, or improve the network traffic analysers in the tools <A HREF="https://www.snort.org">Snort</A> and
<A HREF="https://www.bro.org">Bro</A>.
</p>
<p>
<B>Literature:</B>
The place to start with this project is obviously this
<A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/regex-parsing-derivatives.pdf">paper</A>
and this <A HREF="https://nms.kcl.ac.uk/christian.urban/Publications/posix.pdf">one</A>.
Traditional methods for regular expression matching are explained
in the Wikipedia articles
<A HREF="http://en.wikipedia.org/wiki/DFA_minimization">here</A> and
<A HREF="http://en.wikipedia.org/wiki/Powerset_construction">here</A>.
The authoritative <A HREF="http://infolab.stanford.edu/~ullman/ialc.html">book</A>
on automata and regular expressions is by John Hopcroft and Jeffrey Ullmann (available in the library).
There is also an online course about this topic by Ullman at
<A HREF="https://www.coursera.org/course/automata">Coursera</A>, though IMHO not
done with love.
There are millions of other pointers about regular expression
matching on the Web. I found the chapter on Lexing in this
<A HREF="http://www.diku.dk/~torbenm/Basics/">online book</A> very helpful. Finally, it will
be of great help for this project to take part in my Compiler and Formal Language module (6CCS3CFL).
Test cases for “<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>”
regular expressions can be obtained from <A HREF="http://www.haskell.org/haskellwiki/Regex_Posix">here</A>.
</p>
<p>
<B>Skills:</B>
This is a project for a student with an interest in theory and with
good programming skills. The project can be easily implemented
in functional languages like
<A HREF="http://www.scala-lang.org/">Scala</A>,
<A HREF="http://fsharp.org">F#</A>,
<A HREF="http://en.wikipedia.org/wiki/Standard_ML">ML</A>,
<A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>, etc. Python and other non-functional languages
can be also used, but seem much less convenient. If you do attend my Compilers and Formal Languages
module, that would obviously give you a head-start with this project.
</p>
<li> <H4>[CU2] Grammars and Derivative-Based Parsing Algorithms</H4>
<p>
Parsing is an old nut. Generations of software developers need to do parsing of data or text.
There are zillions of links, tools, papers and textbooks about parsing. One particular
<A HREF="https://dickgrune.com/Books/PTAPG_1st_Edition/BookBody.pdf">book</A> contains something
like 700 different algorithm, nicely analysed and described. Surely, parsing must be a solved problem. Or is it?
Laurie Tratt has a blog <A HREF="https://tratt.net/laurie/blog/entries/parsing_the_solved_problem_that_isnt.html">post</A>
about <i>Parsing: The Solved Problem That Isn't</i>. IMHO parsing is still a wide open field and not solved at all.
PEG parsing, error reporting, error correction, runtime to name just a few are aspects that seem to cause headaches
to developers, and to researchers.</p>
<p>
A recent <A HREF="https://www.cl.cam.ac.uk/~jdy22/papers/a-typed-algebraic-approach-to-parsing.pdf">paper</A>
follows an idea for regular expressions: it adapts the notion of
derivatives of regular expressions to grammars. The idea is to implement in a functional programming language
the parsing algorithm proposed in this paper and to try it out with some sample data. There is also
a recent PhD thesis about derivative-based parsing
<A HREF="https://infoscience.epfl.ch/record/287059?ln=en">Efficient Parsing with Derivatives and Zippers</A>.
</p>
<p>
<B>Literature:</B> <A HREF="https://www.cl.cam.ac.uk/~jdy22/papers/a-typed-algebraic-approach-to-parsing.pdf">paper</A>,
<A HREF="https://lara.epfl.ch/~kuncak/papers/EdelmannETAL20ZippyLLParsingDerivatives.pdf">paper</A>
</p>
<p>
<B>Skills:</B> See [CU1].
</p>
<li> <H4>[CU3] A Compiler for a small Programming Language</H4>
<p>
<b>Description:</b>
Compilers translate high-level programs that humans can read and write into
efficient machine code that can be run on a CPU or virtual machine.
A compiler for a simple functional language generating X86 code is described
<A HREF="https://libraries.io/github/chameco/Shade">here</A>.
I recently implemented a very simple compiler for an even simpler functional
programming language following this
<A HREF="https://www.cs.princeton.edu/~dpw/papers/tal-toplas.pdf">paper</A>
(also described <A HREF="https://www.cs.princeton.edu/~dpw/papers/tal-tr.pdf">here</A>).
My code, written in <A HREF="http://www.scala-lang.org/">Scala</A>, of this compiler is
<A HREF="https://nms.kcl.ac.uk/christian.urban/compiler.scala">here</A>.
The compiler can deal with simple programs involving natural numbers, such
as Fibonacci numbers or factorial (but it can be easily extended - that is not the point).
</p>
<p>
While the hard work has been done (understanding the two papers above),
my compiler only produces some idealised machine code. For example I
assume there are infinitely many registers. The goal of this
project is to generate machine code that is more realistic and can
run on a CPU, like X86, or run on a virtual machine, say the JVM.
This gives probably a speedup of thousand times in comparison to
my naive machine code and virtual machine. The project
requires to dig into the literature about real CPUs and generating
real machine code.
</p>
<p>
An alternative is to not generate machine code, but build a compiler that compiles to
<A HREF="http://www.w3schools.com/js/">JavaScript</A>. This is the language that is supported by most
browsers and therefore is a favourite
vehicle for Web-programming. Some call it <B>the</B> scripting language of the Web.
Unfortunately, JavaScript is also probably one of the worst
languages to program in (being designed and released in a hurry). <B>But</B> it can be used as a convenient target
for translating programs from other languages. In particular there are two
very optimised subsets of JavaScript that can be used for this purpose:
one is <A HREF="http://asmjs.org">asm.js</A> and the other is
<A HREF="https://github.com/kripken/emscripten/wiki">emscripten</A>. Since
last year there is even the official <A HREF="http://webassembly.org">Webassembly</A>
There is a <A HREF="http://kripken.github.io/emscripten-site/docs/getting_started/Tutorial.html">tutorial</A> for emscripten
and an impressive <A HREF="https://youtu.be/c2uNDlP4RiE">demo</A> which runs the
<A HREF="http://en.wikipedia.org/wiki/Unreal_Engine">Unreal Engine 3</A>
in a browser with spectacular speed. This was achieved by compiling the
C-code of the Unreal Engine to the LLVM intermediate language and then translating the LLVM
code to JavaScript.
</p>
<p>
<B>Literature:</B>
There is a lot of literature about compilers
(for example <A HREF="http://www.cs.princeton.edu/~appel/papers/cwc.html">this book</A> -
I can lend you my copy for the duration of the project, or this
<A HREF="http://www.diku.dk/~torbenm/Basics/">online book</A>). A very good overview article
about implementing compilers by
<A HREF="http://tratt.net/laurie/">Laurie Tratt</A> is
<A HREF="http://tratt.net/laurie/tech_articles/articles/how_difficult_is_it_to_write_a_compiler">here</A>.
An online book about the Art of Assembly Language is
<A HREF="http://flint.cs.yale.edu/cs422/doc/art-of-asm/pdf/">here</A>.
An introduction into x86 machine code is <A HREF="http://ianseyler.github.com/easy_x86-64/">here</A>.
Intel's official manual for the x86 instruction is
<A HREF="http://download.intel.com/design/intarch/manuals/24319101.pdf">here</A>.
Two assemblers for the JVM are described <A HREF="http://jasmin.sourceforge.net">here</A>
and <A HREF="https://github.com/Storyyeller/Krakatau">here</A>.
An interesting twist of this project is to not generate code for a CPU, but
for the intermediate language of the <A HREF="http://llvm.org">LLVM</A> compiler
(also described <A HREF="http://llvm.org/docs/LangRef.html">here</A>). If you want to see
what machine code looks like you can compile your C-program using gcc -S.
</p>
<p>
If JavaScript is chosen as a target instead, then there are plenty of <A HREF="http://www.w3schools.com/js/">tutorials</A> on the Web.
<A HREF="http://jsbooks.revolunet.com">Here</A> is a list of free books on JavaScript.
A project from which you can draw inspiration is this
<A HREF="http://jlongster.com/Outlet--My-Lisp-to-Javascript-Experiment">Lisp-to-JavaScript</A>
translator. <A HREF="https://bitbucket.org/ktg/parenjs/overview">Here</A> is another such project.
And <A HREF="https://github.com/viclib/liscript">another</A> in less than 100 lines of code.
<A HREF="http://en.wikipedia.org/wiki/CoffeeScript">Coffeescript</A> is a similar project
except that it is already quite <A HREF="http://coffeescript.org">mature</A>. And finally not to
forget <A HREF="http://www.typescriptlang.org">TypeScript</A> developed by Microsoft. The main
difference between these projects and this one is that they translate into relatively high-level
JavaScript code; none of them use the much lower levels <A HREF="http://asmjs.org">asm.js</A> and
<A HREF="https://github.com/kripken/emscripten/wiki">emscripten</A>.
</p>
<p>
<B>Skills:</B>
This is a project for a student with a deep interest in programming languages and
compilers. Since my compiler is implemented in <A HREF="http://www.scala-lang.org/">Scala</A>,
it would make sense to continue this project in this language. I can be
of help with questions and books about <A HREF="http://www.scala-lang.org/">Scala</A>.
But if Scala is a problem, my code can also be translated quickly into any other functional
language. Again, it will be of great help for this project to take part in
my Compiler and Formal Language module (6CCS3CFL).
</p>
<p>
<B>PS:</B> Compiler projects consistently received high marks in the past.
I have supervised eight so far and most of them received a mark above 70% - one even was awarded a prize.
</p>
<li> <H4>[CU4] Webassembly Interpreter / Compiler</H4>
<p>
Webassembly is a recently agreed standard for speeding up web applications in browsers. In this
project the aim is to implement an interpreter or compiler for webassembly. There are already
<A HREF="https://github.com/WebAssembly/spec/tree/master/interpreter">reference interpreters</A>,
but people take different views, for example implement a
<A HREF="https://groups.google.com/forum/#!topic/comp.lang.forth/CvNrP_AOmmw">Forth</A> language on top of webassembly.
What is good about webassembly is that is a rather simple format, which can be generated quite
easily, unlike Java class files, which need some head-standing when you generate them.
</p>
<p>
A <A HREF="https://github.com/WebAssembly/spec/tree/master/interpreter">reference interpreter</A> for webassembly.
</p>
<p>
<B>Skills:</B> See [CU1].
</p>
<li> <H4>[CU5] Slide-Making in the Web-Age</H4>
<p>
The standard technology for writing scientific papers in Computer Science is to use
<A HREF="http://en.wikipedia.org/wiki/LaTeX">LaTeX</A>, a document preparation
system originally implemented by <A HREF="http://en.wikipedia.org/wiki/Donald_Knuth">Donald Knuth</A>
and <A HREF="http://en.wikipedia.org/wiki/Leslie_Lamport">Leslie Lamport</A>.
LaTeX produces very pleasantly looking documents, can deal nicely with mathematical
formulas and is very flexible. If you are interested, <A HREF="http://openwetware.org/wiki/Word_vs._LaTeX">here</A>
is a side-by-side comparison between Word and LaTeX (which LaTeX “wins” with 18 out of 21 points).
Computer scientists not only use LaTeX for documents,
but also for slides (really, nobody who wants to be cool uses Keynote or Powerpoint).
</p>
<p>
Although used widely, LaTeX seems nowadays a bit dated for producing
slides. Unlike documents, which are typically “static” and published in a book or journal,
slides often contain changing contents that might first only be partially visible and
only later be revealed as the “story” of a talk or lecture demands.
Also slides often contain animated algorithms where each state in the
calculation is best explained by highlighting the changing data.
</p>
<p>
It seems HTML and JavaScript are much better suited for generating
such animated slides. This <A HREF="http://www.impressivewebs.com/html-slidedeck-toolkits/">page</A>
links to slide-generating programs using this combination of technologies.
However, the problem with all of these project is that they depend heavily on the users being
able to write JavaScript, CCS or HTML...not something one would like to depend on given that
“normal” users likely only have a LaTeX background. The aim of this project is to invent a
very simple language that is inspired by LaTeX and then generate from code written in this language
slides that can be displayed in a web-browser. An example would be the
<A HREF="https://www.madoko.net">Madoko</A> project.
</p>
<p>
This sounds complicated, but there is already some help available:
<A HREF="http://www.mathjax.org">Mathjax</A> is a JavaScript library that can
be used to display mathematical text, for example</p>
<blockquote>
<p>When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are
\(x = {-b \pm \sqrt{b^2-4ac} \over 2a}\).</p>
</blockquote>
<p>
by writing code in the familiar LaTeX-way. This can be reused.
Another such library is <A HREF="http://khan.github.io/KaTeX/">KaTeX</A>.
There are also plenty of JavaScript
libraries for graphical animations (for example
<A HREF="http://raphaeljs.com">Raphael</A>,
<A HREF="http://svgjs.com">SVG.JS</A>,
<A HREF="http://bonsaijs.org">Bonsaijs</A>,
<A HREF="http://jsxgraph.uni-bayreuth.de/wp/">JSXGraph</A>). The inspiration for how the user should be able to write
slides could come from the LaTeX packages <A HREF="http://en.wikipedia.org/wiki/Beamer_(LaTeX)">Beamer</A>
and <A HREF="http://en.wikipedia.org/wiki/PGF/TikZ">PGF/TikZ</A>. A slide-making project from which
inspiration can be drawn is <A HREF="http://maciejczyzewski.me/hyhyhy/">hyhyhy</A>.
</p>
<p>
<B>Skills:</B>
This is a project that requires good knowledge of JavaScript. You need to be able to
parse a language and translate it to a suitable part of JavaScript using
appropriate libraries. Tutorials for JavaScript are <A HREF="http://www.w3schools.com/js/">here</A>.
A parser generator for JavaScript is <A HREF="http://pegjs.majda.cz">here</A>. There are probably also
others. If you want to avoid JavaScript there are a number of alternatives: for example the
<A HREF="http://elm-lang.org">Elm</A>
language has been especially designed for implementing interactive animations, which would be
very convenient for this project. A nice slide making project done by a previous student is
<A HREF="http://www.markslides.org">MarkSlides</A> by Oleksandr Cherednychenko.
</p>
<li> <H4>[CU5A] Generation of Online Books / Online Tutorials</H4>
<p>
There are some very beautiful online books that help with displaying, explaining and running of
code. Two very noteworthy examples are <A HREF="https://www.handsonscala.com/part-i-introduction-to-scala.html">Hands-on Scala</A>
by Haoyi Li, and <A HREF="https://craftinginterpreters.com">Crafting Interpreters</A> by Robert Nystrom
(see also <A HREF="http://journal.stuffwithstuff.com/2020/04/05/crafting-crafting-interpreters/">here for the latter</A>).
They integrate many tools, like github, markdown, snippets and much more, into a whole book (sometimes online and in paper-form).
The idea would be to implement something similar (i.e. the infrastructure) on a smaller
scale. Another idea is to help with creating online tutorials - one inspiration are
the tutorials from <A HREF="https://www.grape.codes/explore">Grape.codes</A> and
the interactive video editor <A HREF="https://liqvidjs.org">here</A>.
</p>
<li> <H4>[CU6] Raspberry Pi's and Arduinos</H4>
<p>
<B>Description:</B>
This project is for true hackers! <A HREF="http://en.wikipedia.org/wiki/Raspberry_Pi">Raspberry Pi's</A>
are small Linux computers the size of a credit-card and only cost £26, the
simplest version even costs only £5 (see pictures on the left below). They were introduced
in 2012 and people went crazy...well some of them. There is a
<A HREF="https://plus.google.com/communities/113390432655174294208?hl=en">Google+</A>
community about Raspberry Pi's that has more
than 300k of followers. A similar number follow the corresponding <A HREF="https://www.facebook.com/raspberrypi/">group</A>
on Facebook. It is hard to keep up with what people do with these small computers. The possibilities
seem to be limitless. The main resource for Raspberry Pi's is <A HREF="http://www.raspberrypi.org">here</A>.
There are <A HREF="https://www.raspberrypi.org/magpi/">magazines</A> dedicated to them and tons of
<A HREF="http://www.raspberrypi.org/phpBB3/viewforum.php?f=39">books</A> (not to mention
floods of <A HREF="https://www.google.co.uk/search?q=raspberry+pi">online</A> material,
such as the <A HREF="https://www.raspberrypi.org/magpi-issues/Projects_Book_v1.pdf">RPi projects book</A>).
Google just released a
<A HREF="http://googlecreativelab.github.io/coder/">framework</A>
for web-programming on Raspberry Pi's turning them into webservers.
In my home one Raspberry Pi has the very important task of automatically filtering out
nearly all advertisments using the
<A HREF="https://github.com/pi-hole/pi-hole">Pi-Hole</A> software
(you cannot imagine what difference this does to your web experience).
</p>
<p>
<A HREF="http://en.wikipedia.org/wiki/Arduino">Arduinos</A> are slightly older (from 2005) but still very cool (see picture on the right below). They
are small single-board micro-controllers that can talk to various external gadgets (sensors, motors, etc). Since Arduinos
are open-software and open-hardware there are many clones and add-on boards. Like for the Raspberry Pi, there
is a lot of material <A HREF="https://www.google.co.uk/search?q=arduino">available</A> about Arduinos.
The main reference is <A HREF="http://www.arduino.cc">here</A>. Like the Raspberry Pi's, the good thing about
Arduinos is that they can be powered with simple AA-batteries.
</p>
<p>
I have several Raspberry Pi's including wifi-connectors and two <A HREF="http://www.raspberrypi.org/camera">cameras</A>.
I also have two <A HREF="http://www.freaklabs.org/index.php/Blog/Store/Introducing-the-Freakduino-Chibi-An-Arduino-based-Board-For-Wireless-Sensor-Networking.html">Freakduino Boards</A> that are Arduinos extended with wireless communication. I can lend them to responsible
students for one or two projects. However, the aim is to first come up with an idea for a project. Popular projects are
automated temperature sensors, network servers, robots, web-cams (<A HREF="http://www.secretbatcave.co.uk/electronics/shard-rain-cam/">here</A>
is a <A HREF="http://www.raspberrypi.org/archives/3547">web-cam</A> directed at the Shard that can
<A HREF="http://www.secretbatcave.co.uk/software/shard-rain-cam-quantifying-cloudy/">tell</A>
you whether it is raining or cloudy). There are plenty more ideas listed
<A HREF="http://www.raspberrypi.org/phpBB3/viewforum.php?f=15">here</A> for Raspberry Pi's and
<A HREF="http://playground.arduino.cc/projects/ideas">here</A> for Arduinos.
</p>
<p>
There are essentially two kinds of projects: One is purely software-based. Software projects for Raspberry Pi's are often
written in <A HREF="http://www.python.org">Python</A>, but since these are Linux-capable computers any other
language would do as well. You can also write your own operating system as done
<A HREF="http://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/">here</A>. For example the students
<A HREF="http://www.recantha.co.uk/blog/?p=4918">here</A> developed their own bare-metal OS and then implemented
a chess-program on top of it (have a look at their very impressive
<A HREF="http://www.youtube.com/watch?v=-03bouPsfEQ&feature=player_embedded">youtube</A> video).
The other kind of project is a combination of hardware and software; usually attaching some sensors
or motors to the Raspberry Pi or Arduino. This might require some soldering or what is called
a <A HREF="http://en.wikipedia.org/wiki/Breadboard">bread-board</A>. But be careful before choosing a project
involving new hardware: these devices
can be destroyed (if “Vin connected to GND” or “drawing more than 30mA from a GPIO”
does not make sense to you, you should probably stay away from such a project).
</p>
<center>
<img style="-webkit-user-select: none; cursor: -webkit-zoom-in;"
src="http://upload.wikimedia.org/wikipedia/commons/3/3d/RaspberryPi.jpg"
alt="Raspberry Pi"
width="313" height="209">
<img style="-webkit-user-select: none; cursor: -webkit-zoom-in;"
src="https://upload.wikimedia.org/wikipedia/commons/7/7e/Raspberry-Pi-Zero-FL.jpg"
alt="Raspberry Pi Zero"
width="313" height="209">
<img style="-webkit-user-select: none; cursor: -webkit-zoom-in;"
src="http://upload.wikimedia.org/wikipedia/commons/3/38/Arduino_Uno_-_R3.jpg"
alt="Arduino"
width="240" height="209">
</center>
<p>
<B>Skills:</B>
Well, you must be a hacker; happy to make things. Your desk might look like the photo below on the left.
The photo below on the middle shows an earlier student project which connects wirelessly a wearable Arduino (packaged
in a "self-3d-printed" watch) to a Raspberry Pi seen in the background. The Arduino in the foreground takes
measurements of
heart rate and body temperature; the Raspberry Pi collects this data and makes it accessible via a simple
web-service. The picture on the right is another project that implements an airmouse using an Arduino.
<center>
<img style="-webkit-user-select: none; cursor: -webkit-zoom-in;"
src="https://nms.kcl.ac.uk/christian.urban/rpi-photo.jpg"
alt="Raspberry Pi"
width="209" height="313">
<img style="-webkit-user-select: none; cursor: -webkit-zoom-in;"
src="https://nms.kcl.ac.uk/christian.urban/rpi-watch.jpg"
alt="Raspberry Pi"
width="450" height="254">
<img style="-webkit-user-select: none; cursor: -webkit-zoom-in;"
src="https://nms.kcl.ac.uk/christian.urban/rpi-airmouse.jpg"
alt="Raspberry Pi"
width="250" height="254">
</center><p>
A really cool project using a toy helicopter and two Raspberry Pi's was done by Nikolaos Kyknas. He transformed
an off-the-shelf toy helicopter into an autonomous flying machine. He attached a Raspberry Pi Zero and an ultrasound
sensor to the helicopter for measuring the distance from ground. Another Raspberry Pi is attached to the “ground control
unit” in order to give instructions to the throttle of the helicopter. Both Raspberry Pi's communicate over WiFi for calculating
the next flight instruction. The goal is to find and maintain a steady altitude. Sounds simple? Well, not so fast!
First you need to get the balance of the helicopter plus Raspberry Pi plus its power source just right,
otherwise the helicopter will simply take off in random directions. Also the flight instructions need to be just right,
otherwise the helicopter would at best “oscillate” around the set altitude, but never be steady. To solve this problem,
Nikolaos used exactly the same algorithm that keeps cars at a steady pace when in cruise control.
<center>
<video width="320" height="576" controls>
<source src="https://nms.kcl.ac.uk/christian.urban/h1.mp4" type="video/mp4">
Your browser does not support the video tag.
</video>
<video width="320" height="576" controls>
<source src="https://nms.kcl.ac.uk/christian.urban/h3.mp4">
Your browser does not support the video tag.
</video>
</center>
<li> <H4>[CU7] An Infrastructure for Displaying and Animating Code in a Web-Browser</H4>
<p>
<B>Description:</B>
The project aim is to implement an infrastructure for displaying and
animating code in a web-browser. The infrastructure should be agnostic
with respect to the programming language, but should be configurable.
I envisage something smaller than the projects
<A HREF="http://www.pythontutor.com">here</A> (for Python),
<A HREF="http://ideone.com">here</A> (for Java),
<A HREF="http://codepad.org">here</A> (for multiple languages),
<A HREF="http://www.w3schools.com/html/tryit.asp?filename=tryhtml_intro">here</A> (for HTML)
<A HREF="http://repl.it/languages/JavaScript">here</A> (for JavaScript),
and <A HREF="http://www.scala-tour.com/#/welcome">here</A> (for Scala).
</p>
<p>
The tasks in this project are being able (1) to lex and parse languages and (2) to write an interpreter.
The goal is to implement this as much as possible in a language-agnostic fashion.
</p>
<p>
<B>Skills:</B>
Good skills in lexing and language parsing, as well as being fluent with web programming (for
example JavaScript).
</p>
<li> <H4>[CU8] Proving the Correctness of Programs</H4>
<p>
I am one of the main developers of the interactive theorem prover
<A HREF="http://isabelle.in.tum.de">Isabelle</A>. This theorem prover
has been used to establish the correctness of some quite large
programs (for example an <A HREF="http://ertos.nicta.com.au/research/l4.verified/">operating system</A>).
Together with colleagues from Nanjing, I used this theorem prover to establish the correctness of a
scheduling algorithm, called
<A HREF="http://en.wikipedia.org/wiki/Priority_inheritance">Priority Inheritance</A>,
for real-time operating systems. This scheduling algorithm is part of the operating
system that drives, for example, the
<A HREF="http://en.wikipedia.org/wiki/Mars_Exploration_Rover">Mars rovers</A>.
Actually, the very first Mars rover mission in 1997 did not have this
algorithm switched on and it almost caused a catastrophic mission failure (see
this youtube video <A HREF="http://www.youtube.com/watch?v=lyx7kARrGeM">here</A>
for an explanation what happened).
We were able to prove the correctness of this algorithm, but were also able to
establish the correctness of some optimisations in this
<A HREF="https://nms.kcl.ac.uk/christian.urban/Publications/pip.pdf">paper</A>.
</p>
<p>On a much smaller scale, there are a few small programs and underlying algorithms where it
is not really understood whether they always compute a correct result (for example the
regular expression matcher by Sulzmann and Lu in project [CU1]). The aim of this
project is to completely specify an algorithm in Isabelle and then prove it correct (that is,
it always computes the correct result).
</p>
<p>
<B>Skills:</B>
This project is for a very good student with a knack for theoretical things and formal reasoning.
</p>
<li> <H4>[CU9] Anything Security Related that is Interesting</H4>
<p>
If you have your own project that is related to security (must be
something interesting), please propose it. We can then have a look
whether it would be suitable for a project.
</p>
<li> <H4>[CU10] Anything Interesting in the Areas</H4>
<ul>
<li><A HREF="http://elm-lang.org">Elm</A> (a reactive functional language for animating webpages; have a look at the cool examples, or <A HREF="http://pragmaticstudio.com/blog/2014/12/19/getting-started-with-elm">here</A> for an introduction)
<li><A HREF="http://www.smlserver.org/smltojs/">SMLtoJS</A> (a ML compiler to JavaScript; or anything else related to
sane languages that compile to JavaScript)
<li>Any statistical data related to Bitcoins (in the spirit of this
<A HREF="http://people.csail.mit.edu/spillai/data/papers/bitcoin-transaction-graph-analysis.pdf">paper</A> or
this <A HREF="https://eprint.iacr.org/2012/584.pdf">one</A>; this will probably require some extensive C knowledge or any
other heavy-duty programming language)
<li>Anything related to programming languages and formal methods (like
<A HREF="http://matt.might.net/articles/intro-static-analysis/">static program analysis</A>)
<li>Anything related to low-cost, hands-on hardware like Raspberry Pi, Arduino,
<A HREF="http://en.wikipedia.org/wiki/Cubieboard">Cubieboard</A>
<li>Anything related to unikernel operating systems, like
<A HREF="http://www.xenproject.org">Xen</A> or
<A HREF="http://www.openmirage.org">Mirage OS</A>
<li>Any kind of applied hacking, for example the Arduino-based keylogger described
<A HREF="http://samy.pl/keysweeper/">here</A>
<li>Anything related to code books, like this
<A HREF="http://www.joelotter.com/kajero/">one</A>
</ul>
<li> <H4>Earlier Projects</H4>
I am also open to project suggestions from you. You might find some inspiration from my earlier projects:
<A HREF="https://nms.kcl.ac.uk/christian.urban/bsc-projects-12.html">BSc 2012/13</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/msc-projects-12.html">MSc 2012/13</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/bsc-projects-13.html">BSc 2013/14</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/msc-projects-13.html">MSc 2013/14</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/bsc-projects-14.html">BSc 2014/15</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/msc-projects-14.html">MSc 2014/15</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/bsc-projects-15.html">BSc 2015/16</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/msc-projects-15.html">MSc 2015/16</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/bsc-projects-16.html">BSc 2016/17</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/msc-projects-16.html">MSc 2016/17</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/bsc-projects-17.html">BSc 2017/18</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/msc-projects-17.html">MSc 2017/18</A>,
<A HREF="https://nms.kcl.ac.uk/christian.urban/bsc-projects-17.html">BSc 2018/19</A>
</ul>
</TD>
</TR>
</TABLE>
<P>
2018-09-24 12:12:35 by Christian Urban
<a href="https://validator.w3.org/check/referer">[Validate this page.]</a>
</P>
</BODY>
</HTML>