public_html: bsc-projects-12.html@4dac76eb27d9

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<HEAD>
<TITLE>2012/13 BSc Projects</TITLE>
<BASE HREF="http://nms.kcl.ac.uk/christian.urban/">
<script type="text/javascript" src="striper.js"></script>
<link rel="stylesheet" href="nominal.css">
</HEAD>
<BODY TEXT="#000000" 
      BGCOLOR="#4169E1" 
      LINK="#0000EF" 
      VLINK="#51188E" 
      ALINK="#FF0000"
      ONLOAD="striper('ul','striped','li','first,second')">



<TABLE WIDTH="100%" 
       BGCOLOR="#4169E1" 
       BORDER="0"   
       FRAME="border"  
       CELLPADDING="10"     
       CELLSPACING="2"
       RULES="all">

<TR>
<TD BGCOLOR="#FFFFFF" 
    WIDTH="75%" 
    VALIGN="TOP">

<H2>2012/13 BSc Projects</H2>
<H4>Supervisor: Christian Urban</H4> 
<H4>Email: christian dot urban at kcl dot ac dot uk,  Office: Strand Building S1.27</H4>
<H4>If you are interested in a project, please send me an email and we can discuss details. Please include
a short description about your programming skills and Computer Science background in your first email. 
I will also need your King's username in order to book the project for you. Thanks.</H4> 

<H4>Note that besides being a lecturer at the theoretical end of Computer Science, I am also a passionate
    <A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker</A> &hellip;
    defined as &ldquo;a person who enjoys exploring the details of programmable systems and 
    stretching their capabilities, as opposed to most users, who prefer to learn only the minimum 
    necessary.&rdquo; I am always happy to supervise like-minded students.</H4>  

<ul class="striped">
<li> <H4>[CU1] Automata Minimisation</H4>

  <p>
  <B>Description:</b>  
  <A HREF="http://en.wikipedia.org/wiki/Deterministic_finite_automaton">Deterministic finite automata</A> 
  have many uses in Computer Science, for example for lexing
  program code. In order to improve their run-time, automata need to be minimised, that 
  is transformed into equivalent automata with the smallest possible number of state 
  nodes. 
  </p>

  <p>
  There is a little known method for minimising deterministic finite
  automata by <A HREF="http://en.wikipedia.org/wiki/Janusz_Brzozowski_(computer_scientist)">
  Janusz Brzozowski</A>. 
  This method first reverses the edges of an automaton, which produces
  a potentially non-deterministic automaton. The non-deterministic automaton is 
  then determinised using the usual powerset construction. This is repeated
  once more and voila you obtain a minimised version of the automaton
  you started with. It is rather surprising that this method works at all: 
  the powerset construction might produce an automaton with an exponentially 
  larger number of states, completely contrary to the idea of minimising the
  number of states. The task of this project is to implement this method, check that
  it actually works with some examples and
  compare it with more traditional methods for automata minimisation
  (in terms of run-time, code complexity, etc). Examples can be 
  obtained by translating regular expressions into automata. A natural extension
  of the project is therefore to implement a recogniser for regular expressions
  following, for example, this <A HREF="http://www.cl.cam.ac.uk/~so294/documents/jfp09.pdf">paper</A>. 
  </p>

  <p>
  <B>Literature:</B> 
  A good place to start with this project are the wikipedia articles 
  <A HREF="http://en.wikipedia.org/wiki/DFA_minimization">here</A> and 
  <A HREF="http://en.wikipedia.org/wiki/Powerset_construction">here</A>.
  The authoritative <A HREF="http://infolab.stanford.edu/~ullman/ialc.html">book</A>
  on automata is by John Hopcroft and Jeffrey Ullmann (available in the library). 
  There is also an online course about automata by Ullman at 
  <A HREF="https://www.coursera.org/course/automata">Coursera</A>, though IMHO not 
  done with love. There
  is also the book <i>Automata and Computability</i> by 
  <A HREF="http://www.cs.cornell.edu/~kozen/">Dexter Kozen</A> including more 
  advanced material about automata.
  Finally, there are millions of other pointers about automata
  minimisation on the web. Finally, I will give a lot of the background in
  my Automata and Formal Languages course (6CCS3AFL), which starts in September.
  </p>

  <p>
  <B>Skills:</B> 
  This is a project for a student with an interest in theory and some
  reasonable programming skills. The project can be easily implemented
  in languages like
  <A HREF="http://www.scala-lang.org/">Scala</A>,
  <A HREF="http://en.wikipedia.org/wiki/Standard_ML">ML</A>,  
  <A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>, 
  <A HREF="http://www.python.org">Python</A>, etc.
  </p>

