public_html: comparison msc-projects-12.html

equal deleted inserted replaced

-:d99c0026ebaf
+:89c9fcb211a8
 <A HREF="http://www.home.hs-karlsruhe.de/~suma0002/publications/ppdp12-part-deriv-sub-match.pdf">this paper</A>
 about regular expression matching and partial derivatives was presented this summer at the international
 PPDP'12 conference. The task in this project is to implement the results from this paper.</p>
 <p>The background for this project is that some regular expressions are
-&quot;<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>&quot;
+&ldquo;<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>&rdquo;
-and can &quot;stab you in the back&quot; according to
+and can &ldquo;stab you in the back&rdquo; according to
 this <A HREF="http://tech.blog.cueup.com/regular-expressions-will-stab-you-in-the-back">blog post</A>.
 For example, if you use in <A HREF="http://www.python.org">Python</A> or
 in <A HREF="http://www.ruby-lang.org/en/">Ruby</A> (probably also in other mainstream programming languages) the
 innocently looking regular expression <code>a?{28}a{28}</code> and match it, say, against the string
 <code>aaaaaaaaaaaaaaaaaaaaaaaaaaaa</code> (that is 28 <code>a</code>s), you will soon notice that your CPU usage goes to 100%. In fact,
 Python and Ruby need approximately 30 seconds of hard work for matching this string. You can try it for yourself:
 <A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/cgi-bin/repos.cgi/afl-material/raw-file/tip/re.py">re.py</A> (Python version) and
 <A HREF="http://www.dcs.kcl.ac.uk/staff/urbanc/cgi-bin/repos.cgi/afl-material/raw-file/tip/re-internal.rb">re.rb</A>
 (Ruby version). You can imagine an attacker
 mounting a nice <A HREF="http://en.wikipedia.org/wiki/Denial-of-service_attack">DoS attack</A> against
-your program if it contains such an &quot;evil&quot; regular expression. Actually
+your program if it contains such an &ldquo;evil&rdquo; regular expression. Actually
 <A HREF="http://www.scala-lang.org/">Scala</A> (and also Java) are almost immune from such
 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
 the regular expression and string further to, say, 4,600 <code>a</code>s, then you get a <code>StackOverflowError</code>
 potentially crashing your program.
 </p>
 official matcher maxes out at 4,600 <code>a</code>s). My matcher is approximately
 85 lines of code and based on the concept of
 <A HREF="http://lambda-the-ultimate.org/node/2293">derivatives of regular expressions</A>.
 These derivatives were introduced in 1964 by <A HREF="http://en.wikipedia.org/wiki/Janusz_Brzozowski_(computer_scientist)">
 Janusz Brzozowski</A>, but according to this
-<A HREF="http://www.cl.cam.ac.uk/~so294/documents/jfp09.pdf">paper</A> had been lost in the &quot;sands of time&quot;.
+<A HREF="http://www.cl.cam.ac.uk/~so294/documents/jfp09.pdf">paper</A> had been lost in the &ldquo;sands of time&rdquo;.
 The advantage of derivatives is that they side-step completely the usual
 <A HREF="http://hackingoff.com/compilers/regular-expression-to-nfa-dfa">translations</A> of regular expressions
 into NFAs or DFAs, which can introduce the exponential behaviour exhibited by the regular
 expression matchers in Python and Ruby.
 </p>
 Their approach is based on the concept of partial derivatives introduced in 1994 by
 <A HREF="http://reference.kfupm.edu.sa/content/p/a/partial_derivatives_of_regular_expressio_1319383.pdf">Valentin Antimirov</A>.
 I used them once myself in a <A HREF="http://www.inf.kcl.ac.uk/staff/urbanc/Publications/rexp.pdf">paper</A>
 in order to prove the <A HREF="http://en.wikipedia.org/wiki/Myhill–Nerode_theorem">Myhill-Nerode theorem</A>.
 So I know they are worth their money. Still, it would be interesting to actually compare their results
-with my simple rainy-afternoon matcher and potentially &quot;blow away&quot; the regular expression matchers
+with my simple rainy-afternoon matcher and potentially &ldquo;blow away&rdquo; the regular expression matchers
 in Python and Ruby (and possibly in Scala too).
 </p>
 <p>
 <B>Literature:</B>
 on automata and regular expressions is by John Hopcroft and Jeffrey Ullmann (available in the library).
 There is also an online course about this topic by Ullman at
 <A HREF="https://www.coursera.org/course/automata">Coursera</A>, though IMHO not
 done with love.
 Finally, there are millions of other pointers about regular expression
-matching on the Net. Test cases for &quot;<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>&quot;
+matching on the Net. Test cases for &ldquo;<A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">evil</A>&rdquo;
 regular expressions can be obtained from <A HREF="http://en.wikipedia.org/wiki/ReDoS#Examples">here</A>.
 </p>
 <p>
 <B>Skills:</B>
 <p>
 <B>Skills:</B>
 This is a project for a student with very good programming
 and <A HREF="http://en.wikipedia.org/wiki/Hacker_(programmer_subculture)">hacking</A> skills.
-Some knowledge in JavaScript, HTML and CSS cannot hurt The algorithms from automata
+Some knowledge in JavaScript, HTML and CSS cannot hurt. The algorithms from automata
 theory are fairly standard material.
 </p>
 <!--
 <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.
+in [CU3] 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
 computers or smart phones.
 </p>
 <p>
 However, there is one restriction that makes this project harder than it seems
-as first sight. The department does not allow large server applications and databases
+at first sight: The department does not allow large server applications and databases
-to be run on calcium - the central server in the department. So the problem should be solved with as few resources needed
+to be run on calcium, which is the central server in the department. So the problem
-on the &quot;back-end&quot; which collects the votes.
+should be solved with as few resources as possible
+on the &ldquo;back-end&rdquo; collecting the votes.
 </p>
 <p>
 <B>Literature:</B>
 The project requires fluency in a web-programming language (for example

changeset 165	89c9fcb211a8
parent 164	d99c0026ebaf
child 166	78e14199b429