Archive for January, 2008

Thue in Haskell

Jan 27, 2008 by olsner

Yesterday, I wrote a Thue implementation in Haskell. At this point, the implementation is painfully slow (about 35 minutes to run the brainfuck "Hello World!" through the BF Thue interpreter on my MacBook, as compared to about 4 minutes for the python Thue implementation run in python 2.5.1). I'm thinking I should a) should use ByteString's instead of String, and b) use some smarter algorithm for matching the rules (instead of untilDone (foldl applyRule input rules), it'd be something more like compiling an automaton out of all rules and untilDone (run automaton)). By reducing the number of rules (eliminating the 50 or so #::=# rules, which are comments in idiomatic Thue but don't strictly need special processing), I could squeeze about twice the performance out of it - this optimization brought the execution time down to 35 minutes. I need at least 10x the performance before this program is anything to brag about!

Another idea for the future is to implement parallel Thue by splitting up the state and then replacing in the parts until no replacements can be done in parallel, then running a few iterations serially on the whole state. You could also just synchronize once and move the split-point - which would eliminate the problem of deciding when to start going parallell again since you'd never really go serial. With the language designed to allow random replacement order, any valid Thue program already contains the synchronization needed to make it evaluate the right thing and e.g. output things in the correct order, so this is perfectly safe provided you have a correct implementation and correct programs.

Although it's fun to make things go fast, I think parallel Thue would be much more interesting as it might even be something that's never been done before!

Anyway, if you want to try it out, here's my Thue darcs repository, containing the haskell source and the BF interpreter in Thue with the BF Hello world program I've been using for testing. It should take exactly 287197 steps (and heaps of time) to complete the execution and print "Hello world!\n" as a series of binary numbers separated by underscores.

BF+Thue in mod_rewrite

Jan 27, 2008 by olsner

Based on the mod_rewrite experiment from the other week, I hacked up a small Thue to mod_rewrite compiler in sed. For testing, I have used the brainfuck interpreter in Thue (as far as I can see, this is like the only example of a "real-world" Thue program). I tested this on the small 3+5 examples included in the BF Thue distribution and tried to test it on BF Hello World, but apache runs out of memory before completing the rewriting ;-)

Anyway, in this BF interpreter, the interpretation is bootstrapped by a circumflex, '^', so the interpreter placeholder I introduced last week had a natural use allowing us to simply enter the brainfuck program as a URL, followed by a colon and input as binary underscore-separated numbers (terminated by 0_), and have patience.