<li> <H4>[CU2] Equivalence Checking of Regular Expressions</H4>

  <p>
  <B>Description:</b>  
  Solving the problem of deciding the equivalence of regular expressions can be used
  to decide a number of problems in automated reasoning. Recently, 
  <A HREF="http://www.cs.unibo.it/~asperti/">Andreas Asperti</A>
  proposed a simple method for deciding regular expression equivalence described
  <A HREF="http://www.cs.unibo.it/~asperti/PAPERS/compact.pdf">here</A>. 
  The task is to implement this method and test it on examples.
  It would be also interesting to see whether Asperti's method applies to
  extended regular expressions, described
  <A HREF="http://ww2.cs.mu.oz.au/~sulzmann/manuscript/reg-exp-partial-derivatives.pdf">here</A>.
  </p>

  <p>
  <B>Literature:</B> 
  The central literature is obviously the papers
  <A HREF="http://www.cs.unibo.it/~asperti/PAPERS/compact.pdf">here</A> and
  <A HREF="http://ww2.cs.mu.oz.au/~sulzmann/manuscript/reg-exp-partial-derivatives.pdf">here</A>.
  Asperti has also some slides <A HREF="http://www.cs.unibo.it/~asperti/SLIDES/regular.pdf">here</a>.
  More references about regular expressions can be found
  <A HREF="http://en.wikipedia.org/wiki/Regular_expression">here</A>. Like in
  [CU1], I will give a lot of the background pf this project in
  my Automata and Formal Languages course (6CCS3AFL).
  </p>  

  <p>
  <B>Skills:</B> 
  This is a project for a student with a passion for theory and some
  reasonable programming skills. The project can be easily implemented
  in languages like Scala
  <A HREF="http://www.scala-lang.org/">Scala</A>,
  <A HREF="http://en.wikipedia.org/wiki/Standard_ML">ML</A>,  
  <A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>, 
  <A HREF="http://www.python.org">Python</A>, etc.
  Being able to read <A HREF="http://haskell.org/haskellwiki/Haskell">Haskell</A>
  code is beneficial for the part involving extended regular expressions.
  </p>

<li> <H4>[CU3] Machine Code Generation for a Simple Compiler</H4>

  <p>
  <b>Description:</b> 
  Compilers translate high-level programs that humans can read and write into
  efficient machine code that can be run on a CPU or virtual machine.
  I recently implemented a very simple compiler for a very simple functional
  programming language following this 
  <A HREF="http://www.cs.princeton.edu/~dpw/papers/tal-toplas.pdf">paper</A> 
  (also described <A HREF="http://www.cs.princeton.edu/~dpw/papers/tal-tr.pdf">here</A>).
  My code, written in <A HREF="http://www.scala-lang.org/">Scala</A>, of this compiler is 
  <A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/compiler.scala">here</A>.
  The compiler can deal with simple programs involving natural numbers, such
  as Fibonacci numbers
  or factorial (but it can be easily extended - that is not the point).
  </p>

  <p>
  While the hard work has been done (understanding the two papers above),
  my compiler only produces some idealised machine code. For example I
  assume there are infinitely many registers. The goal of this
  project is to generate machine code that is more realistic and can
  run on a CPU, like x86, or run on a virtual machine, say the JVM. 
  This gives probably a speedup of thousand times in comparison to
  my naive machine code and virtual machine. The project
  requires to dig into the literature about real CPUs and generating 
  real machine code. 
  </p>

  <p>
  <B>Literature:</B>
  There is a lot of literature about compilers 
  (for example <A HREF="http://www.cs.princeton.edu/~appel/papers/cwc.html">this book</A> -
  I can lend you my copy for the duration of the project). A very good overview article
  about implementing compilers by 
  <A HREF="http://tratt.net/laurie/">Laurie Tratt</A> is 
  <A HREF="http://tratt.net/laurie/tech_articles/articles/how_difficult_is_it_to_write_a_compiler">here</A>.
  An introduction into x86 machine code is <A HREF="http://ianseyler.github.com/easy_x86-64/">here</A>.
  Intel's official manual for the x86 instruction is 
  <A HREF="http://download.intel.com/design/intarch/manuals/24319101.pdf">here</A>. 
  A simple assembler for the JVM is described <A HREF="http://jasmin.sourceforge.net">here</A>.
  An interesting twist of this project is to not generate code for a CPU, but
  for the intermediate language of the <A HREF="http://llvm.org">LLVM</A> compiler
  (also described <A HREF="https://wiki.aalto.fi/display/t1065450/LLVM+IR">here</A> and
  <A HREF="http://llvm.org/docs/LangRef.html">here</A>). If you want to see
  what machine code looks like you can compile your C-program using gcc -S.
  </p>

  <p>
  <B>Skills:</B> 
  This is a project for a student with a deep interest in programming languages and
  compilers. Since my compiler is implemented in <A HREF="http://www.scala-lang.org/">Scala</A>,
  it would make sense to continue this project in this language. I can be
  of help with questions and books about <A HREF="http://www.scala-lang.org/">Scala</A>.
  But if Scala is a problem, my code can also be translated quickly into any other functional
  language. 
  </p>

