297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 1 <?xml version="1.0" encoding="utf-8"?>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 2 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 3 <HEAD>
333
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 4 <TITLE>2014/15 MSc Projects</TITLE>
465
+ − 5 <BASE HREF="http://nms.kcl.ac.uk/christian.urban/">
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 6 <script type="text/javascript" src="striper.js"></script>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 7 <link rel="stylesheet" href="nominal.css">
300
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 8 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 9 </script>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 10 </HEAD>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 11 <BODY TEXT="#000000"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 12 BGCOLOR="#4169E1"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 13 LINK="#0000EF"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 14 VLINK="#51188E"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 15 ALINK="#FF0000"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 16 ONLOAD="striper('ul','striped','li','first,second')">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 17
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 18
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 19
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 20 <TABLE WIDTH="100%"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 21 BGCOLOR="#4169E1"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 22 BORDER="0"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 23 FRAME="border"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 24 CELLPADDING="10"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 25 CELLSPACING="2"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 26 RULES="all">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 27
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 28 <TR>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 29 <TD BGCOLOR="#FFFFFF"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 30 WIDTH="75%"
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 31 VALIGN="TOP">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 32
333
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 33 <H2>2014/15 MSc Projects</H2>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 34 <H4>Supervisor: Christian Urban</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 35 <H4>Email: christian dot urban at kcl dot ac dot uk, Office: Strand Building S1.27</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 36 <H4>If you are interested in a project, please send me an email and we can discuss details. Please include
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 37 a short description about your programming skills and Computer Science background in your first email.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 38 I will also need your King's username in order to book the project for you. Thanks.</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 39
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 40 <H4>Note that besides being a lecturer at the theoretical end of Computer Science, I am also a passionate
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 41 <A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker</A> …
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 42 defined as “a person who enjoys exploring the details of programmable systems and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 43 stretching their capabilities, as opposed to most users, who prefer to learn only the minimum
353
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 44 necessary.” I am always happy to supervise like-minded students.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 45
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 46 <p>In 2013/14, I was nominated by the students
352
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 47 for the best BSc project supervisor and best MSc project supervisor awards in the NMS faculty. Somehow I won both ;o)</H4>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 48
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 49 <ul class="striped">
342
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 50 <li> <H4>[CU1] Regular Expression Matching, Lexing and Derivatives</H4>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 51
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 52 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 53 <B>Description:</b>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 54 <A HREF="http://en.wikipedia.org/wiki/Regular_expression">Regular expressions</A>
334
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 55 are extremely useful for many text-processing tasks, such as finding patterns in texts,
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 56 lexing programs, syntax highlighting and so on. Given that regular expressions were
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 57 introduced in 1950 by <A HREF="http://en.wikipedia.org/wiki/Stephen_Cole_Kleene">Stephen Kleene</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 58 you might think regular expressions have since been studied and implemented to death. But you would definitely be
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 59 mistaken: in fact they are still an active research area. For example
312
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 60 <A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/regex-parsing-derivatives.pdf">this paper</A>
315
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 61 about regular expression matching and derivatives was presented just last summer at the international
334
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 62 FLOPS'14 conference. The task in this project is to implement their results and use them for lexing.</p>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 63
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 64 <p>The background for this project is that some regular expressions are
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 65 “<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>”
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 66 and can “stab you in the back” according to
315
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 67 this <A HREF="http://peterscott.github.io/2013/01/17/regular-expressions-will-stab-you-in-the-back/">blog post</A>.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 68 For example, if you use in <A HREF="http://www.python.org">Python</A> or
323
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 69 in <A HREF="http://www.ruby-lang.org/en/">Ruby</A> (or also in a number of other mainstream programming languages according to this
313
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 70 <A HREF="http://www.computerbytesman.com/redos/">blog</A>) the
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 71 innocently looking regular expression <code>a?{28}a{28}</code> and match it, say, against the string
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 72 <code>aaaaaaaaaaaaaaaaaaaaaaaaaaaa</code> (that is 28 <code>a</code>s), you will soon notice that your CPU usage goes to 100%. In fact,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 73 Python and Ruby need approximately 30 seconds of hard work for matching this string. You can try it for yourself:
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 74 <A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/cgi-bin/repos.cgi/afl-material/raw-file/tip/progs/re.py">re.py</A> (Python version) and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 75 <A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/cgi-bin/repos.cgi/afl-material/raw-file/tip/progs/re.rb">re.rb</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 76 (Ruby version). You can imagine an attacker
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 77 mounting a nice <A HREF="http://en.wikipedia.org/wiki/Denial-of-service_attack">DoS attack</A> against
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 78 your program if it contains such an “evil” regular expression. Actually
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 79 <A HREF="http://www.scala-lang.org/">Scala</A> (and also Java) are almost immune from such
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 80 attacks as they can deal with strings of up to 4,300 <code>a</code>s in less than a second. But if you scale
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 81 the regular expression and string further to, say, 4,600 <code>a</code>s, then you get a <code>StackOverflowError</code>
314
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 82 potentially crashing your program. Moreover (beside the "minor" problem of being painfully slow) according to this
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 83 <A HREF="http://www.haskell.org/haskellwiki/Regex_Posix">report</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 84 nearly all POSIX regular expression matchers are actually buggy.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 85 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 86
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 87 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 88 On a rainy afternoon, I implemented
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 89 <A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/cgi-bin/repos.cgi/afl-material/raw-file/tip/progs/re3.scala">this</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 90 regular expression matcher in Scala. It is not as fast as the official one in Scala, but
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 91 it can match up to 11,000 <code>a</code>s in less than 5 seconds without raising any exception
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 92 (remember Python and Ruby both need nearly 30 seconds to process 28(!) <code>a</code>s, and Scala's
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 93 official matcher maxes out at 4,600 <code>a</code>s). My matcher is approximately
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 94 85 lines of code and based on the concept of
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 95 <A HREF="http://lambda-the-ultimate.org/node/2293">derivatives of regular expressions</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 96 These derivatives were introduced in 1964 by <A HREF="http://en.wikipedia.org/wiki/Janusz_Brzozowski_(computer_scientist)">
341
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 97 Janusz Brzozowski</A>, but according to this
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 98 <A HREF="http://www.cl.cam.ac.uk/~so294/documents/jfp09.pdf">paper</A> had been lost in the “sands of time”.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 99 The advantage of derivatives is that they side-step completely the usual
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 100 <A HREF="http://hackingoff.com/compilers/regular-expression-to-nfa-dfa">translations</A> of regular expressions
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 101 into NFAs or DFAs, which can introduce the exponential behaviour exhibited by the regular
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 102 expression matchers in Python and Ruby.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 103 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 104
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 105 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 106 Now the authors from the
312
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 107 <A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/regex-parsing-derivatives.pdf">FLOPS'14-paper</A> mentioned
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 108 above claim they are even faster than me and can deal with even more features of regular expressions
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 109 (for example subexpression matching, which my rainy-afternoon matcher cannot). I am sure they thought
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 110 about the problem much longer than a single afternoon. The task
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 111 in this project is to find out how good they actually are by implementing the results from their paper.
334
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 112 Their approach to regular expression matching is also based on the concept of derivatives.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 113 I used derivatives very successfully once for something completely different in a
465
+ − 114 <A HREF="http://nms.kcl.ac.uk/christian.urban/Publications/rexp.pdf">paper</A>
334
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 115 about the <A HREF="http://en.wikipedia.org/wiki/Myhill–Nerode_theorem">Myhill-Nerode theorem</A>.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 116 So I know they are worth their money. Still, it would be interesting to actually compare their results
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 117 with my simple rainy-afternoon matcher and potentially “blow away” the regular expression matchers
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 118 in Python and Ruby (and possibly in Scala too). The application would be to implement a fast lexer for
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 119 programming languages.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 120 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 121
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 122 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 123 <B>Literature:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 124 The place to start with this project is obviously this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 125 <A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/ppdp12-part-deriv-sub-match.pdf">paper</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 126 Traditional methods for regular expression matching are explained
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 127 in the Wikipedia articles
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 128 <A HREF="http://en.wikipedia.org/wiki/DFA_minimization">here</A> and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 129 <A HREF="http://en.wikipedia.org/wiki/Powerset_construction">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 130 The authoritative <A HREF="http://infolab.stanford.edu/~ullman/ialc.html">book</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 131 on automata and regular expressions is by John Hopcroft and Jeffrey Ullmann (available in the library).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 132 There is also an online course about this topic by Ullman at
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 133 <A HREF="https://www.coursera.org/course/automata">Coursera</A>, though IMHO not
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 134 done with love.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 135 Finally, there are millions of other pointers about regular expression
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 136 matching on the Web. I found the chapter on Lexing in this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 137 <A HREF="http://www.diku.dk/~torbenm/Basics/">online book</A> very helpful.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 138 Test cases for “<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>”
316
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 139 regular expressions can be obtained from <A HREF="http://www.haskell.org/haskellwiki/Regex_Posix">here</A>.
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 140
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 141 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 142
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 143 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 144 <B>Skills:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 145 This is a project for a student with an interest in theory and some
335
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 146 good programming skills. The project can be easily implemented
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 147 in functional languages like
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 148 <A HREF="http://www.scala-lang.org/">Scala</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 149 F#,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 150 <A HREF="http://en.wikipedia.org/wiki/Standard_ML">ML</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 151 <A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>, etc. Python and other non-functional languages
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 152 can be also used, but seem much less convenient.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 153 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 154
298
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 155 <li> <H4>[CU2] A Compiler for a small Programming Language</H4>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 156
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 157 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 158 <b>Description:</b>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 159 Compilers translate high-level programs that humans can read and write into
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 160 efficient machine code that can be run on a CPU or virtual machine.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 161 A compiler for a simple functional language generating X86 code is described
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 162 <A HREF="https://github.com/chameco/Shade">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 163 I recently implemented a very simple compiler for an even simpler functional
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 164 programming language following this
341
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 165 <A HREF="https://www.cs.princeton.edu/~dpw/papers/tal-toplas.pdf">paper</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 166 (also described <A HREF="https://www.cs.princeton.edu/~dpw/papers/tal-tr.pdf">here</A>).
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 167 My code, written in <A HREF="http://www.scala-lang.org/">Scala</A>, of this compiler is
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 168 <A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/compiler.scala">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 169 The compiler can deal with simple programs involving natural numbers, such
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 170 as Fibonacci numbers or factorial (but it can be easily extended - that is not the point).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 171 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 172
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 173 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 174 While the hard work has been done (understanding the two papers above),
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 175 my compiler only produces some idealised machine code. For example I
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 176 assume there are infinitely many registers. The goal of this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 177 project is to generate machine code that is more realistic and can
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 178 run on a CPU, like X86, or run on a virtual machine, say the JVM.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 179 This gives probably a speedup of thousand times in comparison to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 180 my naive machine code and virtual machine. The project
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 181 requires to dig into the literature about real CPUs and generating
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 182 real machine code.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 183 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 184 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 185 An alternative is to not generate machine code, but build a compiler that compiles to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 186 <A HREF="http://www.w3schools.com/js/">JavaScript</A>. This is the language that is supported by most
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 187 browsers and therefore is a favourite
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 188 vehicle for Web-programming. Some call it <B>the</B> scripting language of the Web.
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 189 Unfortunately, JavaScript is also probably one of the worst
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 190 languages to program in (being designed and released in a hurry). <B>But</B> it can be used as a convenient target
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 191 for translating programs from other languages. In particular there are two
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 192 very optimised subsets of JavaScript that can be used for this purpose:
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 193 one is <A HREF="http://asmjs.org">asm.js</A> and the other is
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 194 <A HREF="https://github.com/kripken/emscripten/wiki">emscripten</A>.
316
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 195 There is a <A HREF="http://kripken.github.io/emscripten-site/docs/getting_started/Tutorial.html">tutorial</A> for emscripten
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 196 and an impressive <A HREF="http://www.unrealengine.com/html5/">demo</A> which runs the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 197 <A HREF="http://en.wikipedia.org/wiki/Unreal_Engine">Unreal Engine 3</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 198 in a browser with spectacular speed. This was achieved by compiling the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 199 C-code of the Unreal Engine to the LLVM intermediate language and then translating the LLVM
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 200 code to JavaScript.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 201 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 202
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 203 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 204 <B>Literature:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 205 There is a lot of literature about compilers
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 206 (for example <A HREF="http://www.cs.princeton.edu/~appel/papers/cwc.html">this book</A> -
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 207 I can lend you my copy for the duration of the project, or this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 208 <A HREF="http://www.diku.dk/~torbenm/Basics/">online book</A>). A very good overview article
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 209 about implementing compilers by
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 210 <A HREF="http://tratt.net/laurie/">Laurie Tratt</A> is
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 211 <A HREF="http://tratt.net/laurie/tech_articles/articles/how_difficult_is_it_to_write_a_compiler">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 212 An online book about the Art of Assembly Language is
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 213 <A HREF="http://flint.cs.yale.edu/cs422/doc/art-of-asm/pdf/">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 214 An introduction into x86 machine code is <A HREF="http://ianseyler.github.com/easy_x86-64/">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 215 Intel's official manual for the x86 instruction is
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 216 <A HREF="http://download.intel.com/design/intarch/manuals/24319101.pdf">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 217 A simple assembler for the JVM is described <A HREF="http://jasmin.sourceforge.net">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 218 An interesting twist of this project is to not generate code for a CPU, but
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 219 for the intermediate language of the <A HREF="http://llvm.org">LLVM</A> compiler
316
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 220 (also described <A HREF="http://llvm.org/docs/LangRef.html">here</A>). If you want to see
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 221 what machine code looks like you can compile your C-program using gcc -S.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 222 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 223 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 224 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.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 225 <A HREF="http://jsbooks.revolunet.com">Here</A> is a list of free books on JavaScript.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 226 A project from which you can draw inspiration is this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 227 <A HREF="http://jlongster.com/2012/01/04/outlet-my-lisp-to-javascript-experiment.html">List-to-JavaScript</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 228 translator. <A HREF="https://bitbucket.org/ktg/parenjs/overview">Here</A> is another such project.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 229 And <A HREF="https://github.com/viclib/liscript">another</A> in less than 100 lines of code.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 230 <A HREF="http://en.wikipedia.org/wiki/CoffeeScript">Coffeescript</A> is a similar project
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 231 except that it is already quite <A HREF="http://coffeescript.org">mature</A>. And finally not to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 232 forget <A HREF="http://www.typescriptlang.org">TypeScript</A> developed by Microsoft. The main
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 233 difference between these projects and this one is that they translate into relatively high-level
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 234 JavaScript code; none of them use the much lower levels <A HREF="http://asmjs.org">asm.js</A> and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 235 <A HREF="https://github.com/kripken/emscripten/wiki">emscripten</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 236 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 237 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 238 <B>Skills:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 239 This is a project for a student with a deep interest in programming languages and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 240 compilers. Since my compiler is implemented in <A HREF="http://www.scala-lang.org/">Scala</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 241 it would make sense to continue this project in this language. I can be
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 242 of help with questions and books about <A HREF="http://www.scala-lang.org/">Scala</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 243 But if Scala is a problem, my code can also be translated quickly into any other functional
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 244 language.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 245 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 246
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 247 <p>
343
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 248 <B>PS:</B> Compiler projects consistently received high marks in the past.
335
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 249 I have suprvised five so far and none of them received a mark below 70% - one even was awarded a prize.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 250 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 251
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 252 <li> <H4>[CU3] Slide-Making in the Web-Age</H4>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 254 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 255 The standard technology for writing scientific papers in Computer Science is to use
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 256 <A HREF="http://en.wikipedia.org/wiki/LaTeX">LaTeX</A>, a document preparation
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 257 system originally implemented by <A HREF="http://en.wikipedia.org/wiki/Donald_Knuth">Donald Knuth</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 258 and <A HREF="http://en.wikipedia.org/wiki/Leslie_Lamport">Leslie Lamport</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 259 LaTeX produces very pleasantly looking documents, can deal nicely with mathematical
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 260 formulas and is very flexible. If you are interested, <A HREF="http://openwetware.org/wiki/Word_vs._LaTeX">here</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 261 is a side-by-side comparison between Word and LaTeX (which LaTeX “wins” with 18 out of 21 points).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 262 Computer scientists not only use LaTeX for documents,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 263 but also for slides (really, nobody who wants to be cool uses Keynote or Powerpoint).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 264 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 265
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 266 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 267 Although used widely, LaTeX seems nowadays a bit dated for producing
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 268 slides. Unlike documents, which are typically “static” and published in a book or journal,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 269 slides often contain changing contents that might first only be partially visible and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 270 only later be revealed as the “story” of a talk or lecture demands.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 271 Also slides often contain animated algorithms where each state in the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 272 calculation is best explained by highlighting the changing data.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 273 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 274
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 275 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 276 It seems HTML and JavaScript are much better suited for generating
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 277 such animated slides. This <A HREF="http://www.impressivewebs.com/html-slidedeck-toolkits/">page</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 278 links to 22 slide-generating programs using this combination of technologies.
316
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 279 However, the problem with all of these project is that they depend heavily on the users being
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 280 able to write JavaScript, CCS or HTML...not something one would like to depend on given that
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 281 “normal” users likely only have a LaTeX background. The aim of this project is to invent a
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 282 very simple language that is inspired by LaTeX and then generate from code written in this language
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 283 slides that can be displayed in a web-browser.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 284 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 285
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 286 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 287 This sounds complicated, but there is already some help available:
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 288 <A HREF="http://www.mathjax.org">Mathjax</A> is a JavaScript library that can
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 289 be used to display mathematical text, for example
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 290
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 291 <blockquote>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 292 <p>When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 293 \(x = {-b \pm \sqrt{b^2-4ac} \over 2a}\).</p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 294 </blockquote>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 295
317
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 296 by writing code in the familiar LaTeX-way. This can be reused.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 297 Another such library is <A HREF="http://khan.github.io/KaTeX/">KaTeX</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 298 There are also plenty of JavaScript
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 299 libraries for graphical animations (for example
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 300 <A HREF="http://raphaeljs.com">Raphael</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 301 <A HREF="http://svgjs.com">SVG.JS</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 302 <A HREF="http://bonsaijs.org">Bonsaijs</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 303 <A HREF="http://jsxgraph.uni-bayreuth.de/wp/">JSXGraph</A>). The inspiration for how the user should be able to write
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 304 slides could come from the LaTeX packages <A HREF="http://en.wikipedia.org/wiki/Beamer_(LaTeX)">Beamer</A>
359
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 305 and <A HREF="http://en.wikipedia.org/wiki/PGF/TikZ">PGF/TikZ</A>. A slide-making project from which
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 306 inspiration can be drawn is <A HREF="http://maciejczyzewski.me/hyhyhy/">hyhyhy</A>.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 307 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 308
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 309 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 310 <B>Skills:</B>
335
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 311 This is a project that requires good knowledge of JavaScript. You need to be able to
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 312 parse a language and translate it to a suitable part of JavaScript using
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 313 appropriate libraries. Tutorials for JavaScript are <A HREF="http://www.w3schools.com/js/">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 314 A parser generator for JavaScript is <A HREF="http://pegjs.majda.cz">here</A>. There are probably also
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 315 others. If you want to avoid JavaScript there are a number of alternatives: for example the
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 316 <A HREF="http://elm-lang.org">Elm</A>
335
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 317 language has been especially designed for implementing with ease interactive animations, which would be
316
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 318 very convenient for this project.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 319 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 320
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 321 <li> <H4>[CU4] An Online Student Voting System</H4>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 322
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 323 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 324 <B>Description:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 325 One of the more annoying aspects of giving a lecture is to ask a question
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 326 to the students and no matter how easy the question is to not
316
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 327 receive any answer. The online course system
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 328 <A HREF="http://www.udacity.com">Udacity</A>, in contrast, made an art out of
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 329 asking questions during lectures (see for example the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 330 <A HREF="http://www.udacity.com/overview/Course/cs253/CourseRev/apr2012">Web Application Engineering</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 331 course CS253).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 332 The lecturer there gives multiple-choice questions as part of the lecture and the students need to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 333 click on the appropriate answer. This works very well in the online world.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 334 For “real-world” lectures, the department has some
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 335 <A HREF="http://en.wikipedia.org/wiki/Audience_response">clickers</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 336 (these are little devices which form a part of an audience response systems). However,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 337 they are a logistic nightmare for the lecturer: they need to be distributed
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 338 during the lecture and collected at the end. Nowadays, where students
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 339 come with their own laptop or smartphone to lectures, this can
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 340 be improved.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 341 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 342
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 343 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 344 The task of this project is to implement an online student
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 345 polling system. The lecturer should be able to prepare
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 346 questions beforehand (encoded as some web-form) and be able to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 347 show them during the lecture. The students
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 348 can give their answers by clicking on the corresponding webpage.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 349 The lecturer can then collect the responses online and evaluate them
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 350 immediately. Such a system is sometimes called
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 351 <A HREF="http://en.wikipedia.org/wiki/Audience_response#Smartphone_.2F_HTTP_voting">HTML voting</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 352 There are a number of commercial
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 353 solutions for this problem, but they are not easy to use (in addition
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 354 to being ridiculously expensive). A good student can easily improve upon
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 355 what they provide.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 356 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 357
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 358 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 359 The problem of student polling is not as hard as
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 360 <A HREF="http://en.wikipedia.org/wiki/Electronic_voting">electronic voting</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 361 which essentially is still an unsolved problem in Computer Science. The
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 362 students only need to be prevented from answering question more than once thus skewing
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 363 any statistics. Unlike electronic voting, no audit trail needs to be kept
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 364 for student polling. Restricting the number of answers can probably be solved
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 365 by setting appropriate cookies on the students
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 366 computers or smart phones.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 367 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 368
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 369 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 370 <B>Literature:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 371 The project requires fluency in a web-programming language (for example
316
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 372 <A HREF="http://en.wikipedia.org/wiki/JavaScript">JavaScript</A>,
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 373 <A HREF="http://en.wikipedia.org/wiki/Go_(programming_language)">Go</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 374 <A HREF="http://www.scala-lang.org/">Scala</A>). However JavaScript with
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 375 the <A HREF="http://nodejs.org">Node.js</A> extension seems to be best suited for the job.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 376 <A HREF="http://www.nodebeginner.org">Here</A> is a tutorial on Node.js for beginners.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 377 For web-programming the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 378 <A HREF="http://www.udacity.com/overview/Course/cs253/CourseRev/apr2012">Web Application Engineering</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 379 course at <A HREF="http://www.udacity.com">Udacity</A> is a good starting point
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 380 to be aware of the issues involved. This course uses <A HREF="http://www.python.org">Python</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 381 To evaluate the answers from the students, Google's
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 382 <A HREF="https://developers.google.com/chart/image/docs/making_charts">Chart Tools</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 383 might be useful, which is also described in this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 384 <A HREF="http://www.youtube.com/watch?v=NZtgT4jgnE8">youtube</A> video.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 385 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 386
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 387 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 388 <B>Skills:</B>
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 389 In order to provide convenience for the lecturer, this project needs very good web-programming skills. A
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 390 <A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker mentality</A>
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 391 (see above) is probably also very beneficial: web-programming is an area that only emerged recently and
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 392 many tools still lack maturity. You probably have to experiment a lot with several different
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 393 languages and tools.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 394 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 395
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 396 <li> <H4>[CU5] Raspberry Pi's and Arduinos</H4>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 397
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 398 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 399 <B>Description:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 400 This project is for true hackers! <A HREF="http://en.wikipedia.org/wiki/Raspberry_Pi">Raspberry Pi's</A>
344
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 401 are small Linux computers the size of a credit-card and only cost £26 (see picture on the left below). They were introduced
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 402 in 2012 and people went crazy...well some of them. There is a
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 403 <A HREF="https://plus.google.com/communities/113390432655174294208?hl=en">Google+</A> community about Raspberry Pi's that has more
336
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 404 than 177k of followers. It is hard to keep up with what people do with these small computers. The possibilities
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 405 seem to be limitless. The main resource for Raspberry Pi's is <A HREF="http://www.raspberrypi.org">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 406 There are <A HREF="http://www.themagpi.com">magazines</A> dedicated to them and tons of
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 407 <A HREF="http://www.raspberrypi.org/phpBB3/viewforum.php?f=39">books</A> (not to mention
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 408 floods of <A HREF="https://www.google.co.uk/search?q=raspberry+pi">online</A> material).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 409 Google just released a
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 410 <A HREF="http://googlecreativelab.github.io/coder/">framework</A>
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 411 for web-programming on Raspberry Pi's truning them into webservers.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 412 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 413
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 414 <p>
329
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 415 <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
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 416 are small single-board micro-controllers that can talk to various external gadgets (sensors, motors, etc). Since Arduinos
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 417 are open-software and open-hardware there are many clones and add-on boards. Like for the Raspberry Pi, there
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 418 is a lot of material <A HREF="https://www.google.co.uk/search?q=arduino">available</A> about Arduinos.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 419 The main reference is <A HREF="http://www.arduino.cc">here</A>. Like the Raspberry Pi's, the good thing about
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 420 Arduinos is that they can be powered with simple AA-batteries.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 421 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 422
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 423 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 424 I have two such Raspberry Pi's including wifi-connectors and two <A HREF="http://www.raspberrypi.org/camera">cameras<A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 425 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
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 426 students for one or two projects. However, the aim is to first come up with an idea for a project. Popular projects are
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 427 automated temperature sensors, network servers, robots, web-cams (<A HREF="http://www.secretbatcave.co.uk/electronics/shard-rain-cam/">here</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 428 is a <A HREF="http://www.raspberrypi.org/archives/3547">web-cam</A> directed at the Shard that can
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 429 <A HREF="http://www.secretbatcave.co.uk/software/shard-rain-cam-quantifying-cloudy/">tell</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 430 you whether it is raining or cloudy). There are plenty more ideas listed
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 431 <A HREF="http://www.raspberrypi.org/phpBB3/viewforum.php?f=15">here</A> for Raspberry Pi's and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 432 <A HREF="http://playground.arduino.cc/projects/ideas">here</A> for Arduinos.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 433 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 434
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 435 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 436 There are essentially two kinds of projects: One is purely software-based. Software projects for Raspberry Pi's are often
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 437 written in <A HREF="http://www.python.org">Python</A>, but since these are Linux-capable computers any other
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 438 language would do as well. You can also write your own operating system as done
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 439 <A HREF="http://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/">here</A>. For example the students
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 440 <A HREF="http://www.recantha.co.uk/blog/?p=4918">here</A> developed their own bare-metal OS and then implemented
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 441 a chess-program on top of it (have a look at their very impressive
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 442 <A HREF="http://www.youtube.com/watch?v=-03bouPsfEQ&feature=player_embedded">youtube</A> video).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 443 The other kind of project is a combination of hardware and software; usually attaching some sensors
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 444 or motors to the Raspberry Pi or Arduino. This might require some soldering or what is called
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 445 a <A HREF="http://en.wikipedia.org/wiki/Breadboard">bread-board</A>. But be careful before choosing a project
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 446 involving new hardware: these devices
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 447 can be destroyed (if “Vin connected to GND” or “drawing more than 30mA from a GPIO”
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 448 does not make sense to you, you should probably stay away from such a project).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 449 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 450
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 451 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 452 <center>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 453 <img style="-webkit-user-select: none; cursor: -webkit-zoom-in;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 454 "src="http://upload.wikimedia.org/wikipedia/commons/3/3d/RaspberryPi.jpg" width="313" height="209">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 455
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 456 <img style="-webkit-user-select: none; cursor: -webkit-zoom-in;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 457 "src="http://upload.wikimedia.org/wikipedia/commons/3/38/Arduino_Uno_-_R3.jpg" width="240" height="209">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 458 </center>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 459 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 460
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 461 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 462 <B>Skills:</B>
345
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 463 Well, you must be a hacker; happy to make things. Your desk might look like the photo below on the left.
336
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 464 The photo below on the righ shows an earlier student project which connects wirelessly a wearable Arduino (packaged
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 465 in a "self-3d-printed" watch) to a Raspberry Pi seen in the background. The Arduino in the forground takes meaurements of
330
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 466 heart rate and body temperature; the Raspberry Pi collects this data and makes it accessible via a simple
321
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 467 web-service.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 468 <center>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 469 <img style="-webkit-user-select: none; cursor: -webkit-zoom-in;
465
+ − 470 "src="http://nms.kcl.ac.uk/christian.urban/rpi-photo.jpg" width="209" height="313">
318
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 471
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 472 <img style="-webkit-user-select: none; cursor: -webkit-zoom-in;
465
+ − 473 "src="http://nms.kcl.ac.uk/christian.urban/rpi-watch.jpg" width="450" height="254">
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 474 </center>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 475 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 476
342
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 477 <li> <H4>[CU6] An Infrastructure for Displaying and Animating Code in a Web-Browser</H4>
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 478
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 479 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 480 <B>Description:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 481 The project aim is to implement an infrastructure for displaying and
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 482 animating code in a web-browser. The infrastructure should be agnostic
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 483 with respect to the programming language, but should be configurable.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 484 I envisage something smaller than the projects
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 485 <A HREF="http://www.pythontutor.com">here</A> (for Python),
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 486 <A HREF="http://ideone.com">here</A> (for Java),
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 487 <A HREF="http://codepad.org">here</A> (for multiple languages),
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 488 <A HREF="http://www.w3schools.com/html/tryit.asp?filename=tryhtml_intro">here</A> (for HTML)
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 489 <A HREF="http://repl.it/languages/JavaScript">here</A> (for JavaScript),
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 490 and <A HREF="http://www.scala-tour.com/#/welcome">here</A> (for Scala).
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 491 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 492
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 493 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 494 The tasks in this project are being able (1) to lex and parse languages and (2) to write an interpreter.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 495 The goal is to implement this as much as possible in a language-agnostic fashion.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 496 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 497
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 498 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 499 <B>Skills:</B>
337
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 500 Good skills in lexing and language parsing, as well as being fluent with web programming (for
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 501 example JavaScript).
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 502 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 503
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 504
342
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 505 <li> <H4>[CU7] Implementation of a Distributed Clock-Synchronisation Algorithm developed at NASA</H4>
311
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 506
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 507 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 508 <B>Description:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 509 There are many algorithms for synchronising clocks. This
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 510 <A HREF="http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/20120000054_2011025573.pdf">paper</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 511 describes a new algorithm for clocks that communicate by exchanging
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 512 messages and thereby reach a state in which (within some bound) all clocks are synchronised.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 513 A slightly longer and more detailed paper about the algorithm is
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 514 <A HREF="http://hdl.handle.net/2060/20110020812">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 515 The point of this project is to implement this algorithm and simulate networks of clocks.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 516 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 517
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 518 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 519 <B>Literature:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 520 There is a wide range of literature on clock synchronisation algorithms.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 521 Some pointers are given in this
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 522 <A HREF="http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/20120000054_2011025573.pdf">paper</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 523 which describes the algorithm to be implemented in this project. Pointers
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 524 are given also <A HREF="http://en.wikipedia.org/wiki/Clock_synchronization">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 525 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 526
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 527 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 528 <B>Skills:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 529 In order to implement a simulation of a network of clocks, you need to tackle
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 530 concurrency. You can do this for example in the programming language
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 531 <A HREF="http://www.scala-lang.org/">Scala</A> with the help of the
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 532 <A HREF="http://akka.io">Akka</a> library. This library enables you to send messages
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 533 between different <I>actors</I>. <A HREF="http://www.scala-lang.org/node/242">Here</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 534 are some examples that explain how to implement exchanging messages between actors.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 535 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 536
342
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 537 <li> <H4>[CU8] Proving the Correctness of Programs</H4>
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 538
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 539 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 540 I am one of the main developers of the interactive theorem prover
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 541 <A HREF="http://isabelle.in.tum.de">Isabelle</A>. This theorem prover
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 542 has been used to establish the correctness of some quite large
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 543 programs (for example an <A HREF="http://ertos.nicta.com.au/research/l4.verified/">operating system</A>).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 544 Together with colleagues from Nanjing, I used this theorem prover to establish the correctness of a
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 545 scheduling algorithm, called
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 546 <A HREF="http://en.wikipedia.org/wiki/Priority_inheritance">Priority Inheritance</A>,
337
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 547 for real-time operating systems. This scheduling algorithm is part of the operating
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 548 system that drives, for example, the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 549 <A HREF="http://en.wikipedia.org/wiki/Mars_Exploration_Rover">Mars rovers</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 550 Actually, the very first Mars rover mission in 1997 did not have this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 551 algorithm switched on and it almost caused a catastrophic mission failure (see
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 552 this youtube video <A HREF="http://www.youtube.com/watch?v=lyx7kARrGeM">here</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 553 for an explanation what happened).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 554 We were able to prove the correctness of this algorithm, but were also able to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 555 establish the correctness of some optimisations in this
465
+ − 556 <A HREF="http://nms.kcl.ac.uk/christian.urban/Publications/pip.pdf">paper</A>.
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 557 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 558
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 559 <p>On a much smaller scale, there are a few small programs and underlying algorithms where it
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 560 is not really understood whether they always compute a correct result (for example the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 561 regular expression matcher by Sulzmann and Lu in project [CU1]). The aim of this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 562 project is to completely specify an algorithm in Isabelle and then prove it correct (that is,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 563 it always computes the correct result).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 564 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 565
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 566 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 567 <B>Skills:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 568 This project is for a very good student with a knack for theoretical things and formal reasoning.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 569 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 570
348
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 571 <li> <H4>[CU9] Anything Security Related that is Interesting</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 572
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 573 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 574 If you have your own project that is related to security (must be
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 575 something interesting), please propose it. We can then have a look
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 576 whether it would be suitable for a project.
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 577 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 578
355
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 579 <li> <H4>[CU10] A Graphics Framework for JavaScript</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 580
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 581 <li> <H4>[CU11] Anything Interesting in the Areas</H4>
350
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 582
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 583 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 584 <ul>
358
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 585 <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)
350
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 586 <li><A HREF="http://www.smlserver.org/smltojs/">SMLtoJS</A> (a ML compiler to JavaScript; or anything else related to
351
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 587 sane languages that compile to JavaScript)
350
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 588 <li>Any statistical data related to Bitcoins (in the spirit of this
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 589 <A HREF="http://people.csail.mit.edu/spillai/data/papers/ bitcoin-transaction-graph-analysis.pdf">paper</A> or
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 590 this <A HREF="https://eprint.iacr.org/2012/584.pdf">one</A>; this will probably require some extensive C knowledge or any
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 591 other heavy-duty programming language)
351
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 592 <li>Anything related to programming languages and formal methods (like
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 593 <A HREF="http://matt.might.net/articles/intro-static-analysis/">static program analysis</A>)
354
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 594 <li>Anything related to low-cost, hands-on hardware like Raspberry Pi, Arduino,
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 595 <A HREF="http://en.wikipedia.org/wiki/Cubieboard">Cubieboard</A>
357
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 596 <li>Anything related to microkernel operating systems, like
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 597 <A HREF="http://www.xenproject.org">Xen</A> or
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 598 <A HREF="http://www.openmirage.org">Mirage OS</A>
360
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 599 <li>Any kind of applied hacking, for example the Arduino-based keylogger described
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 600 <A HREF="http://samy.pl/keysweeper/">here</A>
350
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 601 </ul>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 602 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 603
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 604
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 605 <li> <H4>Earlier Projects</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 606
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 607 I am also open to project suggestions from you. You might find some inspiration from my earlier projects:
465
+ − 608 <A HREF="http://nms.kcl.ac.uk/christian.urban/bsc-projects-12.html">BSc 2012/13</A>,
+ − 609 <A HREF="http://nms.kcl.ac.uk/christian.urban/msc-projects-12.html">MSc 2012/13</A>,
+ − 610 <A HREF="http://nms.kcl.ac.uk/christian.urban/bsc-projects-13.html">BSc 2013/14</A>
+ − 611 <A HREF="http://nms.kcl.ac.uk/christian.urban/msc-projects-13.html">MSc 2013/14</A>
354
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 612
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 613 </ul>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 614 </TD>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 615 </TR>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 616 </TABLE>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 617
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 618 <P>
360
Christian Urban <christian dot urban at kcl dot ac dot uk>
diff
changeset
+ − 619 <!-- hhmts start --> Last modified: Wed Jan 14 01:25:12 GMT 2015 <!-- hhmts end -->
297
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 620 <a href="http://validator.w3.org/check/referer">[Validate this page.]</a>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 621 </BODY>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff
changeset
+ − 622 </HTML>