The Thue interpreter needs to keep track of a few bits of state - all of this has to be encoded in some reliable way in the URL we're continually rewriting:

  • Have we added the interpreter? For BF+Thue, this is '^' which is really something that has leaked from this one specific Thue program into the interpreter - which is really ugly, but hey, at least it was easy. Anyway, since we're in the root of the virtual host, we can use the leading slash to encode this information - simply remove it after adding the interpreter, and we can match on ^/(.*)$ to determine whether we should add the bootstrap. (I have since realized that there is not much that prevents a malicious Thue program to output a slash as its first character, thereby breaking my entire system. Well, well, in version 2.0 I'll replace this with a more robust encoding system.)
  • The current output string. Stored in the first part of the URL, terminated by a 'q' (I'm having real trouble here with selecting characters unused in the program and all its possible states - otherwise matching would be a bitch)
  • Did we rewrite anything in the last pass over the state? If nothing was rewritten, we must terminate the program. After the 'q' that terminates the output string, we store an 'r' before starting going through the rules and then every time we apply a rule we remove the 'r'. If the 'r' is still there after having tried every rule in the program, we're done and pass the output string to the printer PHP script.
  • Finally, the current program state is stored after the q and r markers and goes on to the end of the URL.

In the end, this became something quite beautiful in its ugliness, although it could certainly need some robustness work. For example, it blindly relies on the Thue program to never ever use q or r anywhere (and probably a few other things I haven't thought of). This should be changed to a totally robust encoding of anything that the rewrite rules should operate on as data, that can't interfere with the things that are used as control structures and data formatting by the rewrite rules.

Here is the translator sed script in all its regexp-wtf glory, highlighted as Perl since GeSHi unfortunately doesn't have sed highlighting.

(EDIT: Not actually highlighted as Perl anymore since the replacement of wordpress! I have created my own sed highlighter.)

# Remove comments
# Rewrite question marks since they interfere with mod_rewrite by making the
# productions look like requests with query strings, which apache then splits.
# Escape characters with special meanings in regexps.
s/\([.*+(){}^$<>[\\ |]\|\]\)/\\\1/g
# Remove the ::= terminating line since it doesn't define a rule.
# Output rule: ~asf means to print the string "asf" and remove the matched string.
s/^\(.*\)::=~\(.*\)$/RewriteRule ^(.*)qr?(.*)\1(.*)$ $1\2q$2$3 [N]/
# Normal rule: match substring and replace it
s/^\(.*\)::=\(.*\)$/RewriteRule ^(.*)qr?(.*)\1(.*)$ $1q$2\2$3 [N]/

Note that the resulting rewrite rules are meant to be inserted into the mod_rewrite embedded language bootstrap I built in the previous post.

An excursion in mod_rewrite

Jan 21, 2008 by olsner

While setting up my blosxom blog's apache vhost to rewrite URL:s to pass them by the blosxom CGI script, I happened to set up a redirection loop with apache's mod_rewrite module - by accident - and realized that mod_rewrite might be Turing complete. (Always my instinct when something has the ability to loop.) After some more thinking, I realized that this apache module really is a bona fide String rewriting system which can be used to implement both Tag systems and Cellular automata, both of which can be Turing complete. Actually, since mod_rewrite can implement any tag system or cellular automaton, mod_rewrite is Turing complete.

So, if one felt like it, mod_rewrite can be configured with a Turing complete set of rewrite rules such that each accessed URL is a program, and the final URL is the out-data (or a link to a CGI-script that gives back the final output to the user, with suitable decoding). It's possible (trivial, even) to add a first rewrite rule that bootstraps the rewriting with an interpreter string. It's theoretically possible to have this be something like a Haskell interpreter - imagine the possibilities! - a dog-slow Haskell interpreter implemented in an apache config file!

Here's a proof-of-concept implementation of a rewrite system framework in mod_rewrite. All that's missing is a set of rewrite rules to implement something interesting, like 99-bottles-of-beer, bon-digi or a Universal Turing Machine. Note that apache by default limits the number of "internal recursions" to 10, and with any serious use of this you're likely to hit that limit. Increase as needed.

# This file should be included in an Apache2 config file for a VirtualHost.

# Enable rewriting
RewriteEngine on

# First off, set a sensible log level so that you can see what goes wrong
RewriteLogLevel 3
RewriteLog "/var/log/apache2/rewrite/rewrite.log"

# This should only run on the first inputed string to add the interpreter.
# After each run of substitutions, we return to the first rule, so this must
# be safe and idempotent. So, we add the interpeter prefixed by '-' if the
# string does not start with '-'. (This could also be used for input programs
# to replace the interpreter if they like. We could also simply require input
# programs to come with their own interpreters and do nothing here.)
RewriteRule ^([^-].*)$ -INTERPRETER$1

# Add a comma to distinguish unchanged strings. This would be the termination
# condition for our rewrite system. Of course there are other ways to do this,
# for example a regexp which evaluates into the terminate-rule at the bottom.
# Doesn't need to be a comma, of course. If this character is part of the input
# alphabet, it could confuse some things though.
RewriteRule ^(.*)$ ,$1

# This is where the implementation of the entire string rewriting system would
# be. The general format is ,xyz -> xy'z - remove the first comma to mark the
# string as matched and changed (if there was a comma to start with), then
# change the string y to y' (with x and z left unchanged).
RewriteRule ^,?(.*)foo(.*)$ $1bar$2
# ... etc until your rewrite rules implement some turing-complete language, or
# a program that does something interesting.

# If the string has changed, we are not yet done. Loop to the beginning and
# remove the changed-marker. This doesn't change the string at all ('-' is a
# special substitution string that simple uses the original string), just has
# the [N] flag to trigger apache to restart rewriting.
RewriteRule ^[^,].*$ - [N]

# If the string is still unchanged, terminate and apply output-rewriting.

# First, remove the comma
RewriteRule ^,(.*)$ $1 
# Since the example string INTERPRETER is not actually interpreted in this
# example, remove it after applying the rewrite rules.
RewriteRule ^-INTERPRETER(.*)$ $1
# Finally, pass the resulting string to a simple CGI or PHP script to print it
# to the web browser. [L] means to abort rewriting here.
RewriteRule ^(.*)$ /print.php?$1 [L]

WordPress, take 1

Jan 21, 2008 by olsner

This was way easier than blosxom, which after almost a whole day's customization still looks like this. And that's only after stealing dons' stylesheet and template. Plenty of stuff that doesn't really work without hacking it in, or finding a plugin, or the right template (if it's still around - the main blosxom page has plenty of broken links, esp. when it comes to plugins and "flavours").

The whole WordPress installation took perhaps 10-15 minutes, and that's including setting up the database, running the setup wizard, adding a new non-admin account in wordpress and installing markdown, wp-syntax and the Syntax Highlighting with Markdown in Wordpress changes as recommended by conal.

And here's some haskell code!

-- Test some haskell code

fib = 1:1:zipWith (+) fib (tail fib)

And now back in the blog text!

-- And a final line of haskell
main = mapM_ print . take 20 $ fib

I guess this pretty much proves that Wordpress is easier to use and more mature than blosxom. This may well become my long-in-planning programming and haskell blog!

There's a little bit of a problem though. The second run of code lines above becomes highlighted as plain text - this is because the first code block is marked {{lang:haskell}} while the second one isn't. What I'd like here is for them to keep the same language as the previous code block, which would be nice for any literal-haskell-ish blog posts I might post later on. And I really don't want to have to write {{lang:haskell}} every other line of blog post. I could of course let haskell be the default rather than text, but what if I want to blog about some other language? Hmm... Let's see if I get around to hacking markdown/highlighting any time soon.