<li> <H4>[CU4] Implementation of Register Spilling Algorithms</H4>
  
  <p>
  <b>Description:</b> 
  This project is similar to [CU3]. The emphasis here, however, is on the
  implementation and comparison of register spilling algorithms, also often called register allocation 
  algorithms. They are part of any respectable compiler.  As said
  in [CU3], however, my simple compiler lacks them and assumes an infinite amount of registers instead.
  Real CPUs however only provide a fixed amount of registers (for example
  x86-64 has 16 general purpose registers). Whenever a program needs
  to hold more values than registers, the values need to be &ldquo;spilled&rdquo;
  into the main memory. Register spilling algorithms try to minimise
  this spilling, since fetching values from main memory is a costly 
  operation. 
  </p>

  <p>
  The classic algorithm for register spilling uses a
  <A HREF="http://en.wikipedia.org/wiki/Register_allocation">graph-colouring method</A>.
  However, for some time the <A HREF="http://llvm.org">LLVM</A> compiler
  used a supposedly more efficient method, called the linear scan allocation method
  (described 
  <A HREF="http://www.cs.ucla.edu/~palsberg/course/cs132/linearscan.pdf">here</A>).
  However, it was later decided to abandon this method in favour of 
  a <A HREF="http://blog.llvm.org/2011/09/greedy-register-allocation-in-llvm-30.html">
  greedy register allocation</A> method. It would be nice if this project can find out
  what the issues are with these methods and implement at least one of them for the 
  simple compiler referenced in [CU3].
  </p>

  <p>
  <B>Literature:</B> 
  The graph colouring method is described in Andrew Appel's 
  <A HREF="http://www.cs.princeton.edu/~appel/modern/java/">book</A> on compilers
  (I can give you my copy of this book, if it is not available in the library).
  There is also a survey 
  <A HREF="http://compilers.cs.ucla.edu/fernando/publications/drafts/survey.pdf">article</A> 
  about register allocation algorithms with further pointers.
  </p>

  <p>
  <B>Skills:</B> 
  Same skills as [CU3].
  </p>

