msc-projects-13.html
author Christian Urban <christian.urban@kcl.ac.uk>
Sun, 10 Apr 2022 22:14:00 +0100
changeset 616 935124ddd3ec
parent 465 4dac76eb27d9
permissions -rw-r--r--
updated
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
253
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>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
     4
<TITLE>2013/14 Msc Projects</TITLE>
465
4dac76eb27d9 updated
Christian Urban <urbanc@in.tum.de>
parents: 285
diff changeset
     5
<BASE HREF="http://nms.kcl.ac.uk/christian.urban/">
253
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">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
     8
<script type="text/javascript" src="https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
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
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    33
<H2>2013/14 MSc Projects</H2>
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> &hellip;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    42
    defined as &ldquo;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 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    44
    necessary.&rdquo; I am always happy to supervise like-minded students.</H4>  
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    45
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    46
<ul class="striped">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    47
<li> <H4>[CU1] Regular Expression Matching and Partial Derivatives</H4>
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
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    50
  <B>Description:</b>  
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    51
  <A HREF="http://en.wikipedia.org/wiki/Regular_expression">Regular expressions</A> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    52
  are extremely useful for many text-processing tasks such as finding patterns in texts,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    53
  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
    54
  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
    55
  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
    56
  mistaken: in fact they are still an active research area. For example
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    57
  <A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/ppdp12-part-deriv-sub-match.pdf">this paper</A> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    58
  about regular expression matching and partial derivatives was presented last summer at the international 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    59
  PPDP'12 conference. They even work on a followup paper that has not yet been presented at any
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    60
  conference. The task in this project is to implement their results.</p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    61
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    62
  <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
    63
  &ldquo;<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>&rdquo;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    64
  and can &ldquo;stab you in the back&rdquo; according to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    65
  this <A HREF="http://tech.blog.cueup.com/regular-expressions-will-stab-you-in-the-back">blog post</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    66
  For example, if you use in <A HREF="http://www.python.org">Python</A> or 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    67
  in <A HREF="http://www.ruby-lang.org/en/">Ruby</A> (probably also other mainstream programming languages) the 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    68
  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
    69
  <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
    70
  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
    71
  <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
    72
  <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
    73
  (Ruby version). You can imagine an attacker
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    74
  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
    75
  your program if it contains such an &ldquo;evil&rdquo; regular expression. Actually 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    76
  <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
    77
  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
    78
  the regular expression and string further to, say, 4,600 <code>a</code>s, then you get a <code>StackOverflowError</code> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    79
  potentially crashing your program.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    80
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    81
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    82
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    83
  On a rainy afternoon, I implemented 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    84
  <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
    85
  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
    86
  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
    87
  (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
    88
  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
    89
  85 lines of code and based on the concept of 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    90
  <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
    91
  These derivatives were introduced in 1964 by <A HREF="http://en.wikipedia.org/wiki/Janusz_Brzozowski_(computer_scientist)">
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    92
  Janusz Brzozowski</A>, but according to this 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    93
  <A HREF="http://www.cl.cam.ac.uk/~so294/documents/jfp09.pdf">paper</A> had been lost in the &ldquo;sands of time&rdquo;.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    94
  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
    95
  <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
    96
  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
    97
  expression matchers in Python and Ruby.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    98
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
    99
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   100
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   101
  Now the authors from the 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   102
  <A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/ppdp12-part-deriv-sub-match.pdf">PPDP'12-paper</A> mentioned 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   103
  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
   104
  (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
   105
  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
   106
  in this project is to find out how good they actually are by implementing the results from their paper. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   107
  Their approach is based on the concept of partial derivatives introduced in 1994 by
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   108
  <A HREF="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.56.2509&rep=rep1&type=pdf">Valentin Antimirov</A>.
465
4dac76eb27d9 updated
Christian Urban <urbanc@in.tum.de>
parents: 285
diff changeset
   109
  I used them once myself in a <A HREF="http://nms.kcl.ac.uk/christian.urban/Publications/rexp.pdf">paper</A> 
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   110
  in order to prove the <A HREF="http://en.wikipedia.org/wiki/Myhill–Nerode_theorem">Myhill-Nerode theorem</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   111
  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
   112
  with my simple rainy-afternoon matcher and potentially &ldquo;blow away&rdquo; the regular expression matchers 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   113
  in Python and Ruby (and possibly in Scala too).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   114
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   115
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   116
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   117
  <B>Literature:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   118
  The place to start with this project is obviously this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   119
  <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
   120
  Traditional methods for regular expression matching are explained
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   121
  in the Wikipedia articles 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   122
  <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
   123
  <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
   124
  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
   125
  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
   126
  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
   127
  <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
   128
  done with love. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   129
  Finally, there are millions of other pointers about regular expression
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   130
  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
   131
  <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
   132
  Test cases for &ldquo;<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>&rdquo;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   133
  regular expressions can be obtained from <A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   134
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   135
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   136
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   137
  <B>Skills:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   138
  This is a project for a student with an interest in theory and some
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   139
  reasonable programming skills. The project can be easily implemented
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   140
  in functional languages like
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   141
  <A HREF="http://www.scala-lang.org/">Scala</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   142
  F#, 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   143
  <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
   144
  <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
   145
  can be also used, but seem much less convenient.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   146
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   147
  
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   148
<li> <H4>[CU2] A Compiler for a Simple Programming Language</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   149
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   150
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   151
  <b>Description:</b> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   152
  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
   153
  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
   154
  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
   155
  <A HREF="https://github.com/chameco/Shade">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   156
  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
   157
  programming language following this 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   158
  <A HREF="http://www.cs.princeton.edu/~dpw/papers/tal-toplas.pdf">paper</A> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   159
  (also described <A HREF="http://www.cs.princeton.edu/~dpw/papers/tal-tr.pdf">here</A>).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   160
  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
   161
  <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
   162
  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
   163
  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
   164
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   165
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   166
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   167
  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
   168
  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
   169
  assume there are infinitely many registers. The goal of this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   170
  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
   171
  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
   172
  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
   173
  my naive machine code and virtual machine. The project
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   174
  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
   175
  real machine code. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   176
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   177
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   178
  <p>
285
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 278
diff changeset
   179
  An alternative is to not generate machine code, but build a compiler that compiles to
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   180
  <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
   181
  browsers and therefore is a favourite
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   182
  vehicle for Web-programming. Some call it <B>the</B> scripting language of the Web.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   183
  Unfortunately, JavaScript is probably one of the worst
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   184
  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
   185
  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
   186
  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
   187
  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
   188
  <A HREF="https://github.com/kripken/emscripten/wiki">emscripten</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   189
  There is a <A HREF="https://github.com/kripken/emscripten/wiki/Tutorial">tutorial</A> for emscripten
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   190
  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
   191
  <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
   192
  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
   193
  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
   194
  code to JavaScript.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   195
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   196
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   197
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   198
  <B>Literature:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   199
  There is a lot of literature about compilers 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   200
  (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
   201
  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
   202
  <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
   203
  about implementing compilers by 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   204
  <A HREF="http://tratt.net/laurie/">Laurie Tratt</A> is 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   205
  <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
   206
  An online book about the Art of Assembly Language is
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   207
  <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
   208
  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
   209
  Intel's official manual for the x86 instruction is 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   210
  <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
   211
  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
   212
  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
   213
  for the intermediate language of the <A HREF="http://llvm.org">LLVM</A> compiler
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   214
  (also described <A HREF="https://wiki.aalto.fi/display/t1065450/LLVM+IR">here</A> and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   215
  <A HREF="http://llvm.org/docs/LangRef.html">here</A>). If you want to see
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   216
  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
   217
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   218
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   219
  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
   220
  <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
   221
  A project from which you can draw inspiration is this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   222
  <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
   223
  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
   224
  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
   225
  <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
   226
  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
   227
  forget <A HREF="http://www.typescriptlang.org">TypeScript</A> developed by Microsoft. The main
278
7e056bb8c9ab updated
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 277
diff changeset
   228
  difference between these projects and this one is that they translate into relatively high-level
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   229
  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
   230
  <A HREF="https://github.com/kripken/emscripten/wiki">emscripten</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   231
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   232
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   233
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   234
  <B>Skills:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   235
  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
   236
  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
   237
  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
   238
  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
   239
  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
   240
  language. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   241
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   242
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   243
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   244
  <B>PS:</B> Compiler projects like this one consistently received high marks in the past.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   245
  I suprvised four so far and none of them received a mark below 70% - one even was awarded a prize.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   246
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   247
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   248
<li> <H4>[CU3] Slide-Making in the Web-Age</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   249
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
  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
   252
  <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
   253
  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
   254
  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
   255
  LaTeX produces very pleasantly looking documents, can deal nicely with mathematical
258
cb7f2f627278 updated
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 257
diff changeset
   256
  formulas and is very flexible. If you are interested, <A HREF="http://openwetware.org/wiki/Word_vs._LaTeX">here</A>
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   257
  is a side-by-side comparison between Word and LaTeX (which LaTeX &ldquo;wins&rdquo; with 18 out of 21 points).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   258
  Computer scientists not only use LaTeX for documents,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   259
  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
   260
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   261
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   262
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   263
  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
   264
  slides. Unlike documents, which are typically &ldquo;static&rdquo; and published in a book or journal,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   265
  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
   266
  only later be revealed as the &ldquo;story&rdquo; of a talk or lecture demands.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   267
  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
   268
  calculation is best explained by highlighting the changing data.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   269
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   270
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   271
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   272
  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
   273
  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
   274
  links to 22 slide-generating programs using this combination of technologies. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   275
  <A HREF="http://www.impressivewebs.com/html-slidedeck-toolkits/">Here</A> are even more such
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   276
  projects. However, the problem with all of these project is that they depend heavily on the users being
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   277
  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
   278
  &ldquo;normal&rdquo; 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
   279
  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
   280
  slides that can be displayed in a web-browser.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   281
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   282
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   283
 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   284
 This sounds complicated, but there is already some help available:
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   285
 <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
   286
 be used to display mathematical text, for example
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   287
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   288
 <blockquote>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   289
 <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
   290
 \(x = {-b \pm \sqrt{b^2-4ac} \over 2a}\).</p>
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
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   293
 by writing code in the familiar LaTeX-way. This can be reused. There are also plenty of JavaScript
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   294
 libraries for graphical animations (for example
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   295
 <A HREF="http://raphaeljs.com">Raphael</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   296
 <A HREF="http://svgjs.com">SVG.JS</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   297
 <A HREF="http://bonsaijs.org">Bonsaijs</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   298
 <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
   299
 slides could come from the LaTeX packages <A HREF="http://en.wikipedia.org/wiki/Beamer_(LaTeX)">Beamer</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   300
 and <A HREF="http://en.wikipedia.org/wiki/PGF/TikZ">PGF/TikZ</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   301
 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   302
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   303
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   304
  <B>Skills:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   305
  This is a project requires good knowledge of JavaScript. You need to be able to
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   306
  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
   307
  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
   308
  A parser generator for JavaScript is <A HREF="http://pegjs.majda.cz">here</A>. There are probably also
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   309
  others.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   310
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   311
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   312
<li> <H4>[CU4] An Online Student Voting System</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   313
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   314
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   315
  <B>Description:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   316
  One of the more annoying aspects of giving a lecture is to ask a question
277
96f9be2b8188 updated marks
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 258
diff changeset
   317
  to the students and no matter how easy the question is to not 
96f9be2b8188 updated marks
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 258
diff changeset
   318
  receive any answer. Recently, the online course system 
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   319
  <A HREF="http://www.udacity.com">Udacity</A> made an art out of
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   320
  asking questions during lectures (see for example the
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   321
  <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
   322
  course CS253).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   323
  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
   324
  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
   325
  For  &ldquo;real-world&rdquo; lectures, the department has some 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   326
  <A HREF="http://en.wikipedia.org/wiki/Audience_response">clickers</A>
277
96f9be2b8188 updated marks
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 258
diff changeset
   327
  (these are little devices which for a part of an audience response systems). However, 
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   328
  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
   329
  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
   330
  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
   331
  be improved.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   332
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   333
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   334
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   335
  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
   336
  polling system. The lecturer should be able to prepare 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   337
  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
   338
  show them during the lecture. The students
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   339
  can give their answers by clicking on the corresponding webpage.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   340
  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
   341
  immediately. Such a system is sometimes called
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   342
  <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
   343
  There are a number of commercial
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   344
  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
   345
  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
   346
  what they provide. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   347
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   348
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   349
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   350
  The problem of student polling is not as hard as 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   351
  <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
   352
  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
   353
  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
   354
  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
   355
  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
   356
  by setting appropriate cookies on the students
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   357
  computers or smart phones.
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
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   360
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   361
  <B>Literature:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   362
  The project requires fluency in a web-programming language (for example 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   363
  <A HREF="http://en.wikipedia.org/wiki/JavaScript">Javascript</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   364
  <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
   365
  <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
   366
  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
   367
  <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
   368
  For web-programming the 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   369
  <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
   370
  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
   371
  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
   372
  To evaluate the answers from the students, Google's 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   373
  <A HREF="https://developers.google.com/chart/image/docs/making_charts">Chart Tools</A>
285
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 278
diff changeset
   374
  might be useful, which is also described in this 
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   375
  <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
   376
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   377
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   378
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   379
  <B>Skills:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   380
  In order to provide convenience for the lecturer, this project needs very good web-programming skills. A 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   381
  <A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker mentality</A>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   382
  (see above) is probably very beneficial: web-programming is an area that only emerged recently and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   383
  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
   384
  languages and tools.
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
<li> <H4>[CU5] An Infrastructure for Displaying and Animating Code in a Web-Browser</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   388
  
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   389
<p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   390
  <B>Description:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   391
  The project aim is to implement an infrastructure for displaying and
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   392
  animating code in a web-browser. The infrastructure should be agnostic
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   393
  with respect to the programming language, but should be configurable.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   394
  I envisage something smaller than the projects 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   395
  <A HREF="http://www.pythontutor.com">here</A> (for Python),
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   396
  <A HREF="http://ideone.com">here</A> (for Java),
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   397
  <A HREF="http://codepad.org">here</A> (for multiple languages),
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   398
  <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>
parents:
diff changeset
   399
  <A HREF="http://repl.it/languages/JavaScript">here</A> (for JavaScript),
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   400
  and <A HREF="http://www.scala-tour.com/#/welcome">here</A> (for Scala).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   401
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   402
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   403
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   404
  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>
parents:
diff changeset
   405
  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>
parents:
diff changeset
   406
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   407
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   408
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   409
  <B>Skills:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   410
  Good skill in lexing and language parsing, as well as being fluent with web programming (for
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   411
  example JavaScript).
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
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   415
<li> <H4>[CU6] Implementation of a Distributed Clock-Synchronisation Algorithm developed at NASA</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   416
  
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   417
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   418
  <B>Description:</B>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   419
  There are many algorithms for synchronising clocks. This
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   420
  <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>
parents:
diff changeset
   421
  describes a new algorithm for clocks that communicate by exchanging
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   422
  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>
parents:
diff changeset
   423
  A slightly longer and more detailed paper about the algorithm is 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   424
  <A HREF="http://hdl.handle.net/2060/20110020812">here</A>.
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   425
  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>
parents:
diff changeset
   426
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   427
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   428
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   429
  <B>Literature:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   430
  There is a wide range of literature on clock synchronisation algorithms. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   431
  Some pointers are given in this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   432
  <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>
parents:
diff changeset
   433
  which describes the algorithm to be implemented in this project. Pointers
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   434
  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>
parents:
diff changeset
   435
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   436
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   437
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   438
  <B>Skills:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   439
  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>
parents:
diff changeset
   440
  concurrency. You can do this for example in the programming language
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   441
  <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>
parents:
diff changeset
   442
  <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>
parents:
diff changeset
   443
  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>
parents:
diff changeset
   444
  are some examples that explain how to implement exchanging messages between actors. 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   445
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   446
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   447
<li> <H4>[CU7] Raspberry Pi's and Arduinos</H4>
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   448
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
  <B>Description:</B>
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   451
  This project is for true hackers! <A HREF="http://en.wikipedia.org/wiki/Raspberry_Pi">Raspberry Pi's</A>
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   452
  are small Linux computers the size of a credit-card and only cost &pound;34 (see picture left below). They were introduced
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   453
  in 2012 and people went crazy...well some of them. There is a
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   454
  <A HREF="https://plus.google.com/communities/113390432655174294208?hl=en">Google+</A> community about Raspberry Pi's that has more
285
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 278
diff changeset
   455
  than 150k of followers. It is hard to keep up with what people do with these small computers. The possibilities
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   456
  seem to be limitless. The main resource for Raspberry Pi's is <A HREF="http://www.raspberrypi.org">here</A>.
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   457
  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
   458
  <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
   459
  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
   460
  Google just released a
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   461
  <A HREF="http://googlecreativelab.github.io/coder/">framework</A>
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   462
  for web-programming and for turning Raspberry Pi's into webservers.
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   463
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   464
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   465
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   466
  <A HREF="http://en.wikipedia.org/wiki/Arduino">Arduinos</A> are slightly older (from 2005) but still very cool (see picture right below). They
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   467
  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
   468
  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
   469
  is a lot of material <A HREF="https://www.google.co.uk/search?q=arduino">available</A> about Arduinos.
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   470
  The main reference is <A HREF="http://www.arduino.cc">here</A>. Like the Raspberry Pi's, the good thing about
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   471
  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
   472
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   473
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   474
  <p>
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   475
  I have two such Raspberry Pi's including wifi-connectors and two <A HREF="http://www.raspberrypi.org/camera">cameras<A>.
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   476
  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
   477
  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
   478
  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
   479
  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
   480
  <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
   481
  you whether it is raining or cloudy). There are plenty more ideas listed
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   482
  <A HREF="http://www.raspberrypi.org/phpBB3/viewforum.php?f=15">here</A> for Raspberry Pi's and
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   483
  <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
   484
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   485
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   486
  <p>
257
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 255
diff changeset
   487
  There are essentially two kinds of projects: One is purely software-based. Software projects for Raspberry Pi's are often
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   488
  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
   489
  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
   490
  <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
   491
  <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
   492
  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
   493
  <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
   494
  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
   495
  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
   496
  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
   497
  involving new hardware: these devices
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   498
  can be destroyed (if &ldquo;Vin connected to GND&rdquo; or &ldquo;drawing more than 30mA from a GPIO&rdquo;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   499
  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
   500
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   501
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   502
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   503
  <center>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   504
  <img style="-webkit-user-select: none; cursor: -webkit-zoom-in;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   505
  "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
   506
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   507
  <img style="-webkit-user-select: none; cursor: -webkit-zoom-in;
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   508
  "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
   509
  </center>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   510
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   511
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   512
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   513
  <B>Skills:</B> 
255
a4579bd79197 updated
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 254
diff changeset
   514
  Well, you must be a hacker; happy to make things. Your desk might look like this:
254
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 253
diff changeset
   515
  <center>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 253
diff changeset
   516
  <img style="-webkit-user-select: none; cursor: -webkit-zoom-in;
465
4dac76eb27d9 updated
Christian Urban <urbanc@in.tum.de>
parents: 285
diff changeset
   517
  "src="http://nms.kcl.ac.uk/christian.urban/rpi-photo.jpg" width="209" height="313">
254
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 253
diff changeset
   518
  </center>
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   519
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   520
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   521
254
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 253
diff changeset
   522
<li> <H4>[CU8] Proving the Correctness of Programs</H4>
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   523
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   524
 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   525
 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
   526
 <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
   527
 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
   528
 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
   529
 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
   530
 scheduling algorithm, called
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   531
 <A HREF="http://en.wikipedia.org/wiki/Priority_inheritance">Priority Inheritance</A>,
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   532
 for real time operating systems. This scheduling algorithm is part of the operating
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   533
 system that drives, for example, the 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   534
 <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
   535
 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
   536
 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
   537
 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
   538
 for an explanation what happened).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   539
 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
   540
 establish the correctness of some optimisations in this
465
4dac76eb27d9 updated
Christian Urban <urbanc@in.tum.de>
parents: 285
diff changeset
   541
 <A HREF="http://nms.kcl.ac.uk/christian.urban/Publications/pip.pdf">paper</A>.
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   542
 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   543
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   544
 <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   545
 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
   546
 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
   547
 regular expression matcher by Sulzmann and Lu in project [CU1]). 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   548
 The aim of this
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   549
 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
   550
 it always computes the correct result).
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   551
 </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   552
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   553
  <p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   554
  <B>Skills:</B> 
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   555
  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
   556
  </p>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   557
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
<li> <H4>Earlier Projects</H4>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   560
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   561
 I am also open to project suggestions from you. You might find some inspiration from my earlier projects:
465
4dac76eb27d9 updated
Christian Urban <urbanc@in.tum.de>
parents: 285
diff changeset
   562
 <A HREF="http://nms.kcl.ac.uk/christian.urban/bsc-projects-12.html">BSc 2012/13</A>, 
4dac76eb27d9 updated
Christian Urban <urbanc@in.tum.de>
parents: 285
diff changeset
   563
 <A HREF="http://nms.kcl.ac.uk/christian.urban/msc-projects-12.html">MSc 2012/13</A> 
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   564
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   565
</ul>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   566
</TD>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   567
</TR>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   568
</TABLE>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   569
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   570
<P>
285
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents: 278
diff changeset
   571
<!-- hhmts start --> Last modified: Sat Jun 21 08:22:20 BST 2014 <!-- hhmts end -->
253
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   572
<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
   573
</BODY>
Christian Urban <christian dot urban at kcl dot ac dot uk>
parents:
diff changeset
   574
</HTML>