<li> <H4>[CU5] A Student Polling System</H4>

  <p>
  <B>Description:</B>
  One of the more annoying aspects of giving a lecture is to ask a question
  to the students and no matter how easy the questions is to not 
  receive an answer. Recently, the online course system 
  <A HREF="http://www.udacity.com">Udacity</A> made an art out of
  asking questions during lectures (see for example the
  <A HREF="http://www.udacity.com/overview/Course/cs253/CourseRev/apr2012">Web Application Engineering</A> 
  course CS253).
  The lecturer there gives multiple-choice questions as part of the lecture and the students need to 
  click on the appropriate answer. This works very well in the online world. 
  For  &ldquo;real-world&rdquo; lectures, the department has some 
  <A HREF="http://en.wikipedia.org/wiki/Audience_response">clickers</A>
  (these are little devices part of an audience response systems). However, 
  they are a logistic nightmare for the lecturer: they need to be distributed 
  during the lecture and collected at the end. Nowadays, where students
  come with their own laptop or smartphone to lectures, this can
  be improved.
  </p>

  <p>
  The task of this project is to implement an online student
  polling system. The lecturer should be able to prepare 
  questions beforehand (encoded as some web-form) and be able to 
  show them during the lecture. The students
  can give their answers by clicking on the corresponding webpage.
  The lecturer can then collect the responses online and evaluate them 
  immediately. Such a system is sometimes called
  <A HREF="http://en.wikipedia.org/wiki/Audience_response#Smartphone_.2F_HTTP_voting">HTML voting</A>. 
  There are a number of commercial
  solutions for this problem, but they are not easy to use (in addition
  to being ridiculously expensive). A good student can easily improve upon
  what they provide. 
  </p>

  <p>
  The problem of student polling is not as hard as 
  <A HREF="http://en.wikipedia.org/wiki/Electronic_voting">electronic voting</A>, 
  which essentially is still an unsolved problem in Computer Science. The
  students only need to be prevented from answering question more than once thus skewing
  any statistics. Unlike electronic voting, no audit trail needs to be kept
  for student polling. Restricting the number of answers can probably be solved 
  by setting appropriate cookies on the students
  computers or smart phones.
  </p>

  <p>
  <B>Literature:</B> 
  The project requires fluency in a web-programming language (for example 
  <A HREF="http://en.wikipedia.org/wiki/JavaScript">Javascript</A>,
  <A HREF="http://en.wikipedia.org/wiki/PHP">PHP</A>, 
  Java, <A HREF="http://www.python.org">Python</A>, 
  <A HREF="http://en.wikipedia.org/wiki/Go_(programming_language)">Go</A>, 
  <A HREF="http://www.scala-lang.org/">Scala</A>,
  <A HREF="http://en.wikipedia.org/wiki/Ruby_(programming_language)">Ruby</A>) 
  and possibly a cloud application platform (for example
  <A HREF="https://developers.google.com/appengine/">Google App Engine</a> or 
  <A HREF="http://www.heroku.com">Heroku</A>).
  For web-programming the 
  <A HREF="http://www.udacity.com/overview/Course/cs253/CourseRev/apr2012">Web Application Engineering</A>
  course at <A HREF="http://www.udacity.com">Udacity</A> is a good starting point 
  to be aware of the issues involved. This course uses <A HREF="http://www.python.org">Python</A>.
  To evaluate the answers from the student, Google's 
  <A HREF="https://developers.google.com/chart/image/docs/making_charts">Chart Tools</A>
  might be useful, which ar also described in this 
  <A HREF="http://www.youtube.com/watch?v=NZtgT4jgnE8">youtube</A> video.
  </p>

  <p>
  <B>Skills:</B> 
  In order to provide convenience for the lecturer, this project needs very good web-programming skills. A 
  <A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacker mentality</A>
  (see above) is probably very beneficial: web-programming is an area that only emerged recently and
  many tools still lack maturity. You probably have to experiment a lot with several different
  languages and tools.
  </p>

<li> <H4>[CU6] Implementation of a Distributed Clock-Synchronisation Algorithm developed at NASA</H4>
  
  <p>
  <B>Description:</B>
  There are many algorithms for synchronising clocks. This
  <A HREF="http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/20120000054_2011025573.pdf">paper</A> 
  describes a new algorithm for clocks that communicate by exchanging
  messages and thereby reach a state in which (within some bound) all clocks are synchronised.
  A slightly longer and more detailed paper about the algorithm is 
  <A HREF="http://hdl.handle.net/2060/20110020812">here</A>.
  The point of this project is to implement this algorithm and simulate networks of clocks.
  </p>

  <p>
  <B>Literature:</B> 
  There is a wide range of literature on clock syncronisation algorithms. 
  Some pointers are given in this
  <A HREF="http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/20120000054_2011025573.pdf">paper</A>,
  which describes the algorithm to be implemented in this project. Pointers
  are given also <A HREF="http://en.wikipedia.org/wiki/Clock_synchronization">here</A>.
  </p>

  <p>
  <B>Skills:</B> 
  In order to implement a simulation of a network of clocks, you need to tackle
  concurrency. You can do this for example in the programming language
  <A HREF="http://www.scala-lang.org/">Scala</A> with the help of the 
  <A HREF="http://akka.io">Akka</a> library. This library enables you to send messages
  between different <I>actors</I>. <A HREF="http://www.scala-lang.org/node/242">Here</A> 
  are some examples that explain how to implement exchanging messages between actors. 
  </p>

</ul>
</TD>
</TR>
</TABLE>

<P>
<!-- Created: Tue Mar  4 00:23:25 GMT 1997 -->
<!-- hhmts start -->
Last modified: Wed Sep 12 16:30:03 GMT 2012
<!-- hhmts end -->
<a href="http://validator.w3.org/check/referer">[Validate this page.]</a>
</BODY>
</HTML>
author	Christian Urban <urbanc@in.tum.de>
	Sat, 28 Jan 2017 07:17:00 +0000 (2017-01-28)
changeset 465	4dac76eb27d9
parent 151	ad63f8272397
permissions	-rw-r--r--