I write the code

2011-05-23T00:00:00.000-07:00

I was writing some Haskell code where I was constructing a value with lots of record fields, but only cared about one of them initially.


data Type = Type { field1 :: Type1, field2 :: Type2 }

But, omitting the irrelevant fields from the initializer causes a big "Fields not initialised" warning.

So, I figured that, instead of writing out


Type { field1 = value, field2 = undefined }

which was verbose, or


Type { field1 = value }

which resulted in the big warning, I could use


undefined { field1 = value }

which did eliminate the warning.

However,


field1 (undefined { field1 = value })

resulted in an exception. I had expected it to be equivalent to


field1 (Type { field1 = value, field2 = field2 undefined })

but it's not. Since types can have multiple constructors, it's actually equivalent to


field1 (case undefined of { Type { field2 = field2 } -> Type { field1 = value, field2 = field2 })

according to section 3.16.3 in the Haskell report.

2011-05-09T00:00:00.000-07:00

While trying to write concurrent code that forks off threads that sleep before doing some delayed actions using GHCi, version 6.10.4, which is a pretty old version, I found some strange behavior. I used map (flip addUTCTime time) [1..5] to generate the times that the delayed actions should be performed, and the interpreter would lock up. When I changed it to map (flip addUTCTime time) [1,2,3,4,5], everything worked as expected. Maybe there is something tricky in the implementation of enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime]

2011-04-25T00:00:00.000-07:00

I started using Control.Concurrent to write concurrent code in Haskell. It's easier than Java's concurrency model, since values are immutable in Haskell, while one has to worry about values being changed by other threads in Java, which means having to use locks in the right places, and knowing how to use the java.util.concurrent classes.

Of course, it's still possible to deadlock in Haskell, such as with do { a <- takeMVar ma; b <- readMVar mb; putMVar ma a } and do { b <- takeMVar mb; a <- readMVar ma; putMVar mb b }.

Also, there is no getting around dealing with external concurrency issues, such as with databases.

2011-04-11T00:00:00.000-07:00

Thinking about real numbers in the 01_ programming language, the fractional part can be represented as big endian base 1/2. (Or is it little endian? Bits to the left represent larger numbers, but smaller powers of 1/2.) Infinite lists of bits can represent numbers that are ≥ 0 and ≤ 1.

Addition of fractional numbers can be defined as


+/fractional 0a 0b = +/fractional/carry a b 0_ 1_ +/fractional a b.
+/fractional 1a 0b = +/fractional/carry a b 1_ 0_ +/fractional a b.
+/fractional 0a 1b = +/fractional/carry a b 1_ 0_ +/fractional a b.
+/fractional 1a 1b = +/fractional/carry a b 0_ 1_ +/fractional a b.

where evaluating the carry of fractional addition is


+/fractional/carry 0a 0b carry-zero carry-one = carry-zero.
+/fractional/carry 1a 0b carry-zero carry-one = +/fractional/carry a b carry-zero carry-one.
+/fractional/carry 0a 1b carry-zero carry-one = +/fractional/carry a b carry-zero carry-one.
+/fractional/carry 1a 1b carry-zero carry-one = carry-one.

And the subtraction of fractional numbers is


-/fractional 0a 0b = -/fractional/borrow a b 0_ 1_ -/fractional a b.
-/fractional 1a 0b = -/fractional/borrow a b 1_ 0_ -/fractional a b.
-/fractional 0a 1b = -/fractional/borrow a b 1_ 0_ -/fractional a b.
-/fractional 1a 1b = -/fractional/borrow a b 0_ 1_ -/fractional a b.

where evaluating the borrow of fractional subtraction is


-/fractional/borrow 0a 0b borrow-zero borrow-one = -/fractional/borrow a b borrow-zero borrow-one.
-/fractional/borrow 1a 0b borrow-zero borrow-one = borrow-zero.
-/fractional/borrow 0a 1b borrow-zero borrow-one = borrow-one.
-/fractional/borrow 1a 1b borrow-zero borrow-one = -/fractional/borrow a b borrow-zero borrow-one.

Unlike the addition and subtraction of integers, these operations, in general, require infinite time and memory to calculate a finite number of bits, due to the carry and borrow.

2011-03-28T00:00:00.000-07:00

Thinking about numbers in the 01_ programming language, the natural way to represent integers would be to use little-endian base 2. To further simplify things, consider only infinite lists of bits. So the important numbers are


zero = 0 zero.
one = 1 zero.

Negative numbers can also be represented


-one = 1 -one.

Integer addition can be defined as


+/integer 0a 0b = 0 +/integer a b.
+/integer 1a 0b = 1 +/integer a b.
+/integer 0a 1b = 1 +/integer a b.
+/integer 1a 1b = 0 +/integer/carry a b.

where integer addition with carry is


+/integer/carry 0a 0b = 1 +/integer a b.
+/integer/carry 1a 0b = 0 +/integer/carry a b.
+/integer/carry 0a 1b = 0 +/integer/carry a b.
+/integer/carry 1a 1b = 1 +/integer/carry a b.

And integer subtraction is


-/integer 0a 0b = 0 -/integer a b.
-/integer 1a 0b = 1 -/integer a b.
-/integer 0a 1b = 1 -/integer/borrow a b.
-/integer 1a 1b = 0 -/integer a b.

where integer subtraction with borrow is


-/integer/borrow 0a 0b = 1 -/integer/borrow a b.
-/integer/borrow 1a 0b = 0 -/integer a b.
-/integer/borrow 0a 1b = 0 -/integer/borrow a b.
-/integer/borrow 1a 1b = 1 -/integer/borrow a b.

2011-03-14T00:00:00.000-07:00

For work, some of the code is in JSTL (JavaServer Pages Standard Template Library) EL (Expression Language). JSTL EL is weakly typed and dynamically typed. There is no compile-time checking.

One day, a coworker sent me a message saying some stuff stopped working after merging in some of my changes. So I tried running it and it didn't work. I also added logging to the code I changed, which was all Java, and it was working fine. I then tracked it down to some JSTL (untouched by me):


<c:set var="flag" value="{flag1 || flag2}"/>
...
<c:if test="${flag}">
... stuff that failed to appear ...
</c:if>

The first line should have been


<c:set var="flag" value="${flag1 || flag2}"/>

This is the type of stupid mistake that compile-time checking, especially with static typing, can catch.

2011-02-28T00:00:00.000-08:00

I wrote a compiler for 01_ to LLVM (Low Level Virtual Machine) in a week of weekends and evenings. LLVM's static type-checking caught numerous silly mistakes. However, I got bit twice because LLVM does not warn, at least with the default option, when the calling convention declaration of the caller and callee do not match. (I use fastcc because tail-call elimination is important for 01_ programs, and failed to specify it in the caller those two times.) This seems like something that could be checked by the computer and reminds me why I prefer using statically typed programming languages over dynamically typed programming languages.

I wrote the parser in one evening, which I had done before, so it was mostly a matter of getting reacquainted with the Parsec parsing library.

I spent another evening and a weekend learning the LLVM assembly language and writing the runtime library.

I spent another couple of evenings writing the code generator.

I spent the last evening chasing down memory leaks in the generated code.

The code is available at github.com.

2011-02-14T00:00:00.000-08:00

I had been thinking about compiling 01_ to LLVM for a while, and finally decided to get started on it by playing around with LLVM assembly language. One thing I like about LLVM assembly language is the static type checking. Anyhow, I started writing a runtime library for 01_. The only data type in 01_ is a lazy list of bits. The data type does not permit circular references, so I'll use reference counting garbage collection.

Here's my first stab at the data type for 01_ values:


%val = type { i32, i1, %val*, { i1, %.val* } (i8*)*, void (i8*)*, i8* }

which, in a C-like syntax would be:


struct val {
    int refcount;
    bool bit;
    struct val *next;
    struct { bool bit, struct val *next } (void*) *eval;
    void (void *) *free_env;
    void *env;
};

where bit and next are undefined and eval is non-null for unevaluated promises, and bit is undefined and next is null and eval is null for values evaluating to nil, and bit contains the bit value and next points to the next value and eval is null for non-nil values. That's a pretty large data structure for a single element of a bit list. I could shrink it by the size of a pointer by using the same location for next and env and casting, as env and free_env are never valid at the same time as next and bit. I won't do that, though, because it would make the code less clear, and having more understandable code is more important to me in this project.

2011-01-31T00:00:00.000-08:00

I've integrated purchasing with Facebook Credits into a Facebook application. In the end, the API was good, but the documentation was terrible, making it hard to get started. To start with, I needed to handle a callback from Facebook, and the documentation said

There are two callbacks Facebook makes on the application back end. The application needs to verify the fb_sig parameter to make sure that the request is coming from facebook.

I then had to guess and use trial-and-error to get it to work. What the documentation should have said, but didn't say was

The callback is an HTTP POST.
The content-type of the posted content is application/x-www-form-urlencoded.
The two callbacks are indicated by the method parameter.
The fb_sig parameter only needs to be verified if the application does not have the OAuth 2.0 for Canvas setting enabled. If that setting is enabled, the fb_sig parameter is not sent, and all the parameters are in the signed_request, which includes a signature that needs to be verified.
The order_details parameter is a string containing the original JSON, which means it needs to be double parsed.
They provide an example for the response to the payments_get_items callback, but not for the payments_status_update callback. Following the given example for the payments_status_update response results in an unhelpful error message to the user, with no feedback pointing to the problem. As the documentation was unhelpful, and the Facebook developer forums had a few posts from someone facing the same problem with no response, I resorted to trial-and-error. (I'm not creating yet another account and password just to post to that forum.) The problem was that the content field in the payments_get_items response is supposed to be an array, but it is supposed to be a single item in the payments_status_update response.

2011-01-24T00:00:00.000-08:00

I've said that I've found the Python programming language uncompelling. As a language, my impression is that it's a better language than perl, but I still use perl from time to time, but I don't use Python. The main way I use perl is from the command line to run one-off scripts. The one thing I knew about Python from the early 1990s when I first heard about it, until 2009, when I decided to try using it, was that indentation was syntactically significant, which means you can't write one-liners (even though the one line could contain 500 or more characters) like you can with braces and semicolons. perl -e 'while (<>) { ... }' is very convenient when trying to do something that would be too complicated when using pure shell constructs.

2011-01-17T00:00:00.000-08:00

I found out that in Tomcat 6, HttpServletRequest.getRequestURL() omits the ";jsessionid=[sessionid]", if present, while Tomcat 7 returns it. In either case, HttpServletResponse.encodeRedirectURL() adds it in or replaces it with the actual session id when the client has cookies disabled. However, what I needed was to have the ";jsessionid=[requested sessionid]", and not the actual session id, because I needed to reconstruct the URL that was actually sent for the redirect_uri parameter when obtaining an OAuth 2.0 access token.

What had happened was that when multiple hosts were added to the load balancer, clients with cookies disabled would get authentication failures. Since this was a new service in private beta, the immediate fix was to have a single host in the load balancer. I then would add a second host to the load balancer, do a quick test, then remove the second host from the load balancer, and then look at the logs to see what was going on. I had originally constructed the redirect_uri parameter using HttpServletResponse.encodeRedirectURL() on the results of HttpServletRequest.getRequestURL() and HttpServletRequest.getQueryString(). It worked fine with clients that had cookies enabled, because the session id wouldn't be in the URL, and the load balancer used cookies for host stickiness. However, for clients with disabled cookies, the load balancer would bounce the client between hosts for subsequent requests, and since sessions weren't really being shared between hosts, so when a client request gets sent to a different host, it gets a new session. (I did have a scheme to recover a very small set of essential session data through memcached, but I didn't think that saving redirect_uri in it was necessary, since it ought to be available when the client is retrieving that exact URL. I also should have a scheme to make sure the session ids from one host never collide with session ids from another host by prepending the hostname to the session id.)

After I figured out what was happening, I removed the HttpServletResponse.encodeRedirectURL() call in the construction of the redirect_uri parameter. It seemed fine to me, because I was using Tomcat 7. However, once it was running on other systems, there immediate failures for clients with disabled cookies. From the logs, I could tell that HttpServletRequest.getRequestURL() was omitting the ";jsessionid=[session id]", so I theorized that it was because of differences between Tomcat 6 and Tomcat 7, and quickly confirmed it by running Tomcat 6 myself.

I finally settled on an ugly hack, where if HttpServletRequest.isRequestedSessionIdFromURL() and if ":jsessionid=" were not in HttpServletRequest.getRequestURL(), I would add ";jsessionid=" + HttpServletRequest.getRequestedSessionId(), which would then work on Tomcat 6 and Tomcat 7.

2011-01-10T00:00:00.000-08:00

When doing some shell scripting for build and deploy processes, I ran into something I found strange and confusing. I had a loop


while read host; do ssh -i id $host command; done < hosts

However, it only executed the remote command on the first host, which was odd. I threw in some echos to see if something strange was happening, but it only confirmed that the loop only went through one iteration. Then I changed ssh to echo, and the loop iterated through all the hosts. Finally, I figured that ssh was slurping up stdin for some reason, causing the loop to end, and fixed the problem with


while read host; do ssh -n -i id $host command; done < hosts

2011-01-03T00:00:00.000-08:00

I created a simple web application and put it up on Amazon Web Services for about a week. The cost for a single instance and a single load balancer was around $21, including a few cents for storage and traffic. It would be about $82 a month. So I ported it to Google App Engine, where a low-traffic web application could be hosted for free. It took about a day. I replaced the storage layer that used Amazon S3 with one that used JDO. I replaced the memcached layer using the net.spy.memcached client with one using the JCache (JSR107) API. Those were straightforward and most of the rest of the code didn't need any changes. I also added the configuration files appengine-web.xml and jdoconfig.xml.

I ran into a few snags with the appengine servlet container, some of which might have been due to strange interactions with Google Guice, but that's just speculation without any real investigation.

The first one is probably a bug in the appengine (or jetty) implementation of HttpServletResponse.encodeRedirectURL(). It erroneously added ;jsessionid=sessionid to external URLs. I worked around that by not calling encodeRedirectURL() for external URLs, even though the javadoc says "All URLs sent to the HttpServletResponse.sendRedirect method should be run through this method."

The next one seemed like some weird difference in implementations. I used guice-servlet to configure servlet filters on /index.jsp, but they weren't being invoked for /, while the filters were being invoked under Tomcat and Glassfish. I worked around that by changing filter("/index.jsp").through(MyFilter.class) to filter("/","/index.jsp").through(MyFilter.class).

The last one was the weirdest, and has to be some kind of bug in either appengine, jetty, or guice. Once I got the filters passing the request for / through, instead of serving up /index.jsp, the service returned a redirect to //, which turned into a redirect to ///, etc, until the browser stopped due to too many redirects. I worked around that by kludging in a special servlet for /:


    @Singleton
    public static class RedirectToIndexJSP extends javax.servlet.http.HttpServlet {
        private static final long serialVersionUID = 0L;
        @Override
        protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, java.io.IOException {
            request.getRequestDispatcher("/index.jsp").forward(request, response);
        }
    }

After that, it all worked. Compared to Amazon, the service on Google App Engine is a lot slower for the first request, as this is a very low-traffic application, so it's pretty much never running, and a new virtual machine starts up when a request does come in, which seems to take around 10 seconds. Subsequent requests are reasonable, though still slower than Amazon.

2010-12-27T00:00:00.000-08:00

In order to access a Garmin device from Javascript in a web page, the Prototype framework needs to be loaded. The bad thing about Prototype is that messes other things up. One nice thing about jQuery is that it is nonintrusive, defining only one global symbol. Prototype, on the other hand screws with basic Javascript datatypes.

The first thing that I had to deal with after loading Prototype was that I could no longer use for (i in array) { ... }, to iterate through array elements without getting a bunch of extra junk. So I rewrote my for loops to go from 0 to array.length - 1 instead.

The next thing really confused me for hours. I wanted to encode a Javascript data structure as JSON, and JSON.stringify([]) would inexplicably result in "\"[]\"". But if I used the browser's Javascript console, JSON.stringify([]) would correctly result in "[]". Finally, I came across a web page that identified Prototype as causing this problem by setting Array.prototype.toJSON, among other things, which also explained to me why Prototype was screwing up my for loops iterating through arrays.

2010-12-20T00:00:00.000-08:00

When building a war file with ant, I found it convenient to include multiple <webinf/> elements in the war task when some of the WEB-INF files were generated, so that the source files and the generated files could be in separate directory trees. However, if there were entries under WEB-INF that were duplicated between the directory trees, one of them would always cause ant to find the war file out of date and rebuild it. It's not that I had any duplicated regular files, but I did have duplicated subdirectories, which had different timestamps. I had been puzzled by why ant was always rebuilding the war file, even if nothing had changed, before looking into it. I finally changed the war task to have a single <webinf/> element pointing at the generated files, and added a task that copies the source files into the directory tree of the generated files.

2010-12-13T00:00:00.000-08:00

Facebook authorization has some weirdness that I could only deal with with an ugly workaround. My understanding of OAuth is that I redirect the user to a Facebook URL. Then, Facebook sends the user back to me with a code that I exchange for an access token with Facebook. This works fine if the user has already authorized my application: the user gets redirected to Facebook, and then redirected back to me without a hitch.

However, if Facebook need the user to authorize my application, then there is a problem. My application runs in an iframe in a Facebook page. However, if I redirect the user to Facebook, which shows the user the authorization page, Facebook detects that it's in an iframe and grays out the page. If the user tries to interact with it, the user gets sent to the page out of the iframe. Once the user authorizes my application, the user gets sent back to me, but not in the iframe. Fortunately, when the user comes to my application, Facebook passes a flag to me that says whether the user has already authorized my application. So if the user has already authorized my application, I redirect to Facebook and things work fine. If the user has not, then I show the user a page that has some javascript that sends the user to Facebook out of the iframe, and when the user comes back from Facebook, I redirect the user to the Facebook page that frames my application.

2010-12-06T00:00:00.000-08:00

I have an ant target that runs some scripts on some Amazon EC2 instances. So, I first generate a file with a list the hostnames of the running instances. Then, ant runs a shell command that iterates over the hostnames and runs ssh to each with a command. Since I didn't want to run the command as root, the command was su -c "\"command with some parameters\"" username, which worked fine for me. However, on cygwin on Microsoft Windows, the nested quoting didn't work, so that su was trying to set the user to the first command parameter rather than the username I specified. None of the variations of single and double quotes and backslash quoting the space characters worked.

Finally, I gave up on trying to deal with the quirks of the Bourne shell under Microsoft Windows, and moved the su into a script on EC2:

if [ ! `id -un` = username ]; then su -c "sh -c \"$0 $*\"" username; exit; fi

Of course, none of the command parameters are expected to have spaces in them, as the $* would be trouble. And $@ wouldn't help because of the nested quoting.

2010-11-29T00:00:00.000-08:00

For storing objects in a database, I chose to serialize the objects in a way that maintains compatibility between object versions. So Java serialization was out. My first implementation was to serialize to JSON using Jackson, which was simple because it could serialize and deserialize objects that I was already using. However, there were more compact serialization schemes. Apache Thrift and Google Protocol Buffers looked fairly equivalent in functionality. Both required generating code from some IDL, making them less convenient than JSON. I chose Protocol Buffers since its serialization seemed to be slightly smaller than that of Thrift.

In order to continue using the objects that I was using before, since they included annotations and logic that can't be cleanly added to the protobuf-generated code, I used java.beans.Introspector to extract values from the objects to be stored in the database and put them into the protobuf objects and vice-versa.

2010-11-22T00:00:00.000-08:00

AWS (Amazon Web Services) is pretty nice. It not only has what's needed to deploy and scale a web service, but everything can be controlled through their REST (or SOAP) API, so that everything can be automated.

One thing that should have been obvious was how a service would start when an instance starts. The first time, I created an instance from a prebuilt image, copied the code to it, then logged in and started it manually. Eventually, I created an image that included all the code. I finally figured out that I could start it in /etc/rc.local.

The next thing I needed to figure out was how to update the software. Everything would be in a single war file (except for static assets pushed up to the CloudFront CDN (Content Delivery Network)), but automatically building a new image from an existing image with the war file replaced looked difficult. I could do it manually by starting an instance, replacing the war file, and then creating a new image. I could automate that manual process. Another way seems to involve turning the image into a loopback filesystem, replacing the war file in the filesystem, then turning the filesystem back into an image, then uploading the image. Finally, I figured out that I could just upload the war file to Amazon S3 (Simple Storage Service), and the instance could download the war file from S3 when it starts up, and creating new images is unnecessary.

However, the process of getting a working image was slow and tedious, since starting and stopping instances, and creating images were all really slow. Once I had an image that worked, setting up load balancing was trivially easy. Setting up Auto Scaling also looks very easy, once I figure out what metrics to use for launching and terminating instances.

2010-11-15T00:00:00.000-08:00

JAX-RS is really nice for writing REST services. I'm using Jersey 1.3, with Guice 2.0 and jersey-guice to configure things. However, the Jersey JSON provider is horrible. It messes up writing empty and single element arrays, and it writes boolean and numerical values as strings. My first hack around that was to return a JSON string instead of the objects, doing the conversions in-line using Jackson 1.5. That was ugly, so I overwrote META-INF/services/javax.ws.rs.ext.MessageBodyReader and META-INF/services/javax.ws.rs.ext.MessageBodyWriter in the Jersey jar, replacing the Jersey JSON providers with org.codehaus.jackson.jaxrs.JacksonJaxbJsonProvider, and it was much better.

I also use the Jersey REST client to talk to Facebook. However, Facebook returns text/javascript;charset=UTF-8 as the content-type, which is not recognized by either the Jersey JSON provider, or the Jackson JAX-RS JSON provider. Again, the first thing I did was to get the content as an InputStream, which I sent to Jackson for object binding. Then, I figured that I could just extend the Jackson JSON provider to accept text/javascript and use that class as the JSON provider.


@Provider
@Consumes({MediaType.APPLICATION_JSON, "text/json", "text/javascript"})
@Produces({MediaType.APPLICATION_JSON, "text/json"})
public class MyJaxbJsonProvider extends JacksonJaxbJsonProvider {
    @Override
    protected boolean isJsonType(MediaType mediaType) {
        if (mediaType != null && "javascript".equals(mediaType.getSubtype()))
            return true;
        return super.isJsonType(mediaType);
    }
}

Now, the code no longer has ugly hacks for JSON. However, any time I get a new Jersey jar, I'll have to overwrite the provider list in the jar, which is ugly. Perhaps I could put my own javax.ws.rs.ext.MessageBodyReader and javax.ws.rs.ext.MessageBodyWriter in a jar, and have it take precedence, but it didn't work the first time I tried it. It might depend on the classpath order of the jars, and having to use the classpath order of jar files to override things is also ugly.

Also on JSON, RFC-4627 says that slashes may be backslash quoted, though the example in section 8 does not backslash quote the slashes. The JSON from Facebook does backslash quote the slashes, but the JSON produced by Jackson does not. I wonder why backslash quoted slashes were explicitly included in the JSON specification. Perhaps it was inherited from Javascript, in which case I wonder why it was that way in Javascript. My only guess is that it had something to do with regular expressions, if it was from Javascript. Otherwise, it just seems weird.

2010-11-08T00:00:00.000-08:00

One thing that bugs me about some of the datacenter hosts that I have to access for one reason or another under a generic developer account that has no write access to anything except /tmp is that there is a long delay while xauth tries to lock $HOME/.Xauthority. I've explicitly unset DISPLAY, but that makes no difference.

2010-11-01T00:00:00.000-07:00

My initial attempt at making an iframe Facebook app immediately ran into a snag. It seems that if the Safari browser's cookie configuration is "Only from sites I visit", subtitled "Block cookies from third parties and advertisers.", then cookies don't get saved or sent to the iframe. Which means saving the session id in a cookie fails. Having sessions is critical, but I don't know if other browsers have this problem, or whether it's acceptable to fail for users that block iframe cookies (or all cookies). The session id could be stuck in the URL as a matrix parameter with a simple configuration of the servlet container, but it's painful to have to make sure all the URLs that need the session id are rewritten. Plus, the session id would get leaked in Referer headers.

Once I made sure all the URLs had the proper rewriting, it still didn't work, because although Glassfish v3 (74.2) rewrites all the URLs, it never recognizes the sessionid in the URL, and creates a new session. When I switched to Tomcat, it worked with cookies disabled.

2010-10-25T00:00:00.000-07:00

Now, I'm working on Facebook apps using OAuth 2.0, and the draft specification says in section 4.2 that JSON is returned when retrieving the access token. However, Facebook's OAuth 2.0 server returns application/x-www-form-urlencoded data. I anticipate things changing without notice, so I'll have to code it flexibly. Of course, it is a draft specification.

As for OAuth 2.0 versus OAuth 1.0, it's a little nicer. Code for computing the signature for OAuth 1.0 is difficult to debug, but, once it's working, it's easy. On the server side, incorrect nonce handling seems like an obvious hole for replay attacks, and OAuth 2.0 is better in that way. Also, unencrypted OAuth 1.0 traffic can still be snooped. Of course, OAuth 2.0 is still subject to traffic analysis. Of course, with Facebook's reputation on privacy, these differences are irrelevant for most Facebook apps, including the ones I'm working on.

2010-10-18T00:00:00.000-07:00

After using Guice for a little while, I've started learning how to use it better. I can use @Provides methods to configure objects. I like being able to install() modules for modularity.

For webapps, I can have two web.xml files, one pointing to one configuration, and another pointing to another configuration, such as a test configuration, by specifying the different configuration classes as the listener in web.xml files, where the bindings specify different implementations.

I'm not sure if I like the fluent interface. It's nice for reading the code, but it makes referring to the javadoc more difficult. It also creates a bunch temporary objects, but that isn't really a concern. Guice is supposedly a lot faster than Spring, and the temporary objects probably can be optimized away by escape analysis.

2010-10-11T00:00:00.000-07:00

I've only had a cursory look at Google Guice, but this is my first impression as compared with Spring, which I've used a lot more. Using Spring has actually changed the way I approach writing code.

What I like about Guice is that it is statically type-checked. Spring's xml configuration is like a dynamically typed language, and more errors slip through to later stages.

What I like about Spring is that code doesn't need to be written with any Spring-specific calls or constructs, whereas Guice requires Guice-specific annotations. If I only had to deal with code I've written, it wouldn't matter so much. However, Spring makes it hooking in code from external libraries more convenient.

Also, when using Spring, I like being able to specify every last configurable flag in the xml configuration, and anything that truly needs to be tuned can further be extracted into a properties file. Guice seems to make that level of configuration more inconvenient. Perhaps I am overlooking some mechanism, but it seems inconvenient to have to insert yet another annotation to name yet another string field that I want to configure, rather than just being able to inject beans. Guice seems to encourage having a few, high-level, injected objects, rather than every last configurable value injected.

One nice thing about Guice is that it can inject private fields, while Spring requires a public setter method. This is just a minor thing though, since, while the implementing class may have some public setters, the public interface that it is being injected as won't have those public setters. There is also constructor injection, but that is not convenient when there are many parameters to inject.

2010-10-04T00:00:00.000-07:00

I ran across a bug in an Android app that I was working on that had me throwing the phone to the floor multiple times in frustration. I finally tracked the problem down to SurfaceHolder.Callback.surfaceChanged() being called twice when the phone is held vertically, but only once when the phone is held sideways. Everyone using the app holds the phone sideways when using the app because the text and icons are all sideways. However, I had said to myself, "Screw that. I'm not going to turn the phone sideways just for that." I don't know what the proper way to fix it is, since I don't know why the code is in SurfaceHolder.Callback.surfaceChanged(), and the person who wrote it had just moved on to another company (Google, actually) a week earlier.

2010-09-27T00:00:00.000-07:00

Here's a bug that I recently came across. I didn't figure it out, and it wasn't code I wrote, but it is an example of gratuitously bad code.

Originally, I had written some code for a quick-and-dirty demo that went something like:

    packetType = readPacket(input, buffer);
    switch (packetType) {
    case TYPE1: parseType1(buffer); break;
    case TYPE2: parseType2(buffer); break;
    ...
    }

where readPacket() read the appropriate number of bytes into the buffer depending on the packet type. Something like:

   packetType = input.read();
    if (packetType == TYPE1) {
        read some stuff into buffer;
    } else {
         count = input.read();
         read count bytes into buffer;
    }
    return packetType;

Somewhere along the line, in a change in source control that was something along the lines of "update to the latest protocol", there were a number of changes, including gratuitously changing the code from something like the above, to something like:

    packetType = readPacket(input, buffer);
    switch (packetType) {
    case TYPE1: read more stuff from input; break;
    case TYPE2: parseType2(buffer); break;
    ...
    }

and readPacket() was changed to

    packetType = input.read();
    if (packetType == TYPE1) {
        return packetType;
    } else {
        count = input.read();
        read count bytes into buffer;
    }
    return packetType;

which all would have worked fine, even though it was a stupid and gratuitous change, except that there was another place that called readPacket(), but ignored the packet. So, if that other place called readPacket() and got TYPE1, the packet wouldn't be fully read, and subsequent calls to readPacket() would return garbage. I don't know what the thinking was behind changing the code like that.

2010-09-20T00:00:00.000-07:00

One component of this demo that I'm working on is a server in C++. The guy who did the work on it was laid off 5 months ago, and now I have to add crap to it. Most of it was 3rd-party code. I don't know what changes have been made to it, since it was checked into source control in one big chunk 9 months ago. However, there is one directory that has our specific configuration files and build and startup and shutdown scripts.

I found the build, startup, and shutdown scripts kind of annoying. They all assumed that the scripts would be run from the directory that the script were in, which I don't like to do. I prefer running /absolute/path/to/the/script, rather than cd /absolute/path/to/the, then ./script. So I added cd `dirname $0` to the top of all the scripts. Another goofy thing in the scripts were the use of pushd somedirectory >/dev/null, and then popd >/dev/null. Personally, I use directory stacks interactively all the time, and often have 3 or 4 directories that I switch between, but, for the script, cd somedirectory, then cd .. would work just as well.

As for the C++ server, I had to add a feature, which I did. And it worked some of the time, but mysteriously didn't work some of the time. There was a logging framework that I tried to use, and I spent a day trying to use it. When I tried making a new logger class, and tried enabling it, the server crashed. Finally, I just hacked in some code that fopened a file, and vfprintfed crap directly to it, and figured out that I had added an uninitialized variable to a class, and, depending on what value it had, the feature worked or didn't. So I fixed it by initializing it in the constructor.

2010-09-13T00:00:00.000-07:00

There is some demo code at work that's been around for around 10 months, and I've added various features to it from time to time. Also, from time to time, the deployed code has to be put in a "known state" to actually do the demos. A month or two ago, some other guy added a feature, which makes the user interface fancier, so his changes need to be in all the demos, but he never checked anything into source control. Since then, I've added some features, all of them checked in. So now when there is a demo, this guy has to merge my changes into his code and then deploy it on the demo system. Except that what has actually happened is that they go back to the code that he originally deployed over 3 months ago, which doesn't have any the features I've added, which include changes that make the platform more robust. I can't deploy the demo including his features because I don't have his code.

One of these days, I'm going to ask him why he doesn't check his crap in.

I don't understand how some people can work on stuff while rarely interacting source control. I update my source trees often. I update before starting work. I merge in changes periodically during work. I merge in changes when I'm ready to check stuff in. I check stuff in when I'm done working on it.

2010-09-06T00:00:00.000-07:00

There has been a bunch of attrition at work, so I have to help taking over some Android code. So, to learn the Android platform, I decided to make a sample application that receives incoming SMS messages and send them through the text-to-speech processor. I put the code on github. I managed to get it to work on an emulator in a couple of days, as the Android platform is pretty easy to learn and pretty well documented. I haven't tried it on a real phone, since I wrote it for Android 2.1, and phones at work run Android 1.6.

The one thing that I had problems with was the service lifecycle interfering with the asynchronous text-to-speech interface. My ugly solution was to have the service post an empty intent to itself while the text-to-speech was still speaking to keep the service alive, since the text-to-speech instance would have been considered leaked if it isn't shutdown when the service is destroyed. If I continue working on Android applications, I'll probably find a better way to do it.

2010-08-30T00:00:00.000-07:00

I just started using git for version control, and made some free repositories on github. I haven't tried anything beyond the very basics of creating a repository and committing and fetching code from multiple sites. I haven't made any branches or done any rebasing. For the basics, the only new concept I had to learn was the index, which I glossed over when first reading the documentation. After playing around a bit, I got a little confused, then kind of figured out what was going on, then read the documentation again, and it became clear.

2010-08-23T00:00:00.000-07:00

More Project Euler problems.

For problem 51, I only had to try replacing the 0s, 1s and 2s, since there had to be 8 values in the family. And I didn't have to try replacing 1s with 0s or 2s with 1s or 0s, since those would be redundant.

I just did a brute force search from 1 on up for problem 52. It would be more complicated and maybe faster to skip numbers where the most significant digit is not 1, but the answer wasn't all that big, so it wouldn't be significantly faster, if at all.

For problem 53, since ⁿC₀ = ⁿC_n = 1, and C increases rapidly from the edges and peaks at the middle, I counted the values under a million for 0 ≤ r ≤ n/2, doubled it and subtracted.

For problem 54, using Haskell's deriving (Ord) with an appropriate data structure and mapping the card values to values that ordered the ace, face cards, and ten correctly made it simple. Also, there were no instances of A 2 3 4 5 in the data, which, if considered a straight, would have had to have a special-case constructor to be ordered correctly.

I just brute-forced problem 55 over the range 1..9999.

For problem 56, the upper bound for the sum of digits is 9b log₁₀a, and log₁₀a < 2, so the upper bound is 18b. So the maximum value for b = 99 establishes a lower bound for b that needs to be searched. Subsequent new maximums for b < 99 can raise that lower bound. I wound up searching 1 ≤ a ≤ 99 for 54 ≤ b ≤ 99.

For problem 57, I found that doing head (show numerator) < head (show denominator) was faster than counting all the digits, as it's known that numerator/denominator is approximately 1.4.

For problem 58, I just did a brute force iteration over each square, with running counts of the total and the number of primes.

For problem 59, I printed out every 3rd character decoded with each of the 26 possible key characters, and then visually chose each of the 3 characters in the key.

For problem 60, I could only come up with a super slow solution, though it did come up with the answer in about 10 minutes, and ruled out other possible answers after 30 more minutes. I made a very wide, shallow tree, spitting out results when reaching a depth of 5. I had to do a bunch of redundant calculations, because although I had a branch starting with 3,7,109,... I still needed branches starting with 3,..., 3,7,..., 3,109,..., 7,..., 7,109,..., 109,.... I'm thinking that a graph-based algorithm, instead of a tree-based algorithm would be faster, should I revisit this problem.

2010-08-16T00:00:00.000-07:00

Looking at more Project Euler problems.

I thought problem 41 was going to be tough, but there are only 9! = 362880 nine-digit numbers to consider, and even fewer 8-digit numbers to consider, etc, so it was just a matter of checking for the first prime permutation.

Problem 42 was straightforward. I made a list of triangle numbers up to the maximum word value, then filtered the word values and counted.

For problem 43, I started by taking all multiples of 17 under 1000, filtering out any with repeated digits. Adding the 4th digit made the set 7 times bigger, but removing those that did not have the divisible by 13 property made the set about half the size. Iterate for the remaining digits.

I couldn't find a reasonable way to solve problem 44. It involves finding 4 pentagonal numbers, p_i, p_j, p_k, p_l, where p_i ≤ p_j < p_k < p_l, and p_i = p_k - p_j, and p_j + p_k = p_l, where p_i is minimized. For a given i, there's an upper bound for j, such that p_i ≥ p_j+1 - p_j, and the upper bound for j is O(i²), which means a brute-force search over i gets extremely slow. However, since I didn't have any better ideas, I searched i from 1 to about 350 or so without finding a solution, and gave up.

For problem 45, I made a list of hexagonal numbers, filtered out those that weren't pentagonal or triangle, and took the 3rd number in the resulting list, the first two being 1 and 40755. It would have been slightly slower to make a list of pentagonal or triangle numbers, and filter out those that weren't the other types.

For problem 46, I iterated over non-prime odd numbers, building up a list of primes and doubled squares less than it, stopping when none of the primes could be added to one of the doubled squares to get that number.

In problem 47, I only had to check every 4th number until one had at least 4 factors, then check the previous one, the one before that, and the one before that. If any didn't have at least 4 factors, I could jump forward 4 from that.

For problem 48, using mod 10¹⁰ arithmetic means not having to add gigantic numbers, while still getting the last 10 digits.

For problem 49, I took all the 4 digit primes and grouped the ones that were permutations of each other together, then searched each group for a qualifying triplet.

For problem 50, I found the longest prime sum starting with 2, as well as the list of primes after the last term of the sum. Then, I subtracted 2 and added the next largest prime, looking for the longest sum starting with 3, and iterating until subtracting the next smallest prime and adding enough of the next largest primes to make the sum have more terms than the current longest sum resulted in a sum more than a million.

2010-08-09T00:00:00.000-07:00

Looking at the 4th ten Project Euler problems.

Problem 31 is a straightforward recursive count. Once you get to the 1p, the number of combinations is 1.

For problem 32, 99×99 = 9801 and 111×111 = 12321, so all the solutions have to be a two-digit number × a three-digit number resulting in a four-digit number. I did a brute-force search through all the combinations of 5 digits of the multiplicands.

Problem 33 just involved searching with 1 through 9 to see if any pair of digits had the property, so that was a small search. Also, there were only 36 pairs of digits to check.

Problem 34 is just like problem 30 with a larger bound.

For problem 35, I partitioned the primes by number of digits, then filtered out the numbers that were not the minimum of the digit rotations, which conveniently eliminated all numbers with zeros. I then filtered out the numbers for which not all of the rotated numbers were in its partition, which eliminated 11. 111, 1111, 11111, 111111 are all not prime. Then multiple the size of each partition by its number of digits, sum, add 1 for 11 gives the answer.

Problem 36 was a brute-force filter. Since leading zeros weren't allowed, even numbers could be eliminated, cutting the problem in half.

For problem 37, I built lists of n-digit primes that could be truncated from the left to n-1-digit primes, and lists of n-digit primes that could be truncated from the right to n-1-digit primes. The intersection of the left and right lists gives the 11 numbers.

From the example in problem 38, the first digit had to be a 9, so it was just a matter of searching 91..98, 912..987, 9123..9876, and 91234..98765.

For problem 39, p/3 < c < p-3, and c/2 < b < c-1. After that, I just did a brute-force search, which was kind of slow.

Problem 40 is just multiplying 7 single-digit numbers, and at least 2 of them are 1. It's straightforward to figure out those numbers, and, as it turns out, the product of those numbers is simple to mentally compute.

2010-08-02T00:00:00.000-07:00

I wanted more immediate feedback about my Rock Band scores, so I modified the code I wrote that takes a picture of the television screen and does OCR (optical character recognition) to figure out what song was just played, and run text-to-speech with the name of the song and my high score. It works about half the time. But when it works, I get to know if I got a new high score without having to go over to the computer and check, which means I can be ready to play the next song.

2010-07-26T00:00:00.000-07:00

Continuing to look at the Project Euler problems. The third 10 are a little more difficult than the previous 20.

My Haskell solution for problem 21 was too slow. So, in Java, I made a table of the sum of the divisors for the numbers from 1 to 9999, then added up the numbers that pointed at each other, as well as the numbers in the table that paired with numbers greater than 9999, and it was reasonably fast.

Problem 22 was straightforward.

I could not write a fast algorithm for problem 23 in Haskell. So, in Java, I made a table of whether the number is abundant for 1 to 28123. Then, each number from 1 to 28123 could be tested by testing for pairs of trues in the table where the indices added up to the number, which should be less than around 200 million tests, and short-circuiting after the first pair is found means the actual number of tests should be much lower than that.

Problem 24 doesn't require much computation. The first element of the nth permutation is the (n-1)/m!+1th element, where m+1 is the number of elements, and the rest of the nth permutation is the remainder of (n-1)/m!+1th permutation of the remaining elements.

Problem 25 was straightforward.

My solution to problem 26 was kind of slow, but not excessively slow. I calculated the cycle length by making a list of the remainders and searched the list of remainders for repeats with each new digit in the quotient. After that, it was a brute-force maximum search: snd $ maximum $ map (\ n -> (cycleLength n,n)) [1..1000].

My solution for problem 27 was kind of slow. b must be a prime under 1000 due to n=0, so there 168 possibilities for b. Given b and n, p = n² + an + b, where p is prime, so a = (p - b)/n - n, so p - b has to be a multiple of n, so I made a list of primes satisfying that condition, which can be mapped to a list of values for a, which can be filtered for |a| < 1000. Then, I brute-force searched the 168 values of b for the maximum n and the corresponding a.

Problem 28 doesn't require much computation. The numbers on the corner of the nxn square, where n is odd, is a simple function of n, so the numbers on the diagonals can be added by recursively adding the diagonals of the (n-2)x(n-2) square.

For problem 29, any pair that has aⁱ ≤ 100, where i > 1 and i divides b is not distinct and can be filtered out.

My solution for problem 30 was quite slow. Since 6×9⁵ = 354294, 299999 is an upper bound. 2⁵ + 5×9⁵ = 295277, 1⁵ + 5×9⁵ = 295246, so I used 295246 as an upper bound for the brute force search. After working on problem 34, which is almost the same problem with a much bigger upper bound, I made the search faster by searching by 10s and only going through the 1s digits if the sum of the other digits is between the number + 9 - 9⁵ and the number. This could be generalized to further prune the search by only considering the most significant digits, and only iterating through less significant digits if sum of the digits is within range of the number.

2010-07-19T00:00:00.000-07:00

Continuing to look at the Project Euler problems. The second 10 are a little more difficult than the first 10.

Problem 11 is yet another search. I used transpose . zipWith drop [0..] to get a quarter of the diagonals, and combined it with various uses of reverse to get the rest of the diagonals. The result was on a diagonal.

My solution to problem 12 was horribly slow with hugs, so I solved it in Java. The algorithm I used should be O(N^3/2), and the answer I got was between 50 million and 100 million. Perhaps my calculation of triangle numbers was O(N²) in hugs, instead of O(N), causing the calculation to be O(N^5/2).

Problem 13 might have been more of a challenge when restricted to fixed size integer arithmetic. As it was, take 10 . show . sum.

My Haskell solution to problem 14 was horribly slow, so I solved it in Java by tabulating the results under a million and using the recursive formula whenever it went over a million.

My Haskell solution to problem 15 was horribly slow, so I solved it in Java by tabulating the results by building on the previously tabulated results for smaller grids, which should be O(N²).

Problem 16, like problem 13, was a simple one-liner that would have been much more difficult when restricted to fixed size integers.

Problem 17 is just a matter of counting correctly, without any nontrivial mathematical reasoning or computation.

Problem 18 (and problem 67) can be solved with pretty much a one-liner: foldr1 (\ row sums -> zipWith3 (\ i l r -> i + max l r) row sums (tail sums)).

Problem 19 is an easy brute-force iteration, with only 1200 months to consider. The 100 and 400 year rules can be ignored, given the range.

Problem 20 is a simple one-liner just like problem 16, where the challenge is mainly for those restricted to fixed-size integers.

2010-07-12T00:00:00.000-07:00

When there was only busy-work at work, I started working through the Project Euler problems. For the most part, I used the hugs implementation of Haskell, since the problems ought to be solvable without a huge amount of computation. However, some of my solutions were way too slow, so I used Java to solve some of the problems. I haven't submitted any of my answers, so I don't have that verification that my answers are correct.

Problem 1 was a simple one-liner in Haskell


 p1 = sum [3,6..999] + sum [5,10..999] - sum [15,30..999]

Problem 2 was a simple 2-liner in Haskell.

For problem 3, I started by computing a list of primes. After getting the answer, I realized that calculating the primes was superfluous. I could just divide out all factors, starting from 2, regardless if they were prime or not, and the remainder would be the largest prime factor.

I just brute forced problem 4, though I can halve the search space since multiplication is commutative.

Problem 5 was a simple one-liner. Haskell's Prelude provides gcd.

Problem 6 was another simple one-liner.

My solution for problem 7 was pretty slow. Adding a type declaration: primes :: [Int], made it over 3 times faster, though still slow, with hugs. The inferred type would have been primes :: [Integer], but since all of the relevant numbers fit into signed 32-bit integers, [Int] would still give the correct result. I sped up a number of slow solutions by adding Int declarations.

I brute forced problem 8. Since the last digit was a 0, I could just do product . take 5 and not worry about a spurious result, which I would have had to worry about if the number had ended with 09999.

Problem 9 was another brute-force search. Since 1000 > c > b > a > 0, I could limit the search to 1000 > c > 333 and c > b > c/2.

My solution to problem 10 in Haskell was just too slow using hugs, so I wrote basically the same algorithm in about 20 lines of Java, which was fast. The result had to be a long, since it was too big to for 32-bit integers. I manually stored the computed primes in an array in the Java solution. Perhaps hugs wasn't memoizing the list of primes that was being computed, causing the algorithm that was supposed to be O(N^3/2) to be O(N²).

2010-07-05T00:00:00.000-07:00

The service that I work on interfaces with things that other people work on. One problem that came up multiple times is that these other systems have hard-coded invalid assumptions that have worked so far, for various reasons. One of the reasons is that one of the early features that didn't fit those assumptions simply got reclassified as unsupported and has been removed from every release. Due to these problems, I'll have to account for these hard-coded assumptions in these other systems when adding new features in the future.

2010-06-28T00:00:00.000-07:00

I got pulled into yet another demo, involving building yet another prototype. I managed to get something functional in under a week, in about 2000 lines of Java. The next two weeks involved rewriting lots of the code either due to my misunderstanding of what it was supposed to do, or changes in what it should do after having something available to play with. Since I was the only one working on the code, I felt free to rewrite big chunks of it. The demo ended up being about 3000 lines of Java and seems to have gone successfully.

Two things, which I've said before, apply to this experience.

Being able to throw away the first few iterations is valuable. The design of later iterations can incorporate issues that weren't forseen in the earlier iterations.

Static typing makes replacing large chunks of code manageable. The compiler caught numerous little oversights, whereas using a dynamically typed language would have been much more painful.

So, for prototyping and rapid iteration, I strongly prefer using statically typed languages.

For an established code base that has many people working on it, rewriting large chunks of code is less of an option.

It's harder to understand all of the issues in a large codebase.

Management conservatism discourages potentially disruptive changes.

2010-06-21T00:00:00.000-07:00

After setting up my computer to take pictures of my television screen when finishing a Rock Band song, I can go back and see if I got any new high scores afterwards. However, the leaderboard interface is limited by the controllers and navigating hundreds of songs is clumsy, so I came up with a way to make the computer do most of that work. I can get my scores from rockbandscores.com in csv format, and use OCR (optical character recognition) software to get the name of the song out of the picture.

The scores and song names show up in two different ways. In the middle of a set, the song name appears at the bottom left of the screen. At the end of the set, the song name appears at the top of the screen, in uppercase, and in a different font. There are also lots of non-textual graphics on the screen. However, the OCR software doesn't have to be anywhere near perfect, since all it needs to do is to enable distinguishing between a limited set of a few hundred song titles. So I got ocrad, which is free, lightweight, and fast, though not very sophisticated or flexible.

I send the upper part of each image and the lower left of each image through OCR after processing the piece of the image into monochrome, selecting the whitest and brightest pixels. Originally, I selected for the brightest pixels, but I found that also selecting for the whitest pixels worked much better. There are still lots of non-text clutter left, which the OCR software interprets. So after gathering data on what results the OCR software got from various pictures, I made and refined a heuristic for matching the OCR results with the song titles.

Here are some initial results after getting it to work pretty well. First, a song in the middle of a setlist:

Processing the upper part and the lower left part causes the song title to stand out in the lower left.

The OCR software does a reasonable job on the lower left:


M1dn19htR1d9r. . .
\ a ' ;' '' .. , 1
_-__.

The OCR text is good enough that it matches one song in the scores.csv file, the correct one, and I did not get a new high score:


[Midnight Rider, The Allman Brothers Band, GUITAR:75218 6.18, DRUMS:127100 5.37]

After finishing the set:

Processing the upper part and lower left part of the image causes the song name and score to show up cleanly in the upper part:

The OCR software returns:


FRRNH11N'5 7DWER
225,225 _K1,v,v_

and the A in the picture does look like an R, and the K does look like an H, and all the other misread characters do look like the characters returned by the OCR software. The score was also correctly recognized, but that usually doesn't happen.

Matching the text with the scores.csv file, I got a new high score:


[Franklin's Tower, Grateful Dead, DRUMS:223275 5.98, GUITAR:155807 6.67]

2010-06-14T00:00:00.000-07:00

One thing I like to do is play Rock Band. However, I often find that I don't remember what songs I just played in a playlist, and sometimes I want to check and see if I got a new high score. My first thought was to sniff the packets sent to the online leaderboards and pull the songs and the scores out of that data. Unfortunately, the packets are encrypted, so I gave up on that idea. But I had a new idea. I could point my computer's camera at the screen and record a video.

Making a video of the gameplay would eat up disk space and it would be a pain to go through a long video to see all the songs. But, going back to my first idea of sniffing packets, I could have some scheme of taking pictures and saving the ones around the time when packets were sent to the leaderboards. After finding out how to take pictures using the quicktime API and trying it out, I wrote some code that took a picture every 5 seconds, and interleaved the pictures with tcpdump output. I found that 32 byte packets were being sent every few seconds to Xbox Live, and 80 byte packets were being sent every once in a while, but larger packets were always sent after finishing a song. So then I wrote it to take a few pictures when seeing the larger packets. It worked really well. It takes some extraneous pictures due to other packets. Fortunately, I don't have lots of Xbox friends that would cause lots of notification packets.

Now I can play a dozen or so songs, and then go back and see how I did, instead of worrying about not remembering what I just played after playing only 3 or 4 songs.


import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Date;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
import quicktime.QTSession;
import quicktime.io.QTFile;
import quicktime.qd.Pict;
import quicktime.qd.QDConstants;
import quicktime.qd.QDGraphics;
import quicktime.qd.QDRect;
import quicktime.std.StdQTConstants4;
import quicktime.std.image.GraphicsExporter;
import quicktime.std.sg.SequenceGrabber;

public class Scorer {
    private static ArrayBlockingQueue<Long> queue = new ArrayBlockingQueue<Long>(20);
    private static boolean running = true;

    private static void capturePhoto(String filename) throws Exception {
        try {
            QTSession.open();
            QDRect qdRect = new QDRect(640, 480);
            QDGraphics qdGraphics = new QDGraphics(qdRect);
            SequenceGrabber sequenceGrabber = new SequenceGrabber();
            sequenceGrabber.setGWorld(qdGraphics, null);
            GraphicsExporter graphicsExporter = new GraphicsExporter(StdQTConstants4.kQTFileTypePNG);
            graphicsExporter.setInputPicture(Pict.fromSequenceGrabber(sequenceGrabber, qdRect, 0, 0));
            graphicsExporter.setOutputFile(new QTFile(filename));
            graphicsExporter.doExport();
        } finally {
            QTSession.close();
        }
    }

    private static void recorder(String dir) {
        try {
            PrintStream out = new PrintStream(new FileOutputStream(dir + "index.html"));
            out.println("<html><body>");
            int i = 0;
            long t = 0L;
            while (running) {
                queue.take();
                if (System.currentTimeMillis() - t < 30000L)
                    continue;
                out.println("<br>Start:" + new Date() + "<br>");
                for (int j = 0; j < 3; j++) {
                    capturePhoto(dir + i + ".png");
                    out.println("<img src=\"" + i + ".png\">");
                    i++;
                    TimeUnit.SECONDS.sleep(1);
                }
                out.println("<br>End:" + new Date() + "<br>");
                queue.clear();
                t = System.currentTimeMillis();
            }
            out.println("</body></html>");
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void sniffer() {
        try {
            Process process = new ProcessBuilder("/usr/bin/sudo", "/usr/sbin/tcpdump", "-n", "-l", "port", "3074").start();
            BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream()));
            while (running) {
                String s = in.readLine();
                if (s == null)
                    break;
                if (s.endsWith("length 32") || s.endsWith("length 80"))
                    continue;
                queue.offer(System.currentTimeMillis());
            }
            process.destroy();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        new File("/tmp/score").mkdir();
        new Thread() { public void run() { recorder("/tmp/score/"); } }.start();
        new Thread() { public void run() { sniffer(); } }.start();
        System.in.read();
        running = false;
    }
}

2010-06-07T00:00:00.000-07:00

I played around a little with Clojure's Java interoperability at work. Since I made making a new module in the main product that I work on a matter of putting some classes and some xml in a jar file and putting that jar file and any jars it depends on in a directory, it shouldn't be a problem.

The Clojure code was all straightforward, using gen-class. How to actually get the class files generated was all in the documentation, but having the correct classpath was a big snag for me, especially the need to have ./classes in the classpath, which kept causing mysterious NoClassDefFoundErrors. After getting that figured out, I stuck it into ant:


    <target name="compile">
        <mkdir dir="${build.dir}"/>
        <java classname="clojure.main">
            <arg value="-e"/>
            <arg value="(set! *compile-path* &#34;${build.dir}&#34;) (compile 'name.of.test.ModuleClass)"/>
            <classpath>
                <fileset dir="${lib.dir}">
                    <include name="*.jar"/>
                </fileset>
                <fileset dir="${clojure.home}">
                    <include name="*.jar"/>
                </fileset>
         <pathelement location="${src.dir}"/>
         <pathelement location="${build.dir}"/>
            </classpath>
        </java>
    </target>

Then, after getting the jar files built, I dropped the jar file and clojure.jar into the directory and got a giant stack trace, leading to


Caused by: java.io.FileNotFoundException: Could not locate clojure/core__init.class or clojure/core.clj on classpath: 
        at clojure.lang.RT.load(RT.java:402)
        at clojure.lang.RT.load(RT.java:371)
        at clojure.lang.RT.doInit(RT.java:406)
        at clojure.lang.RT.(RT.java:292)
        ... 45 more

I hadn't the classloader set properly for the initial loading of the modules. For all the other modules, there wasn't much done in the class initializers, so this problem didn't come up. I had the classloader set for all other operations, though, so it was merely a matter of doing the same thing at initialization, and it worked.

I also noted that I handled the classloader by hand-creating a proxy class and implementing each method to wrap the classloader switch,


    final ClassLoader handlerClassLoader = handler.getClass().getClassLoader();
    return new Handler() {
        public Object getObject(Object parameter) {
            ClassLoader cl = Thread.currentThread().getContentClassLoader();
            Thread.currentThread().setContextClassLoader(handlerClassLoader);
            try {
                return handler.getObject(parameter);
            } finally {
                Thread.currentThread().setContextClassLoader(cl);
            }
        }
    };

which I could improve by using java.lang.reflect.Proxy, which I could use to wrap all the calls with one method. The code was about 100 lines shorter, and would no longer have to be changed if the Handler interface changed. I'll check in these changes, but not the test module in Clojure.

2010-05-31T00:00:00.000-07:00

After playing with Clojure for a little while, one feature that I really like about it is doc and doc-strings, which work just like doc-strings in Emacs Lisp. I can use find-doc and ns-publics to find or explore the available symbols. I'm sure that an emacs mode or an IDE could make the interface as nice as the Emacs Lisp interface, but the functionality is there.

In Java, I often use javap to see what the method signatures of a class were, and have sometimes wished that the Javadoc were also available in the same way. The Java compiler could have put the Javadoc in attributes in the class files, which would then be available to tools like javap.

When using hugs or ghci for Haskell, I like using :browse and :info. The name and type almost always is enough to convey what a function does. It would be nice to have a short description of relevant information not captured by the name and type, but that's somewhat rare.

In any case, if I really needed to, documentation for the standard libraries for all three of these languages are available online. For Clojure and Haskell, the source code is available. For Java, the class files can be disassembled, though the occasional native method would remain opaque.

I find Clojure compelling in a way that I do not find Python compelling. They are both dynamically typed, which is a minus to me for both. I'm neither drawn to nor repelled by the syntax of either. However, I like feel of the immutable data structures of Clojure better than the data structures of Python. I'm also going to play around with integrating Clojure code with Java code. And while I haven't explored multimethods or any concurrency features, I can see learning new concepts, perhaps even learning when volatile would be useful when writing in Java, when looking into them.

2010-05-24T00:00:00.000-07:00

In the product I work on at work, there are modules that accept items of various content types. Somebody made a dumb extension that made text content a special case, so now I'm getting silly NullPointerException bugs assigned to me because null is being passed in for the content. It would have been much cleaner to just use "text/plain" as the content type without any new special case code.

2010-05-17T00:00:00.000-07:00

It seemed inappropriate that I hadn't implemented Parenthesis Hell in a Lisp, so I decided to learn a little about Clojure, a new Lisp dialect. I didn't use any of the concurrency features of Clojure, which is one of its main selling points. However, a Parenthesis Hell interpreter doesn't need any mutable state.


(defn ph-eval* [expr scope input]
  (loop [scope* scope]
        (cond
         (empty? expr) input
         (contains? scope* (first expr))
         ((scope* (first expr)) (rest expr) scope input scope*)
         :else (recur (scope* 'outer)))))

(defn ph-valid? [val]
  (cond
   (not (seq? val)) false
   (empty? val) true
   (not (seq? (first val))) false
   (empty? (first val)) (recur (rest val))
   :else (recur (cons (first (first val)) (cons (rest (first val)) (rest val))))))

(defn ph-fn [body]
  (fn [expr scope input def-scope]
      (ph-eval* body def-scope expr)))

(defn ph-quote [expr scope input def-scope]
  expr)

(defn ph-let [expr scope input def-scope]
  (if (empty? expr)
      ()
    (loop [bindings (first expr) scope* {'outer scope}]
          (cond
           (empty? bindings) (ph-eval* (rest expr) scope* input)
           (empty? (first bindings)) (recur (rest bindings) scope*)
           :else (recur (rest bindings)
                        (assoc scope*
                               (first (first bindings))
                               (ph-fn (rest (first bindings)))))))))

(defn ph-car [expr scope input def-scope]
  (let [expr* (ph-eval* expr scope input)]
       (if (empty? expr*) () (first expr*))))

(defn ph-cdr [expr scope input def-scope]
  (let [expr* (ph-eval* expr scope input)]
       (if (empty? expr*) () (rest expr*))))

(defn ph-cons [expr scope input def-scope]
  (if (empty? expr)
      ()
    (let [head (ph-eval* (first expr) scope input)
         tail (ph-eval* (rest expr) scope input)]
         (cons head tail))))

(defn ph-if [expr scope input def-scope]
  (cond
   (or (empty? expr) (empty? (rest expr))) ()
   (not (empty? (ph-eval* (first expr) scope input)))
     (ph-eval* (first (rest expr)) scope input)
   :else
     (ph-eval* (rest (rest expr)) scope input)))

(defn ph-eval [expr scope input def-scope]
  (let [expr* (ph-eval* expr scope input)]
       (if (not (ph-valid? expr))
           (throw (IllegalArgumentException. "Not valid Parenthesis Hell")))
       (ph-eval* expr* scope input)))

(defn ph-eval
  "Evaluate a Parenthesis Hell expression with optional input."
  ([expr] (ph-eval expr ()))
  ([expr input]
     (if (or (not (ph-valid? expr))
             (not (seq? input)))
         (throw (IllegalArgumentException. "Not valid Parenthesis Hell")))
     (ph-eval* expr
               {'() ph-quote
                '(()) ph-let
                '((())) ph-car
                '(()()) ph-cdr
                '((())()) ph-cons
                '(()()()) ph-if
                '(((()))) ph-eval}
               input)))

2010-05-10T00:00:00.000-07:00

Here is are a couple of programs in Parenthesis Hell that print themselves. I've inserted a bunch of line breaks, but they should be on one line.

The first one uses the optional concat in the initial scope. The second does not, and I haven't successfully tested it, since my interpreter runs out of memory when running it.

The following uses concat:


((())((((()()))()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()(
)(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(
()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()
()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()((
)(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(
()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()((
)(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()
()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()((
)()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()(
)(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()
()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()
(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()
()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()((
)(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(
()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()((
)(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(
()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()((
)()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()(
)(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()(
)(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()((
)(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(
()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()
(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()((
)()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(
()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()
()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(
()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()
()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()((
)()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()(
)(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()(
)(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()
(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()
(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(
()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()
()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(
()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(
)()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()((
)(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(
()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()
(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()
()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(
()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()((
)()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(
()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()
()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()((
)()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()
()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()((
)()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()(
)(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()
()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()(
)(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()
()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()(
)(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()(
)(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()
(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(
()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()(
)(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(
()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()
()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()
(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()((
)()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()((
)(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()(
)(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(
()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()
()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()
(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()
()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(
()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(
()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()
(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
))))))))))))))))((())(()()())()((()(()))(()()()(()(()()()())))(()(()))((())
((())))(()(()))(()()()(()(()()(()))))(())(()()))()()))(()(()))(()()()(()(()
()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()(
)(()(()()()()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()((
)()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(()))
))))))))))))))))))))))))))))))))))))))))(()(()))((())((()())))((()())))

The following does not use concat:


((())((((()()))()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()(
)(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(
()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()
(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()((
)(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()
()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()
(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()((
)()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(
()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()(
)(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()
()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()(
)(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()
()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()
(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(
)()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()
(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()(
)()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()((
)()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()
()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()((
)()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()
(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()(
)(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()((
)(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(
)()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(()()(()
(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()
()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()
(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()
()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()(
)()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(
()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()
(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()((
)(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()((
)()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(
()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()
()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()((
)()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(()(
)(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()
(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()((
)(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()
()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()
(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()()
()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()((
)()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()(
)(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()(
)()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()
(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()
()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(
()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()
(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()
(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()()
()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()((
)()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()
(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()
(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()((
)(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(
()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()
(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()((
)()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(
()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()
()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(
()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()
()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()((
)()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()(
)(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()(
)(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()
(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()
(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(
()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()
()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(
()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(
)()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()((
)(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(
()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()
(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()
()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(
()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()((
)()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(
()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()
()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()((
)()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()
()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()((
)()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()(
)(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()
()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()(
)(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()
()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()(
)(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()(
)(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()
()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()
(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()(
)()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(
()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()(
)(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(
()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()
()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(
()(()()(()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()()(
)()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()((
)(()()()()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(
()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()
()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()
(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()
(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()((
)()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()(
)(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(
()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(
()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()
()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()((
)()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(()(
)(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()()()()(()((
)()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()
(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(()(()()(()()(()(()(
)(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()()()()(()(()()()()()(
()(()()(()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()(()()(()(()()((
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))((())(()()())(((())))((()()())(((()))((())))
(((())())((())((())())(((()))((())))(()()))())(()()())((()())((())))(((())(
))(())(())((())())((()())((())))(()()))(()()))(()()))((((())))(()()())()(((
))((())())(()()()(()(()()()())))(())((())())((((())))((())))(())((())())(()
()()(()(()()(()))))(((())))(()()))()()))(())((())())(()()()(()(()()()()()((
)(()()()()()(()(()()()()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(
)()()(()(()()()()()(()(()()()()()(()(()()()()()(()(()()(()()(()(()()()()()(
()(()()(()()(()(()()(()()(()(()()(()()(()(()()()()()(()(()()(()))))))))))))
))))))))))))))))))))))))))))))(())((())())((((())))((()())))((()())))

The tasq programming language

2010-05-03T00:00:00.000-07:00

tasq is a macro-expansion language with a single task queue and a small set of operations.

Syntax

A tasq program is a sequence of declarations or comments, optionally separated by whitespace.

A comment starts with a dot (.) and continues to the end of the line.

A declaration is an identifier followed by zero or more operations, and ending with a dot (.). Whitespace may separate identifiers and operations, but is otherwise ignored.

An operation is an identifier or one of +, -, ~, or ?.

An identifier is an uninterrupted sequence of non-whitespace characters not including +, -, ~, and ?.

A declaration of an identifier with zero following operations adds the identifier to the end of the task queue.

A declaration of an identifier followed by one or more operations defines the identifier's expansion as those operations.

It is illegal to use undefined identifiers. It is illegal to have more than one definition for an identifier.

Execution

Execution consists of dequeuing and executing the top item of the task queue repeatedly while the task queue is not empty.

Operations

+ Write 1 to the output.
- Write 0 to the output.
~ Discard the next item in the task queue.
? Read one bit from the input. If 1 is read, do nothing. If 0 is read, discard the next item in the task queue. If at EOF, discard the next two items in the task queue.
identifier Append the identifier's expansion to the end of the task queue.

Examples

Hello world:


w-+--+----++--+-+-++-++---++-++---++-++++--+------+++-
+++-++-++++-+++--+--++-++---++--+----+----+----+-+-.w.

cat:


bit? 1 0. .Read a bit
0 -bit.   .Write 0, handle next bit
1 +~.     .Write 1, discard the ensuing -
bit.      .Initial task queue

Self-printing program (formatted as multiple lines, but should be a 1-liner):


d.0-z.1+o.z--+-------++----.o--+-------++---+.q p.p--+------+++---+--+-+++--
 ---+-+-.d 0 1 1 0 0 1 0 0 0 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 1 0 1 1 0 1 0
 1 1 1 1 0 1 0 0 0 1 0 1 1 1 0 0 0 1 1 0 0 0 1 0 0 1 0 1 0 1 1 0 1 1 0 1 1 1
 1 0 0 1 0 1 1 1 0 0 1 1 1 1 0 1 0 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1
 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1
 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0
 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 1
 0 0 1 1 0 1 1 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1
 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1
 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0 0 1 0 1 1 0 1 0
 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1 1 1 0 0 1 1 1 0 0 0
 1 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 1 0 1
 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1
 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0
 0 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0
 1 0 0 1 0 1 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1
 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0 0 1 0 1 1 0 1 0 0 1
 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0
 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 1 0 0 1 1 0 0 1 0
 0 q.

Interpreter


module Main(main) where

import Data.Map(Map,empty,insert,(!))
import Data.Bits(testBit)
import Data.Char(chr,ord)
import System.Environment(getArgs)
import Text.ParserCombinators.Parsec(CharParser,anyChar,char,getState,many,many1,manyTill,newline,noneOf,runParser,setState,space,spaces,(<|>),(<?>))

data Task = Out0 | Out1 | In | Discard | Task String

parse :: String -> String -> (String -> [Task],[Task])
parse file src =
    either (error . show) id (runParser program (empty,[]) file src)

type Parser a = CharParser (Map String [Task],[Task]) a

program :: Parser (String -> [Task],[Task])
program = do
    many (space <|> comment)
    many statement
    (map,queue) <- getState
    return ((map !),reverse queue)

comment :: Parser Char
comment = do
    char '.'
    manyTill anyChar newline
    return ' '

statement :: Parser ()
statement = do
    id <- name
    body <- many task
    char '.'
    many (space <|> comment)
    (map,queue) <- getState
    setState (if null body then (map,Task id:queue)
                           else (insert id body map,queue))

task :: Parser Task
task = do
    t <-    (char '-' >> return Out0)
        <|> (char '+' >> return Out1)
        <|> (char '?' >> return In)
        <|> (char '~' >> return Discard)
        <|> fmap Task name
    spaces
    return t

name :: Parser String
name = do
    str <- many1 (noneOf "+-?~. \r\n\t\f\v")
    spaces
    return str

run :: (String -> [Task]) -> [Task] -> [Bool] -> [Bool]
run _ [] _ = []
run defs (Out0:tasks) input = False : run defs tasks input
run defs (Out1:tasks) input = True : run defs tasks input
run defs (In:[]) _ = []
run defs (In:_:[]) [] = []
run defs (In:_:_:tasks) [] = run defs tasks []
run defs (In:_:tasks) (False:input) = run defs tasks input
run defs (In:tasks) (True:input) = run defs tasks input
run defs (Discard:[]) _ = []
run defs (Discard:_:tasks) input = run defs tasks input
run defs (Task name:tasks) input = run defs (tasks ++ (defs name)) input

main :: IO ()
main = do
    (file:_) <- getArgs
    src <- readFile file
    interact (fromBits . uncurry run (parse file src) . toBits)

toBits = concatMap (flip map [7,6..0] . testBit . ord)

fromBits (b7:b6:b5:b4:b3:b2:b1:b0:rest) =
    chr ((if b7 then 128 else 0) + (if b6 then 64 else 0)
       + (if b5 then 32  else 0) + (if b4 then 16 else 0)
       + (if b3 then 8   else 0) + (if b2 then 4  else 0)
       + (if b1 then 2   else 0) + (if b0 then 1  else 0)) : fromBits rest
fromBits _ = []

2010-04-26T00:00:00.000-07:00

Last year, I made a bunch of changes to automatically do a lot of the manual configuration that was involved in adding a new component and also managed to package everything to do with a component into a single jar file that gets its own ClassLoader so that different components can't interfere with each other. Two major things were making the SNMP configuration almost completely automatic, and automatically adding new database rows required for new components as needed. I did all this after two people involved in implementing the service left so I didn't have to worry too much about stepping on toes or having a bunch of bureaucratic meetings.

It has worked pretty well so far. The biggest snag was that some people ran a build that automatically added some rows to the database, then moved back to an older build that would refuse to initialize because database didn't match the configured components. This is no longer be an issue, as there aren't even builds that old in production.

However, there is another associated service that has a horrible tiered maven build that requires a bunch of configuration in two of the maven components as well as requiring new database rows be added for each new component. As long as somebody else is taking care of all of that, I don't care. But I've been called on to add the configuration when there are new components, and it's annoying to have to add almost 200 lines of boilerplate XML and request a minor database script update for each new component, and then go through the convoluted maven build process.

There are a few other associated services that, as yet, require manually adding stuff for each new component, but other people have been taking care of it. One of them is a hack onto a legacy infrastructure and is the source of most of the usage. Another two really ought to fetch everything associated with a component from the main service, which does have all the mechanisms required for doing so, but were implemented to have hard-coded copies of a few things for each component. But, for at least one of them, it's in the pipeline to do it right, after which it would no longer need any changes every time a new component is added.

The mentality that all new components need a database script update seems to be somewhat ingrained. Even today, someone asked me if they needed to run a database script, presumably for their development environment, as new components are being released to production in a few weeks. Their database probably already has had all the new rows for months, since the code for the new components have been in place for months.

The turn programming language

2010-04-19T00:00:00.001-07:00

I decided to take a shot at making a two-dimensional programming language when noting that - and |, and / and \, and N and Z are 90-degree rotations of each other.

turn is a two-dimensional programming language that is invariant under 90-degree rotations and has any number of program counters.

A program counter (PC) has a location, direction, and turn direction.

A direction is up, right, down, or left.

A turn direction is left, straight, right, or u-turn.

Each cycle, each PC executes the operation at its location, then moves to its next location. If the next location is a wall and the turn direction is not straight, the direction is changed in the turn direction until the next location is not a wall. If the PC cannot turn to a location is not a wall, the PC dies. A PC also dies if it moves off the grid. If multiple PCs have the same location, direction, and turn direction, all but one of those PCs die. Execution ends when there are no remaining PCs.

There are 8 types of locations and their operations:
/: If the direction is horizontal, the turn direction rotates 90 degrees left. If the direction is vertical, the turn direction rotates 90 degrees right.
\: If the direction is horizontal, the turn direction rotates 90 degrees right. If the direction is vertical, the turn direction rotates 90 degrees left.
-: If the direction is horizontal, there is no effect. If the direction is vertical, the turn direction rotates 180 degrees.
|: If the direction is horizontal, the turn direction rotates 180 degrees. If the direction is vertical, there is no effect.
Z: If the direction is horizontal, read a bit from input. If the direction is vertical, write a bit to output.
N: If the direction is horizontal, write a bit to output. If the direction is vertical, read a bit from input.
+: Create a new PC at this location with direction in the turned direction and turn direction straight.
O: Read from this location or write to this location. If this location contains a bit, then read that bit, otherwise, write a bit. This location initially does not contain a bit.
space or dot (.): No-op.
^ > v <: No-op. Defines the starting location and direction of a PC. The initial turn direction is straight.
any other character: Wall. No-op.

When reading a bit, if the bit read is a 0, the turn direction is rotated 90 degrees to the left. If the bit read is a 1, the turn direction is rotated 90 degrees to the right. At EOF, the turn direction is rotates 180 degrees.

If multiple PCs read the input in a cycle, they all read the same bit. If multiple PCs read the same location in a cycle, they all read the same bit.

When writing a bit, if the turn direction is left, a 0 is written. If the turn direction is right, a 1 is written. Otherwise, nothing is written.

If multiple PCs are writing to the output in a cycle, if they all write the same value, then one bit with that value is written, otherwise nothing is written. If multiple PCs are writing to the same location in a cycle, if they all write the same value, then that value is written, otherwise nothing is written.

Examples

Hello world


>/N|N|NN|N|NNNN|NN|NN|N|N|N|N|NN|N|NN|NNN|NN|N|NN|NNN|NN|N|NNNN|NN|N|NNNNNN|NN#
 #N|N|NNNN|N|NNNN|N|NNNN|N|NN|NN|NNN|NN|N|NN|NN|N|NN|NNN|N|NNNN|N|NN|N|NNN|N|Z
  -                                                                          #
N|Z
  #

cat


 _v_
  +
 ZNZ
(   )
 ===

approximate touppercase


##|###|#||##---------#
#.......++.-.........#
##.###.#..#NO.......+#
##.......+|-.........#
##/###.#..##.........#
-.O......O...O......+#
##.###.#..##.........#
#.|N|#...............#
#.....|#.Z##.........#
AT##-#-#\.##.........#
PO.#+/+.+.....O......N
PU.#+.+.+......O.....N
RP.#+.+.+.......O....N
OP.#+.+.+........O...N
XE.#+.+.+.........O..N
IR.#+.+.+..........O.N
MC.#.#.#..##NNNNNNNN.#
AA\#+.+.+.>/++++++++.#
TS.\/\/...|APPROXIMATE
EE#######|#TOUPPERCASE

Interpreter


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Iterator;

public class Turn {
    private int height;
    private int width;
    private ArrayList<ArrayList<Instruction>> grid = new ArrayList<ArrayList<Instruction>>();
    private ArrayList<ArrayList<Boolean>> data = new ArrayList<ArrayList<Boolean>>();
    private ArrayList<PC> pcs = new ArrayList<PC>();

    public enum Instruction {
        SLASH, BACKSLASH, DASH, VERT, N, Z, PLUS, O, NOOP, WALL,
    }

    public enum TurnDir {
        STRAIGHT, RIGHT, UTURN, LEFT,
    }

    public class PC {
        private int x;
        private int y;
        private int dx;
        private int dy;
        private TurnDir turnDir;

        public PC(int x, int y, char dir) {
            this.x = x;
            this.y = y;
            switch (dir) {
            case '^': dx = 0;  dy = -1; break;
            case '>': dx = 1;  dy = 0;  break;
            case 'v': dx = 0;  dy = 1;  break;
            case '<': dx = -1; dy = 0;  break;
            default: assert false; break;
            }
            turnDir = TurnDir.STRAIGHT;
        }

        public PC(PC pc) {
            this.x = pc.x;
            this.y = pc.y;
            this.dx = pc.dx;
            this.dy = pc.dy;
            this.turnDir = pc.turnDir;
            doTurn();
            this.turnDir = TurnDir.STRAIGHT;
        }

        public boolean inBounds() {
            return x >= 0 && x < width && y >= 0 && y < height;
        }

        public void move() {
            x += dx;
            y += dy;
        }

        public Instruction rotate(Instruction insn) {
            if (dx == 0)
                return insn;
            switch (insn) {
            case SLASH: return Instruction.BACKSLASH;
            case BACKSLASH: return Instruction.SLASH;
            case DASH: return Instruction.VERT;
            case VERT: return Instruction.DASH;
            case N: return Instruction.Z;
            case Z: return Instruction.N;
            default: return insn;
            }
        }

        public TurnDir getTurnDir() {
            return turnDir;
        }

        public void setTurnDir() {
            switch (rotate(grid.get(y).get(x))) {
            case SLASH:
                turnDir = TurnDir.values()[(turnDir.ordinal()+1)%4];
                break;
            case BACKSLASH:
                turnDir = TurnDir.values()[(turnDir.ordinal()+3)%4];
                break;
            case DASH:
                turnDir = TurnDir.values()[(turnDir.ordinal()+2)%4];
                break;
            }
        }

        public boolean facingWall() {
            return x + dx >= 0 && x + dx < width
                && y + dy >= 0 && y + dy < height
                && grid.get(y + dy).get(x + dx) == Instruction.WALL;
        }

        public void doTurn() {
            int t;
            switch (turnDir) {
            case RIGHT: t = dx; dx = -dy; dy = t;  break;
            case LEFT:  t = dx; dx = dy;  dy = -t; break;
            case UTURN: dx = -dx; dy = -dy; break;
            }
        }

        public boolean isInput() {
            return rotate(grid.get(y).get(x)) == Instruction.N;
        }

        public void doInput(boolean eof, boolean bit) {
            if (eof)
                turnDir = TurnDir.values()[(turnDir.ordinal()+2)%4];
            else if (bit)
                turnDir = TurnDir.values()[(turnDir.ordinal()+1)%4];
            else
                turnDir = TurnDir.values()[(turnDir.ordinal()+3)%4];
        }

        public boolean isOutput() {
            return (turnDir == TurnDir.LEFT || turnDir == TurnDir.RIGHT)
                && rotate(grid.get(y).get(x)) == Instruction.Z;
        }

        public boolean getOutput() {
            return turnDir == TurnDir.RIGHT;
        }

        public boolean isSpawn() {
            return grid.get(y).get(x) == Instruction.PLUS
                && turnDir != TurnDir.STRAIGHT;
        }

        public boolean isReadSignal() {
            return grid.get(y).get(x) == Instruction.O
                && data.get(y).get(x) != null;
        }

        public void readSignal() {
            doInput(false, data.get(y).get(x));
        }

        public void clearSignal() {
            data.get(y).set(x, null);
        }

        public boolean isWriteSignal() {
            return (turnDir == TurnDir.LEFT || turnDir == TurnDir.RIGHT)
                && grid.get(y).get(x) == Instruction.O
                && data.get(y).get(x) == null;
        }

        public void setSignal() {
            data.get(y).set(x, getOutput());
        }

        public boolean equals(PC pc) {
            return pc.x == x && pc.y == y && pc.dx == dx && pc.dy == dy
                && pc.turnDir == turnDir;
        }

        public boolean sameLocation(PC pc) {
            return pc.x == x && pc.y == y;
        }
    }

    public Turn(BufferedReader in) throws IOException {
        String line;
        while ((line = in.readLine()) != null)
            parseLine(line);
        height = grid.size();
        width = 0;
        for (ArrayList<Instruction> row : grid)
            width = Math.max(width, row.size());
        for (ArrayList<Instruction> row : grid)
            while (row.size() < width)
                row.add(Instruction.NOOP);
        while (data.size() < height)
            data.add(new ArrayList<Boolean>());
        for (ArrayList<Boolean> row : data)
            while (row.size() < width)
                row.add(null);
    }

    private void parseLine(String line) {
        ArrayList<Instruction> row = new ArrayList<Instruction>();
        for (int i = 0; i < line.length(); i++)
            switch (line.charAt(i)) {
            case '^': case '>': case 'v': case '<':
                pcs.add(new PC(i, grid.size(), line.charAt(i)));
                /*FALLTHROUGH*/
            case ' ': case '.':
                row.add(Instruction.NOOP);
                break;
            case '/': row.add(Instruction.SLASH); break;
            case '\\': row.add(Instruction.BACKSLASH); break;
            case '-': row.add(Instruction.DASH); break;
            case '|': row.add(Instruction.VERT); break;
            case 'N': row.add(Instruction.N); break;
            case 'Z': row.add(Instruction.Z); break;
            case '+': row.add(Instruction.PLUS); break;
            case 'O': row.add(Instruction.O); break;
            case 'X': row.add(Instruction.WALL); break;
            default: row.add(Instruction.WALL); break;
            }
        grid.add(row);
    }

    public void run(BitInputStream in, BitOutputStream out) throws IOException {
        ArrayList<PC> list = new ArrayList<PC>();
        ArrayList<PC> list2 = new ArrayList<PC>();
        for (;;) {
            for (PC pc : pcs)
                if (pc.isOutput())
                    list.add(pc);
            boolean doOutput = false;
            boolean output = false;
            for (PC pc : list)
                if (doOutput) {
                    if (output != pc.getOutput()) {
                        doOutput = false;
                        break;
                    }
                } else {
                    doOutput = true;
                    output = pc.getOutput();
                }
            if (doOutput)
                out.write(output);
            list.clear();

            for (PC pc : pcs) {
                pc.setTurnDir();
                if (pc.isInput())
                    list.add(pc);
            }

            if (list.size() > 0) {
                boolean eof = in.eof();
                boolean bit = in.read();
                for (PC pc : list)
                    pc.doInput(eof, bit);
                list.clear();
            }

            for (PC pc : pcs) {
                if (pc.isReadSignal()) {
                    pc.readSignal();
                    list2.add(pc);
                    continue;
                } else if (!pc.isWriteSignal() || list.contains(pc)) {
                    continue;
                }
                doOutput = true;
                for (PC pc2 : pcs)
                    if (pc != pc2 && pc.sameLocation(pc2)) {
                        list.add(pc2);
                        if (pc.getOutput() != pc2.getOutput())
                            doOutput = false;
                    }
                if (doOutput)
                    pc.setSignal();
            }
            list.clear();
            for (PC pc : list2)
                pc.clearSignal();
            list2.clear();

            for (PC pc : pcs)
                if (pc.isSpawn())
                    list.add(new PC(pc));
            pcs.addAll(list);
            list.clear();

            loop:
            for (Iterator<PC> i = pcs.iterator(); i.hasNext(); ) {
                PC pc = i.next();
                for (PC pc2 : pcs)
                    if (pc2 != pc && pc2.equals(pc)) {
                        i.remove();
                        continue loop;
                    }
                if (pc.getTurnDir() != TurnDir.STRAIGHT) {
                    for (int n = 0; n < 4 && pc.facingWall(); n++)
                        pc.doTurn();
                    if (pc.facingWall())
                        i.remove();
                }
            }

            for (Iterator<PC> i = pcs.iterator(); i.hasNext(); ) {
                PC pc = i.next();
                pc.move();
                if (!pc.inBounds())
                    i.remove();
            }

            if (pcs.isEmpty())
                break;
        }
        out.flush();
    }

    public static class BitInputStream {
        private InputStream in;
        private int bit;
        private int octet;

        public BitInputStream(InputStream in) {
            this.in = in;
            this.bit = 0;
            this.octet = 0;
        }

        public boolean eof() throws IOException {
            if (octet >= 0 && bit == 0) {
                bit = 128;
                octet = in.read();
            }
            return octet < 0;
        }

        public boolean read() throws IOException {
            if (octet >= 0 && bit == 0) {
                bit = 128;
                octet = in.read();
            }
            try {
                return (octet & bit) != 0;
            } finally {
                bit >>>= 1;
            }
        }

        public void close() throws IOException {
            in.close();
        }
    }

    public static class BitOutputStream {
        private OutputStream out;
        private int bit;
        private int octet;

        public BitOutputStream(OutputStream out) {
            this.out = out;
            this.bit = 128;
            this.octet = 0;
        }

        public void write(boolean b) throws IOException {
            if (b)
                octet |= bit;
            bit >>>= 1;
            if (bit == 0) {
                out.write(octet);
                bit = 128;
                octet = 0;
            }
        }

        public void close() throws IOException {
            out.close();
        }

        public void flush() throws IOException {
            out.flush();
        }
    }

    public static class ASCIIBitOutputStream extends BitOutputStream {
        private OutputStream out;

        public ASCIIBitOutputStream(OutputStream out) {
            super(out);
            this.out = out;
        }

        public void write(boolean b) throws IOException {
            out.write(b ? '1' : '0');
        }
    }

    public static void main(String[] args) throws Exception {
        String src;
        BitOutputStream out;
        if ("-b".equals(args[0])) {
            src = args[1];
            out = new ASCIIBitOutputStream(System.out);
        } else {
            src = args[0];
            out = new BitOutputStream(System.out);
        }
        new Turn(new BufferedReader(new FileReader(src))).run(new BitInputStream(System.in), out);
    }
}

2010-04-12T00:00:00.000-07:00

I had never taken a serious look at the Python programming language, and I really only knew it for its usage of indentation for scoping. So I decided to try using it to implement an interpreter for my 01_ programming language, which I had implemented in Java, C, and Haskell earlier. It took a few days of my spare time.

Python is dynamically typed, and I don't like dynamic typing. The static typing of Haskell, and even Java, helps catch stupid little errors.

Python classes can't be used to create abstract data types, and only naming conventions and the double-underscore name-mangling hack are used to indicate (unenforcibly) private data.

I neither like nor dislike the syntactically significant indentation. It's just another syntax. However, if I had to work with large blocks of code, I'd prefer braces, because editors can match distant pairs of braces. But maybe people using Python would avoid writing large blocks of code. People using Java certainly do write large blocks of code, though.

Python has lots of nifty syntactical sugar enabling concise code, such as with statements, list comprehensions, and iterators. The generator coroutines for writing iterators is also nice for making readable code.

The Python library seems pretty comprehensive. I don't think it matches the Java library, but I haven't really looked at it.

In any case, I've demonstrated to myself that I can pick up a new programming language. Though, in the case of Python, I didn't learn any new programming concepts, certainly nothing mind-bending like call-with-current-continuation.

In line count, the 01_ interpreter in Python is about twice the size of the interpreter in Haskell, but about half the size of the interpreter in Java, and about a fourth the size of the interpreter in C.


import os
import sys

def tokens(chars):
    lookahead = None
    while True:
        if lookahead == None:
            char = chars.__next__()
        else:
            char = lookahead
            lookahead = None
        if char == '0' or char == '1' or char == '.' or char == '_':
            yield char
        elif char == '=':
            try:
                lookahead = chars.__next__()
            except StopIteration:
                yield '='
                raise StopIteration
            if lookahead != '=':
                yield char
            else:
                lookahead = None
                while chars.__next__() != '\n':
                    pass
        elif char != ' ' and char != '\t' and char != '\r' and char != '\n':
            symbol = char
            while True:
                try:
                    char = chars.__next__()
                except StopIteration:
                    yield symbol
                    raise StopIteration
                if (char == '0' or char == '1' or char == '.' or char == '='
                    or char == '_' or char == ' ' or char == '\t'
                    or char == '\r' or char == '\n'):
                    yield symbol
                    lookahead = char
                    break
                else:
                    symbol = symbol + char

class LiteralExpr:
    def __init__(self, bits):
        self.bits = bits

class BoundExpr:
    def __init__(self, index):
        self.index = index

class ConcatExpr:
    def __init__(self, head, tail):
        self.head = head
        self.tail = tail

class CallExpr:
    def __init__(self, fn, args):
        self.fn = fn
        self.args = args

class ParseError(BaseException):
    pass

class Pattern:
    def __init__(self, match, binding, index):
        self.match = match
        self.binding = binding
        self.index = index
    def is_wild(self):
        return self.binding == '.'
    def is_literal(self):
        return self.binding == '_'

class Defn:
    def __init__(self, tokens):
        self.name = tokens.__next__()
        if self.name == '.' or self.name == '=' or self.name == '_' \
           or self.name == '0' or self.name == '1':
            raise ParseError
        self.patterns = self._parse_patterns(tokens)
        self.body = self._collect_body(tokens)

    def _parse_patterns(self, tokens):
        patterns = []
        match = []
        index = 0
        while True:
            token = tokens.__next__()
            if token == '=':
                if match != []:
                    patterns.append(Pattern(match, ".", None))
                return patterns
            elif token == '0':
                match.append(False)
            elif token == '1':
                match.append(True)
            elif token == '.' or token == '_':
                patterns.append(Pattern(match, token, None))
                match = []
            else:
                patterns.append(Pattern(match, token, index))
                match = []
                index = index + 1

    def _collect_body(self, tokens):
        body = []
        while True:
            token = tokens.__next__()
            if token == '.':
                return body
            body.append(token)

    def _arity(self, fns, name):
        return len(fns[name][0].patterns) if name in fns else None

    def _binding(self, patterns, name):
        for pattern in patterns:
            if name == pattern.binding:
                return pattern.index
        return None

    def parse_body(self, fns):
        if len(self.body) == 0:
            self.expr = LiteralExpr([])
        else:
            self.expr = self._parse_exprs(self.body, 0, self.patterns, fns)
        del self.body

    def _parse_exprs(self, tokens, index, patterns, fns):
        exp, index = self._parse_expr(tokens, index, patterns, fns)
        if index >= len(tokens):
            return exp
        return ConcatExpr(exp, self._parse_exprs(tokens, index, patterns, fns))

    def _parse_expr(self, tokens, index, patterns, fns):
        token = tokens[index]
        if token == '0' or token == '1' or token == '_':
            return self._parse_literal(tokens, index)
        binding = self._binding(patterns, token)
        if binding != None:
            return BoundExpr(binding), index + 1
        arity = self._arity(fns, token)
        if arity == None:
            raise ParseError
        args = []
        index = index + 1
        while len(args) < arity:
            if index >= len(tokens):
                raise ParseError
            arg, index = self._parse_expr(tokens, index, patterns, fns)
            args.append(arg)
        return CallExpr(token, args), index

    def _parse_literal(self, tokens, index):
        bits = []
        while True:
            if index >= len(tokens):
                return LiteralExpr(bits), index
            elif tokens[index] == '0':
                bits.append(False)
            elif tokens[index] == '1':
                bits.append(True)
            elif tokens[index] == '_':
                return LiteralExpr(bits), index + 1
            else:
                return LiteralExpr(bits), index
            index = index + 1

def collect_defns(fns, tokens):
    def defns_list():
        while True:
            yield Defn(tokens)
    for defn in defns_list():
        if defn.name in fns:
            if len(fns[defn.name][0].patterns) != len(defn.patterns):
                raise ParseError
            fns[defn.name].append(defn)
        else:
            fns[defn.name] = [defn]

def parse_file(fns, file):
    def chars():
        for line in file:
            for char in line:
                yield char
    collect_defns(fns, tokens(chars()))

def parse_bodies(fns):
    for name, defns in fns.items():
        for defn in defns:
            defn.parse_body(fns)

class UndefinedFunctionError(BaseException):
    pass

class NilVal:
    def value():
        return None

    def next():
        assert False

class LiteralVal:
    def __init__(self, bits, index):
        self._bits = bits
        self._index = index
        self._next = None

    def value(self):
        if self._index >= len(self._bits):
            return None
        else:
            return self._bits[self._index]

    def next(self):
        if self._next == None:
            assert self._index < len(self._bits)
            self._next = LiteralVal(self._bits, self._index + 1)
        return self._next

class FileVal:
    def __init__(self, file, index = 7, byte = 0):
        self._file = file
        self._index = index
        self._byte = byte
        self._next = None

    def value(self):
        if self._byte == None:
            assert self._index == 7
            bytes = self._file.read(1)
            if len(bytes) == 0:
                self._byte = -1
                self._file.close()
            else:
                self._byte = bytes[0]
        if self._byte < 0:
            return None
        return (self._byte & (1 << self._index)) != 0

    def next(self):
        if self._next == None:
            self.value()
            assert self.value() != None
            if self._index > 0:
                self._next = FileVal(self._file, self._index - 1, self._byte)
            else:
                self._next = FileVal(self._file, 7, None)
        return self._next

class ConcatVal:
    def __init__(self, head, tail):
        self._head = head
        self._tail = tail
        self._value = None
        self._next = None

    def value(self):
        if self._head != None:
            bit = self._head.value()
            if bit != None:
                self._value = bit
                self._next = ConcatVal(self._head.next(), self._tail)
            else:
                self._value = self._tail.value()
                if self._value != None:
                    self._next = self._tail.next()
            self._head = None
            self._tail = None
        return self._value

    def next(self):
        if self._head != None:
            self.value()
            assert self._value != None
        return self._next

class ExprVal:
    def __init__(self, fns, expr, bindings):
        self._fns = fns
        self._expr = expr
        self._bindings = bindings
        self._value = None
        self._next = None

    def value(self):
        if self._expr != None:
            if self._expr.__class__ is LiteralExpr:
                self._value, self._next = self._eval_literal()
            elif self._expr.__class__ is BoundExpr:
                self._value, self._next = self._eval_bound()
            elif self._expr.__class__ is ConcatExpr:
                self._value, self._next = self._eval_concat()
            elif self._expr.__class__ is CallExpr:
                self._value, self._next = self._eval_call()
            else:
                assert False
            self._expr = None
        return self._value

    def next(self):
        if self._expr != None:
            self.value()
            assert self._value != None
        return self._next

    def _eval_literal(self):
        if self._expr.bits == []:
            return None, None
        else:
            return self._expr.bits[0], LiteralVal(self._expr.bits, 1)

    def _eval_bound(self):
        val = self._bindings[self._expr.index]
        bit = val.value()
        return bit, val.next() if bit != None else None

    def _eval_concat(self):
        head = ExprVal(self._fns, self._expr.head, self._bindings)
        tail = ExprVal(self._fns, self._expr.tail, self._bindings)
        bit = head.value()
        if bit != None:
            return bit, ConcatVal(head.next(), tail)
        else:
            bit = tail.value()
            return bit, tail.next() if bit != None else None

    def _eval_call(self):
        val = apply(self._fns, self._expr.fn,
                    [ExprVal(self._fns, arg, self._bindings)
                     for arg in self._expr.args])
        bit = val.value()
        return bit, val.next() if bit != None else None

def apply(fns, fn, args):
    def match(pattern, val):
        for bit in pattern.match:
            b = val.value()
            if b == None or b != bit:
                return False
            val = val.next()
        if pattern.is_literal():
            return val.value() == None
        elif pattern.is_wild():
            return True
        else:
            return val

    for defn in fns[fn]:
        bindings = []
        for pattern, arg in zip(defn.patterns, args):
            binding = match(pattern, arg)
            if binding == False:
                break
            elif binding == True:
                continue
            else:
                bindings.append(binding)
        else:
            return ExprVal(fns, defn.expr, bindings)
    raise UndefinedFunctionError

def write_value(value, stream):
    b = 0
    bit = 128
    while value.value() != None:
        if value.value():
            b = b | bit
        if bit == 1:
            stream.write(bytes([b]))
            bit = 128
            b = 0
        else:
            bit = bit >> 1
        value = value.next()
        
def parse_sources(files):
    fns = {}
    for file in files:
        with open(file) as f:
            parse_file(fns, f)
    parse_bodies(fns)
    return fns

def interpreter():
    source_files = []
    fn = None
    args = None
    stdin = FileVal(sys.stdin.buffer)
    for arg in sys.argv[1:]:
        if fn == None:
            if arg != '-':
                source_files.append(arg)
            else:
                fn = os.path.basename(source_files[0])
                if fn.find('.') > 0:
                    fn = fn[0:fn.find('.')]
        elif args == None:
            args = []
            fn = arg
        elif arg == '-':
            args.append(stdin)
        else:
            args.append(FileVal(open(arg, "rb")))
    if fn == None:
        fn = os.path.basename(source_files[-1])
        if fn.find('.') > 0:
            fn = fn[0:fn.find('.')]
    if args == None:
        args = []
    fns = parse_sources(source_files)
    arity = len(fns[fn][0].patterns)
    if len(args) < arity:
        args.append(stdin)
    while len(args) < arity:
        args.append(NilVal())
    write_value(apply(fns, fn, args[0:arity]), sys.stdout.buffer)

interpreter()

2010-04-05T00:00:00.000-07:00

Here is a RESOL interpreter in Java. I originally wrote it as multiple files, but crammed it into a single file for this post. The input and output queue size is limited to 10. The interpreter in Haskell does not have this limitation.


import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

public class ri {
    public static class RESOLException extends RuntimeException {
        public RESOLException(Statement statement, String message) {
            super(statement.getLocation() + ": " + message);
        }

        public RESOLException(Statement statement, String message, Throwable t) {
            super(statement.getLocation() + ": " + message, t);
        }

        public RESOLException(String fileName, int lineNumber, String message) {
            super(fileName + ":" + lineNumber + ": " + message);
        }

        public RESOLException(String fileName, int lineNumber, String message, Throwable t) {
            super(fileName + ":" + lineNumber + ": " + message, t);
        }
    }

    public static class BitInputStream {
        private InputStream in;
        private int currentByte;
        private int currentBit = 0;
        private boolean eof = false;

        public BitInputStream(InputStream in) {
            this.in = in;
        }

        public boolean eof() {
            return eof;
        }

        public boolean read() throws IOException {
            if (currentBit == 0) {
                currentByte = in.read();
                if (currentByte < 0) {
                    eof = true;
                    in.close();
                    return false;
                }
                currentBit = 128;
            }
            try {
                return (currentByte & currentBit) != 0;
            } finally {
                currentBit >>>= 1;
            }
        }
    }

    public static class BitOutputStream {
        private OutputStream out;
        private int currentByte = 0;
        private int currentBit = 128;

        public BitOutputStream(OutputStream out) {
            this.out = out;
        }

        public void write(boolean b) throws IOException {
            if (b)
                currentByte |= currentBit;
            currentBit >>>= 1;
            if (currentBit == 0) {
                out.write(currentByte);
                currentByte = 0;
                currentBit = 128;
            }
        }
    }

    public static class Statement {
        public enum Op { DATA, CALL, CONTINUE, IF, STOP }

        private String fileName;
        private int lineNumber;
        private String label;
        private Op op;
        private String arg1;
        private String arg2;
        private Statement next = null;
        private int itemSize = 0;
        private LinkedList<LinkedList<Integer>> queueStack = null;
        private LinkedList<Statement> callStack = null;

        public Statement(String fileName, int lineNumber, String label, Op op, String arg1, String arg2) {
            this.fileName = fileName;
            this.lineNumber = lineNumber;
            this.label = label == null || label.length() == 0 ? null : label;
            this.op = op;
            this.arg1 = arg1;
            this.arg2 = arg2;
            switch (op) {
            case DATA:
                if (arg1 == null)
                    throw new RESOLException(this, "DATA STATEMENT REQUIRES AN ARGUMENT");
                if (label != null) {
                    itemSize = Integer.parseInt(arg1, 10);
                    queueStack = new LinkedList<LinkedList<Integer>>();
                    queueStack.addFirst(new LinkedList<Integer>());
                    if (arg2 != null)
                        enqueueLiteral(arg2);
                }
                break;
            case CALL:
                if (arg1 == null)
                    throw new RESOLException(this, "CALL STATEMENT REQUIRES AN ARGUMENT");
                break;
            case CONTINUE:
                if (arg1 == null)
                    throw new RESOLException(this, "CONTINUE STATEMENT REQUIRES AN ARGUMENT");
                break;
            case IF:
                if (arg1 == null || arg2 == null)
                    throw new RESOLException(this, "IF STATEMENT REQUIRES TWO ARGUMENTS");
                break;
            case STOP:
                if (arg1 != null || arg2 != null)
                    throw new RESOLException(this, "STOP STATEMENT CANNOT HAVE ANY ARGUMENTS");
                break;
            }
            if (label != null)
                callStack = new LinkedList<Statement>();
        }

        protected String getFileName() {
            return fileName;
        }

        protected int getLineNumber() {
            return lineNumber;
        }

        public String getLabel() {
            return label;
        }

        protected Op getOp() {
            return op;
        }

        protected String getArg1() {
            return arg1;
        }

        protected String getArg2() {
            return arg2;
        }

        public void setNext(Statement next) {
            this.next = next;
        }

        public String getLocation() {
            return fileName + ":" + lineNumber;
        }

        public void enqueueLiteral(String literal) {
            for (int i = 0; i < literal.length(); i++)
                enqueueDigit(literal.charAt(i) - '0');
        }

        public void enqueueItem(LinkedList<Integer> queue, int queueItemSize) {
            for (int i = 0; i < Math.min(queue.size(), queueItemSize); i++)
                enqueueDigit(queue.get(i));
        }

        public void enqueueDigit(int digit) {
            assert digit >= 0 && digit <= 9;
            queueStack.getFirst().addLast(digit);
        }

        public void dequeueItem() {
            for (int i = 0; i < itemSize && queueStack.getFirst().size() > 0; i++)
                queueStack.getFirst().removeFirst();
        }

        public int getCurrentItemSize() {
            return Math.min(itemSize, queueStack.getFirst().size());
        }

        public int getItemDigit(int index) {
            assert index < itemSize;
            return queueStack.getFirst().get(index);
        }

        public Statement popCall(Statement t, Statement n) {
            if (queueStack != null)
                queueStack.removeFirst();
            return callStack.removeFirst();
        }

        public void pushCall(Statement t, Statement n) {
            if (queueStack != null)
                queueStack.addFirst(new LinkedList<Integer>());
            callStack.addFirst(n);
        }

        public boolean isData() {
            return op == Op.DATA;
        }

        private static void enqueueTo(Statement statement, String arg, Map<String,Statement> labels) {
            if (!statement.isData())
                return;
            Statement argStatement = labels.get(arg);
            if (argStatement == null)
                statement.enqueueLiteral(arg);
            else
                for (int i = 0; i < argStatement.getCurrentItemSize(); i++)
                    statement.enqueueDigit(argStatement.getItemDigit(i));
        }

        private static boolean equalTo(String arg1, String arg2, Map<String,Statement> labels) {
            if (arg1.equals(arg2))
                return true;
            Statement statement1 = labels.get(arg1);
            Statement statement2 = labels.get(arg2);
            if (statement1 == null && statement2 == null)
                return false;
            if (statement1 != null && statement2 != null) {
                if (statement1.getCurrentItemSize() != statement2.getCurrentItemSize())
                    return false;
                for (int i = 0; i < statement1.getCurrentItemSize(); i++)
                    if (statement1.getItemDigit(i) != statement2.getItemDigit(i))
                        return false;
                return true;
            }
            if (statement1 == null) {
                statement1 = statement2;
                arg2 = arg1;
            }
            if (statement1.getCurrentItemSize() != arg2.length())
                return false;
            for (int i = 0; i < arg2.length(); i++)
                if (statement1.getItemDigit(i) != arg2.charAt(i) - '0')
                    return false;
            return true;
        }

        public Statement run(Map<String,Statement> labels) {
            Statement statement = null;
            Statement statement2 = null;
            switch (op) {
            case DATA:
                statement = labels.get(arg1);
                if (statement == null || !statement.isData())
                    break;
                if (arg2 == null)
                    statement.dequeueItem();
                else
                    enqueueTo(statement, arg2, labels);
                break;

            case CALL:
                statement = labels.get(arg1);
                if (statement == null)
                    throw new RESOLException(this, "CALL TO UNKNOWN LABEL: " + arg1);
                if (next == null)
                    throw new RESOLException(this, "UNEXPECTED END OF PROGRAM");
                statement.pushCall(this, next);
                if (arg2 != null)
                    enqueueTo(statement, arg2, labels);
                return statement;

            case CONTINUE:
                statement = labels.get(arg1);
                if (statement == null)
                    throw new RESOLException(this, "CONTINUE FROM UNKNOWN LABEL: " + arg1);
                if (!statement.isData() || statement.getCurrentItemSize() == 0)
                    return statement.popCall(this, next);
                if (arg2 == null)
                    return statement;
                statement = labels.get(arg2);
                if (statement == null)
                    throw new RESOLException(this, "CONTINUE FROM UNKNOWN LABEL: " + arg2);
                return statement;

            case IF:
                if (!equalTo(arg1, arg2, labels)) {
                    if (next == null || next.next == null)
                        throw new RESOLException(this, "UNEXPECTED END OF PROGRAM");
                    return next.next;
                }
                break;

            case STOP:
                return null;
            }
            if (next == null)
                throw new RESOLException(this, "UNEXPECTED END OF PROGRAM");
            return next;
        }
    }

    public static class FirstStatement extends Statement {
        private boolean encodeOutput;
        private boolean isIO;
        private int[] inputItem = null;
        private int inputItemSize;
        private BitInputStream in;
        private int[] outputItem = null;
        private int outputItemSize;
        private BitOutputStream out;
        private int itemBitCount;

        public FirstStatement(Statement statement, boolean encodeOutput) {
            super(statement.getFileName(), statement.getLineNumber(), statement.getLabel(), statement.getOp(), statement.getArg1(), statement.getArg2());
            this.encodeOutput = encodeOutput;
            isIO = getLabel() != null && getOp() == Op.DATA;
            if (isIO) {
                int itemSize = Integer.parseInt(getArg1(), 10);
                inputItem = new int[itemSize];
                inputItemSize = 0;
                in = new BitInputStream(System.in);
                outputItem = new int[itemSize];
                outputItemSize = 0;
                out = new BitOutputStream(System.out);

                int test = 0;
                for (int i = 0; i < itemSize; i++)
                    test = test*10 + 9;
                itemBitCount = 0;
                boolean decCount = false;
                while (test > 0) {
                    if ((test & 1) == 0)
                        decCount = true;
                    test >>>= 1;
                    itemBitCount++;
                }
                if (decCount)
                    itemBitCount--;
            }
        }

        public void enqueueDigit(int digit) {
            if (!encodeOutput) {
                System.out.print(digit);
                return;
            }
            outputItem[outputItemSize++] = digit;
            if (outputItemSize >= outputItem.length)
                flushOutput();
        }

        public void flushOutput() {
            int item = 0;
            for (int i = 0; i < outputItem.length; i++)
                item = item*10 + outputItem[i];
            int bit = 1 << (itemBitCount - 1);
            while (bit != 0) {
                try {
                    out.write((item & bit) != 0);
                } catch (IOException e) {
                    throw new RESOLException(this, "IO EXCEPTION", e);
                }
                bit >>>= 1;
            }
            outputItemSize = 0;
            Arrays.fill(outputItem, 0);
        }

        public void dequeueItem() {
            readItem();
        }

        public int getCurrentItemSize() {
            if (inputItemSize == 0)
                readItem();
            return inputItemSize;
        }

        public int getItemDigit(int index) {
            return inputItem[index];
        }

        private void readItem() {
            inputItemSize = 0;
            if (in.eof())
                return;
            int item = 0;
            int bit = 1 << (itemBitCount - 1);
            while (!in.eof() && bit != 0) {
                boolean b;
                try {
                    b = in.read();
                } catch (IOException e) {
                    throw new RESOLException(this, "IO EXCEPTION", e);
                }
                if (in.eof())
                    break;
                if (b)
                    item |= bit;
                bit >>>= 1;
            }
            for (int i = inputItem.length - 1; i >= 0; i--) {
                inputItem[i] = item%10;
                item = item/10;
            }
            inputItemSize = inputItem.length;
        }

        public Statement popCall(Statement t, Statement n) {
            if (!isIO)
                return super.popCall(t, n);
            if (n == null)
                throw new RESOLException(t, "UNEXPECTED END OF PROGRAM");
            return n;
        }

        public void pushCall(Statement t, Statement n) {
            if (isIO)
                throw new RESOLException(t, "ILLEGAL CALL");
            super.pushCall(t, n);
        }
    }

    public static class Parser implements Iterable<Statement>, Iterator<Statement> {
        private Reader in;
        private String fileName;
        private int lineNumber;
        private int statementLineNumber = 1;
        private StringBuilder currentLabel = new StringBuilder();
        private StringBuilder currentStatement = new StringBuilder();
        private Statement statement = null;
        private boolean eof = false;

        public Parser(String fileName) throws IOException {
            this(fileName, new FileReader(fileName));
        }

        public Parser(String fileName, Reader in) {
            this.fileName = fileName;
            this.in = in;
            this.lineNumber = 0;
        }

        public Iterator<Statement> iterator() {
            return this;
        }

        public boolean hasNext() {
            while (statement == null && !eof)
                try {
                    readLine();
                } catch (IOException e) {
                    throw new RESOLException(fileName, lineNumber, "IO EXCEPTION", e);
                }
            return statement != null;
        }

        public Statement next() {
            hasNext();
            try {
                return statement;
            } finally {
                statement = null;
            }
        }

        public void remove() {
        }

        private void readLine() throws IOException {
            lineNumber++;
            int column = 1;
            int c = in.read();
            if (c < 0) {
                eof = true;
                in.close();
                finishStatement();
                return;
            }
            if (c == 'C') {
                finishStatement();
                statementLineNumber++;
                while (c >= 0 && c != '\n')
                    c = in.read();
                if (c < 0) {
                    eof = true;
                    in.close();
                }
                return;
            }
            StringBuilder sb = new StringBuilder();
            while (column < 6) {
                if (c != ' ') {
                    if (isDigit(c))
                        sb.append((char) c);
                    else
                        throw new RESOLException(fileName, lineNumber, "ILLEGAL LABEL");
                }
                c = in.read();
                column++;
                if (c < 0) {
                    eof = true;
                    in.close();
                    if (sb.length() > 0)
                        throw new RESOLException(fileName, lineNumber, "UNEXPECTED EOF");
                    finishStatement();
                    return;
                }
                if (c == '\n') {
                    finishStatement();
                    return;
                }
            }
            if (c == ' ')
                finishStatement();
            currentLabel.append(sb);
            for (;;) {
                c = in.read();
                column++;
                if (c < 0) {
                    eof = true;
                    in.close();
                    finishStatement();
                    return;
                }
                if (c == '\n')
                    return;
                if (c == ' ' || column > 72)
                    continue;
                if (isDigit(c) || isLetter(c) || c == ',')
                    currentStatement.append((char) c);
                else
                    throw new RESOLException(fileName, lineNumber, "UNEXPECTED CHARACTER");
            }
        }

        private boolean isDigit(int c) {
            return c >= '0' && c <= '9';
        }

        private boolean isLetter(int c) {
            return c >= 'A' && c <= 'Z';
        }

        private void finishStatement() {
            assert statement == null;
            if (currentStatement.length() == 0 && currentLabel.length() == 0) {
                statementLineNumber = lineNumber;
                return;
            }
            int i = 0;
            while (i < currentStatement.length() && isLetter(currentStatement.charAt(i)))
                i++;
            Statement.Op op;
            try {
                op = Enum.valueOf(Statement.Op.class, currentStatement.substring(0, i));
            } catch (IllegalArgumentException e) {
                throw new RESOLException(fileName, statementLineNumber, "UNRECOGNIZED STATEMENT");
            }
            String arg1 = null;
            int i2 = i;
            while (i2 < currentStatement.length() && isDigit(currentStatement.charAt(i2)))
                i2++;
            if (i2 < currentStatement.length()) {
                if (i2 == i || currentStatement.charAt(i2) != ',')
                    throw new RESOLException(fileName, statementLineNumber, "ILLEGAL ARGUMENT");
            }
            if (i < i2)
                arg1 = currentStatement.substring(i, i2);
            String arg2 = null;
            i = i2 + 1;
            i2 = i;
            while (i2 < currentStatement.length() && isDigit(currentStatement.charAt(i2)))
                i2++;
            if (i2 < currentStatement.length())
                throw new RESOLException(fileName, statementLineNumber, "ILLEGAL ARGUMENT");
            if (i < i2)
                arg2 = currentStatement.substring(i, i2);
            statement = new Statement(fileName, statementLineNumber, currentLabel.toString(), op, arg1, arg2);
            statementLineNumber = lineNumber;
            currentLabel.setLength(0);
            currentStatement.setLength(0);
        }
    }

    public static void main(String[] args) throws Exception {
        boolean encodeOutput = true;
        int index = 0;
        if (index < args.length && "-r".equals(args[index])) {
            encodeOutput = false;
            index++;
        }
        FirstStatement first = null;
        Statement last = null;
        HashMap<String,Statement> labels = new HashMap<String,Statement>();
        for (; index < args.length; index++)
            for (Statement s : new Parser(args[index])) {
                if (first == null)
                    s = first = new FirstStatement(s, encodeOutput);
                else if (last != null)
                    last.setNext(s);
                last = s;
                if (s.getLabel() != null) {
                    if (labels.containsKey(s.getLabel()))
                        throw new RESOLException(s, "DUPLICATE LABEL");
                    labels.put(s.getLabel(), s);
                }
            }
        last = first;
        while (last != null)
            last = last.run(labels);
    }
}

2010-03-29T00:00:00.000-07:00

Here is a RESOL program that prints itself.


001   DATA1
      DATA001,99999
      CALL004,99999
      CALL10000,0010
      CALL10002
      CALL002
      STOP
002   DATA1
      DATA002
      DATA002,10001
      DATA001,10001
      DATA10001
      CONTINUE002
004   DATA000066
      CALL005,004
      DATA004
      CONTINUE004
005   DATA1
      CALL10000,0010020002000200020002000211
006   IF005,0
      CALL10000,0300
      IF005,1
      CALL10000,0301
      IF005,2
      CALL10000,0302
      IF005,3
      CALL10000,0303
      IF005,4
      CALL10000,0304
      IF005,5
      CALL10000,0305
      IF005,6
      CALL10000,0306
      IF005,7
      CALL10000,0307
      CALL002
      DATA005
      CONTINUE005,006
C THIS IS A LIBRARY THAT CONVERTS 4-BIT ITEMS ENQUEUED INTO 10000 AS 2 DIGITS
C INTO 3-BIT ITEMS IN 1 DIGIT THAT ARE AVAILABLE AT 10001.
C CALL 10000 TO PROCESS ITEMS FROM 10000 INTO 10001.
C CALL 10002 TO FLUSH THE FINAL DANGLING BITS (0-2 BITS).
C IF 000002 IS A DATA STATEMENT, CALLING 10000 WILL DEQUEUE FROM IT.  BEST
C NOT TO HAVE 000002 AS A LABEL (WHICH WOULD REQUIRE A CONTINUATION LINE).
10000 DATA 000002
      IF 10003,11000
      CALL 10100
      IF 10003,11001
      CALL 10110
      IF 10003,11002
      CALL 10120
      DATA 10003
      DATA 10000
      CONTINUE 10000
10001 DATA 1
C FLUSH THE FINAL DANGLING BITS
10002 IF 10003,11000
      CONTINUE 10002
      DATA 10001,10004
      DATA 10004
C REINITIALIZE 10003 TO 012
      IF 10003,11001
      DATA 10003
      DATA 10003
      DATA 10003,012
      CONTINUE 10002
C 10003 HOLDS THE NUMBER OF DANGLING BITS
10003 DATA 1,012
C 10004 HOLDS THE VALUE OF THE DANGLING BITS
10004 DATA 1
C NO DANGLING BITS FROM BEFORE.  LEAVES 1 DANGLING BIT FOR NEXT ITEM.
10100 IF 10000,12000
      DATA 10001,11000
      IF 10000,12000
      DATA 10004,11000
      IF 10000,12001
      DATA 10001,11000
      IF 10000,12001
      DATA 10004,11004
      IF 10000,12002
      DATA 10001,11001
      IF 10000,12002
      DATA 10004,11000
      IF 10000,12003
      DATA 10001,11001
      IF 10000,12003
      DATA 10004,11004
      IF 10000,12004
      DATA 10001,11002
      IF 10000,12004
      DATA 10004,11000
      IF 10000,12005
      DATA 10001,11002
      IF 10000,12005
      DATA 10004,11004
      IF 10000,12006
      DATA 10001,11003
      IF 10000,12006
      DATA 10004,11000
      IF 10000,12007
      DATA 10001,11003
      IF 10000,12007
      DATA 10004,11004
      IF 10000,12008
      DATA 10001,11004
      IF 10000,12008
      DATA 10004,11000
      IF 10000,12009
      DATA 10001,11004
      IF 10000,12009
      DATA 10004,11004
      IF 10000,12010
      DATA 10001,11005
      IF 10000,12010
      DATA 10004,11000
      IF 10000,12011
      DATA 10001,11005
      IF 10000,12011
      DATA 10004,11004
      IF 10000,12012
      DATA 10001,11006
      IF 10000,12012
      DATA 10004,11000
      IF 10000,12013
      DATA 10001,11006
      IF 10000,12013
      DATA 10004,11004
      IF 10000,12014
      DATA 10001,11007
      IF 10000,12014
      DATA 10004,11000
      IF 10000,12015
      DATA 10001,11007
      IF 10000,12015
      DATA 10004,11004
      CONTINUE 10100
C 1 DANGLING BIT FROM BEFORE.  LEAVES 2 DANGLING BITS FOR NEXT ITEM.
10110 IF 10004,11000
      CALL 10111
      IF 10004,11004
      CALL 10112
      DATA 10004
      CONTINUE 10110
C DANGLING 0 FROM BEFORE
10111 IF 10000,12000
      DATA 10001,11000
      IF 10000,12000
      DATA 10004,11000
      IF 10000,12001
      DATA 10001,11000
      IF 10000,12001
      DATA 10004,11002
      IF 10000,12002
      DATA 10001,11000
      IF 10000,12002
      DATA 10004,11004
      IF 10000,12003
      DATA 10001,11000
      IF 10000,12003
      DATA 10004,11006
      IF 10000,12004
      DATA 10001,11001
      IF 10000,12004
      DATA 10004,11000
      IF 10000,12005
      DATA 10001,11001
      IF 10000,12005
      DATA 10004,11002
      IF 10000,12006
      DATA 10001,11001
      IF 10000,12006
      DATA 10004,11004
      IF 10000,12007
      DATA 10001,11001
      IF 10000,12007
      DATA 10004,11006
      IF 10000,12008
      DATA 10001,11002
      IF 10000,12008
      DATA 10004,11000
      IF 10000,12009
      DATA 10001,11002
      IF 10000,12009
      DATA 10004,11002
      IF 10000,12010
      DATA 10001,11002
      IF 10000,12010
      DATA 10004,11004
      IF 10000,12011
      DATA 10001,11002
      IF 10000,12011
      DATA 10004,11006
      IF 10000,12012
      DATA 10001,11003
      IF 10000,12012
      DATA 10004,11000
      IF 10000,12013
      DATA 10001,11003
      IF 10000,12013
      DATA 10004,11002
      IF 10000,12014
      DATA 10001,11003
      IF 10000,12014
      DATA 10004,11004
      IF 10000,12015
      DATA 10001,11003
      IF 10000,12015
      DATA 10004,11006
      CONTINUE 10111
C DANGLING 1 FROM BEFORE
10112 IF 10000,12000
      DATA 10001,11004
      IF 10000,12000
      DATA 10004,11000
      IF 10000,12001
      DATA 10001,11004
      IF 10000,12001
      DATA 10004,11002
      IF 10000,12002
      DATA 10001,11004
      IF 10000,12002
      DATA 10004,11004
      IF 10000,12003
      DATA 10001,11004
      IF 10000,12003
      DATA 10004,11006
      IF 10000,12004
      DATA 10001,11005
      IF 10000,12004
      DATA 10004,11000
      IF 10000,12005
      DATA 10001,11005
      IF 10000,12005
      DATA 10004,11002
      IF 10000,12006
      DATA 10001,11005
      IF 10000,12006
      DATA 10004,11004
      IF 10000,12007
      DATA 10001,11005
      IF 10000,12007
      DATA 10004,11006
      IF 10000,12008
      DATA 10001,11006
      IF 10000,12008
      DATA 10004,11000
      IF 10000,12009
      DATA 10001,11006
      IF 10000,12009
      DATA 10004,11002
      IF 10000,12010
      DATA 10001,11006
      IF 10000,12010
      DATA 10004,11004
      IF 10000,12011
      DATA 10001,11006
      IF 10000,12011
      DATA 10004,11006
      IF 10000,12012
      DATA 10001,11007
      IF 10000,12012
      DATA 10004,11000
      IF 10000,12013
      DATA 10001,11007
      IF 10000,12013
      DATA 10004,11002
      IF 10000,12014
      DATA 10001,11007
      IF 10000,12014
      DATA 10004,11004
      IF 10000,12015
      DATA 10001,11007
      IF 10000,12015
      DATA 10004,11006
      CONTINUE 10112
C 2 DANGLING BITS FROM BEFORE.  LEAVES NO DANGLING BITS FOR NEXT ITEM.
10120 IF 10004,11000
      CALL 10121
      IF 10004,11002
      CALL 10122
      IF 10004,11004
      CALL 10123
      IF 10004,11006
      CALL 10124
      DATA 10003,13012
      DATA 10004
      IF 10000,12000
      DATA 10001,11000
      IF 10000,12001
      DATA 10001,11001
      IF 10000,12002
      DATA 10001,11002
      IF 10000,12003
      DATA 10001,11003
      IF 10000,12004
      DATA 10001,11004
      IF 10000,12005
      DATA 10001,11005
      IF 10000,12006
      DATA 10001,11006
      IF 10000,12007
      DATA 10001,11007
      IF 10000,12008
      DATA 10001,11000
      IF 10000,12009
      DATA 10001,11001
      IF 10000,12010
      DATA 10001,11002
      IF 10000,12011
      DATA 10001,11003
      IF 10000,12012
      DATA 10001,11004
      IF 10000,12013
      DATA 10001,11005
      IF 10000,12014
      DATA 10001,11006
      IF 10000,12015
      DATA 10001,11007
      CONTINUE 10120
C DANGLING 00 FROM BEFORE
10121 IF 10000,12000
      DATA 10001,11000
      IF 10000,12001
      DATA 10001,11000
      IF 10000,12002
      DATA 10001,11000
      IF 10000,12003
      DATA 10001,11000
      IF 10000,12004
      DATA 10001,11000
      IF 10000,12005
      DATA 10001,11000
      IF 10000,12006
      DATA 10001,11000
      IF 10000,12007
      DATA 10001,11000
      IF 10000,12008
      DATA 10001,11001
      IF 10000,12009
      DATA 10001,11001
      IF 10000,12010
      DATA 10001,11001
      IF 10000,12011
      DATA 10001,11001
      IF 10000,12012
      DATA 10001,11001
      IF 10000,12013
      DATA 10001,11001
      IF 10000,12014
      DATA 10001,11001
      IF 10000,12015
      DATA 10001,11001
      CONTINUE 10121
C DANGLING 01 FROM BEFORE
10122 IF 10000,12000
      DATA 10001,11002
      IF 10000,12001
      DATA 10001,11002
      IF 10000,12002
      DATA 10001,11002
      IF 10000,12003
      DATA 10001,11002
      IF 10000,12004
      DATA 10001,11002
      IF 10000,12005
      DATA 10001,11002
      IF 10000,12006
      DATA 10001,11002
      IF 10000,12007
      DATA 10001,11002
      IF 10000,12008
      DATA 10001,11003
      IF 10000,12009
      DATA 10001,11003
      IF 10000,12010
      DATA 10001,11003
      IF 10000,12011
      DATA 10001,11003
      IF 10000,12012
      DATA 10001,11003
      IF 10000,12013
      DATA 10001,11003
      IF 10000,12014
      DATA 10001,11003
      IF 10000,12015
      DATA 10001,11003
      CONTINUE 10122
C DANGLING 10 FROM BEFORE
10123 IF 10000,12000
      DATA 10001,11004
      IF 10000,12001
      DATA 10001,11004
      IF 10000,12002
      DATA 10001,11004
      IF 10000,12003
      DATA 10001,11004
      IF 10000,12004
      DATA 10001,11004
      IF 10000,12005
      DATA 10001,11004
      IF 10000,12006
      DATA 10001,11004
      IF 10000,12007
      DATA 10001,11004
      IF 10000,12008
      DATA 10001,11005
      IF 10000,12009
      DATA 10001,11005
      IF 10000,12010
      DATA 10001,11005
      IF 10000,12011
      DATA 10001,11005
      IF 10000,12012
      DATA 10001,11005
      IF 10000,12013
      DATA 10001,11005
      IF 10000,12014
      DATA 10001,11005
      IF 10000,12015
      DATA 10001,11005
      CONTINUE 10123
C DANGLING 11 FROM BEFORE
10124 IF 10000,12000
      DATA 10001,11006
      IF 10000,12001
      DATA 10001,11006
      IF 10000,12002
      DATA 10001,11006
      IF 10000,12003
      DATA 10001,11006
      IF 10000,12004
      DATA 10001,11006
      IF 10000,12005
      DATA 10001,11006
      IF 10000,12006
      DATA 10001,11006
      IF 10000,12007
      DATA 10001,11006
      IF 10000,12008
      DATA 10001,11007
      IF 10000,12009
      DATA 10001,11007
      IF 10000,12010
      DATA 10001,11007
      IF 10000,12011
      DATA 10001,11007
      IF 10000,12012
      DATA 10001,11007
      IF 10000,12013
      DATA 10001,11007
      IF 10000,12014
      DATA 10001,11007
      IF 10000,12015
      DATA 10001,11007
      CONTINUE 10124
C CONSTANTS
11000 DATA 1,0
11001 DATA 1,1
11002 DATA 1,2
11003 DATA 1,3
11004 DATA 1,4
11005 DATA 1,5
11006 DATA 1,6
11007 DATA 1,7
12000 DATA 2,00
12001 DATA 2,01
12002 DATA 2,02
12003 DATA 2,03
12004 DATA 2,04
12005 DATA 2,05
12006 DATA 2,06
12007 DATA 2,07
12008 DATA 2,08
12009 DATA 2,09
12010 DATA 2,10
12011 DATA 2,11
12012 DATA 2,12
12013 DATA 2,13
12014 DATA 2,14
12015 DATA 2,15
13012 DATA 3,012
99999 DATA 40000,
     +140300611002004021040524202304121002004010020040210405242023006014
     +226071162344711620504010020040100201032024611414030064130344711623
     +447102420040100200401004150123046061140300601402606014030460024200
     +401002004010041501230460611403006014405040100200401002010320246114
     +140300620242004010020040100515242365001214030062100200402104052420
     +230412100200401002004021040524202300601440504010020040100201042025
     +210114030062130304601403006102420040100200401004210125040460140304
     +541423006014030412100200401002004021040524202304601403006102420040
     +100200401004151723452111234525051403006202430060150200401004210125
     +040460140300601543301210020040100200402064051423030060152260601403
     +201210020040100200402104052420230060150050401002004010020103236471
     +242224712521230060150050601403244010020104202521011420504010020040
     +100201032024611414230060140300541403006114030062140300601443006014
     +031060140300621403006014430060140310611420506014033040100201112143
     +006015226060024200401002004010041501230460611403006014026060146300
     +600242004010020040100445061403006513030412100200401002004020640514
     +230304601403006013030063140304121002004010020040222430601403245414
     +405040100200401002010320246114142300601403005414031460144050401002
     +004010020111214300601522606302420040100200401004150123046061140300
     +601402606014630063024200401002004010044506140300651303201210020040
     +100200402064051423030460140300601303006314032012100200401002004022
     +243060140324541520504010020040100201032024611414230060140300541403
     +146015205040100200401002011121430060152260660242004010020040100415
     +012304606114030060140260601463006602420040100200401004450614030065
     +130334121002004010020040206405142303046014030060130300631403341210
     +020040100200402064051423030060144050401002004010020104202521011403
     +006502420040100200401004151723452111234525051403006513030060154051
     +031005211022251440222514402022011422241122202511311005211020252040
     +206475162544252225051440150265022225204022252105232514402124712125
     +242525212420402224712423620061140300601402010124620062100421112164
     +452424605103100445162504744014626502222520402225210523251440222470
     +401422010422243511250201242204052410040522212201012544051123040502
     +230424402025204014230060140304560244144020640514230200611403006014
     +020124236201202444750321251523100445242124652310043122236464401423
     +006014030040222471242362006114030060142270122062010320246114100304
     +601403006210052117100431142525151010052110212201062224710123020104
     +202471072304451621620102222521231002406013231040204445242462445602
     +441440222430401403006014030062100445231004044021040524202201232504
     +052421246505234520541004150123046111234434401423006014030040256445
     +142302010421250525212525051004312223646440222520561002010221251524
     +024414402344752410052117100441012544244014030060140300621004052310
     +040440230405022124604012053510222415101005351725246104100511052425
     +251124442440202201032364712422247125202521112364704023044516212244
     +560243046014030060100421012504044014030060140300620242004010020040
     +100445061003046014030063130304611403006002420040100200401004150123
     +046040142300611403001210020040100200402224304014230060140314541423
     +046014030412100200401002004020640514230200611403046114005040100200
     +401002011121420061140300601462606114230060144050401002004010020103
     +202461141003046014231060024200401002004010042101250404401423006014
     +031412100200401002004021040524202200611403006014005040100200401002
     +010323647124222471252122006114030060140050611403006014220104202521
     +011003041220620106230525232202012422042440214445162024604021040516
     +216461112344344020444524246050611403006014420111214200611403006014
     +626061142300601400504010020040100201032364712422247125212200611403
     +006014405040100200401002010420252101100304601403006113030460140300
     +640242004010020040100421012504044014230060140320122062012221244516
     +222521112024611126442440142300601403144025047440140304620242004010
     +020040100445061003046014030063130304611403006102420040100200401004
     +210125040440142300601403141210020040100200402104052420220061140300
     +601460504010020040100201042025210110030460140300631303006114405040
     +100200401002010323647124222471252122006114030060144051031003046014
     +030063100441172304212310052110212201162524650221251040236430402104
     +051621646111234434402044452424605061140300601462010420252101100304
     +541403046202441440142300601403204022047514210514402504410510053101
     +230525051004750610052110212201042024710723044516216201022225212302
     +430460140300641004210125040440142051031004711710042101234435142224
     +710710041111250514402145111723220102212431172444245610020114212405
     +262125144014220104202471072304451621620102222520402144752210047105
     +260520402225210523227012142300611403004022243040142300601403005414
     +231060140300121002004010020040210405242022006114030060142260611423
     +006014005040100200401002011121420061140300601402606114430060140050
     +401002004010020104202521011003046014030064130304611403006002420040
     +100200401004450610030460140300601303046214030061024200401002004010
     +042101250404401423006014030454142304601403001210020040100200402224
     +304014230060140300541423106014030412100200401002004021040524202200
     +611403006015026061142300601500504010020040100201112142006114030060
     +140260611443006014405040100200401002010420252101100304601403006113
     +030461140300610242004010020040100445061003046014030060130304621403
     +006202420040100200401004210125040440142300601403205414230460140300
     +121002004010020040222430401423006014030054142310601403141210020040
     +100200402104052420220061140300601422606114230060142050401002004010
     +020111214200611403006014026061144300601460504010020040100201042025
     +210110030460140300641303046114030064024200401002004010044506100304
     +601403006013030462140300640242004010020040100421012504044014230060
     +140304541423046014031012100200401002004022243040142300601403005414
     +231060140320121002004010020040210405242022006114030060150260611423
     +006014005040100200401002011121420061140300601402606114430060152050
     +401002004010020104202521011003046014030061130304611403006202420040
     +100200401004450610030460140300601303046214030065024200401002004010
     +042101250404401423006014032054142304601403201210020040100200402224
     +304014230060140300541423106014033012100200401002004021040524202200
     +611403006014226061142300601460504010020040100201112142006114030060
     +140260611443006015405040100200401002010420252101100304601403006413
     +030461140300600242004010020040100445061003046014030060130304621403
     +006702420040100200401004210125040440142300601403045414230460140314
     +121002004010020040222430401423006014030054142310601403341210020040
     +100200402104052420220061140300601502606114230060150050401002004010
     +020111214200611403006014026061144300601600504010020040100201042025
     +210110030460140300611303046114030064024200401002004010044506100304
     +601403006013030462140300700242004010020040100421012504044014230060
     +140320541423046014030012100200401002004022243040142300601403005414
     +231060140344121002004010020040210405242022006114030060142260611423
     +006015005040100200401002011121420061140300601402606114430060162050
     +401002004010020104202521011003046014030064130304611403006402420040
     +100200401004450610030460140300601303046214030460024200401002004010
     +042101250404401423006014030454142304601403241210020040100200402224
     +304014230060140300541423106014230012100200401002004021040524202200
     +611403006015026061142300601400504010020040100201112142006114030060
     +140260611443006114205040100200401002010420252101100304601403006113
     +030461140300650242004010020040100445061003046014030060130304621403
     +046102420040100200401004210125040440142300601403205414230460140320
     +121002004010020040222430401423006014030054142310601423101210020040
     +100200402104052420220061140300601422606114230060154050401002004010
     +020111214200611403006014026061144300611440504010020040100201042025
     +210110030460140300641303046114030060024200401002004010044506100304
     +601403006013030462140304630242004010020040100421012504044014230060
     +140304541423046014033012100200401002004022243040142300601403005414
     +231060142314121002004010020040210405242022006114030060150260611423
     +006015005040100200401002011121420061140300601402606114430061150050
     +401002004010020104202521011003046014030061130304611403006702420040
     +100200401004450610030460140300601303046214030464024200401002004010
     +042101250404401423006014032054142304601403001210020040100200402224
     +304014230060140300541423106014232412100200401002004021040524202200
     +611403006014226061142300601560504010020040100201112142006114030060
     +140260611443006115205040100200401002010420252101100304601403006413
     +030461140300640242004010020040100415172345211123452505100304601423
     +006002441440142201042024710723044516216201022225204021451117232201
     +022124311724442456100201142124052621251440144201042024710723044516
     +216201022225212310043117244201162125412410044524212464560243046014
     +230460100445061003046014030064130304611403006002420040100200401004
     +150123046040142300611423041210020040100200402224304014230060140320
     +541423046014032012100200401002004020640514230200611403046114405040
     +100200401002010420252101100304601403006402420040100200401004151723
     +452111234525051003046014230460024414402104051621646111234434401402
     +010624447515100411052144752221205061140304611422011121420061140300
     +601402606114430060140050401002004010020104202521011003046014030061
     +130304611403006002420040100200401004450610030460140300601303046214
     +030060024200401002004010042101250404401423006014032054142304601403
     +001210020040100200402224304014230060140300541423106014030412100200
     +401002004021040524202200611403006014226061142300601400504010020040
     +100201112142006114030060140260611443006014205040100200401002010420
     +252101100304601403006413030461140300620242004010020040100445061003
     +046014030060130304621403006202420040100200401004210125040440142300
     +601403045414230460140300121002004010020040222430401423006014030054
     +142310601403101210020040100200402104052420220061140300601502606114
     +230060150050401002004010020111214200611403006014026061144300601460
     +504010020040100201042025210110030460140300611303046114030060024200
     +401002004010044506100304601403006013030462140300630242004010020040
     +100421012504044014230060140320541423046014033012100200401002004022
     +243040142300601403005414231060140320121002004010020040210405242022
     +006114030060142260611423006014205040100200401002011121420061140300
     +601402606114430060150050401002004010020104202521011003046014030064
     +130304611403006002420040100200401004450610030460140300601303046214
     +030065024200401002004010042101250404401423006014030454142304601403
     +041210020040100200402224304014230060140300541423106014032412100200
     +401002004021040524202200611403006015026061142300601440504010020040
     +100201112142006114030060140260611443006015405040100200401002010420
     +252101100304601403006113030461140300610242004010020040100445061003
     +046014030060130304621403006602420040100200401004210125040440142300
     +601403205414230460140320121002004010020040222430401423006014030054
     +142310601403341210020040100200402104052420220061140300601422606114
     +230060142050401002004010020111214200611403006014026061144300601560
     +504010020040100201042025210110030460140300641303046114030066024200
     +401002004010044506100304601403006013030462140300700242004010020040
     +100421012504044014230060140304541423046014031012100200401002004022
     +243040142300601403005414231060140340121002004010020040210405242022
     +006114030060150260611423006014005040100200401002011121420061140300
     +601402606114430060162050401002004010020104202521011003046014030061
     +130304611403006202420040100200401004450610030460140300601303046214
     +030071024200401002004010042101250404401423006014032054142304601403
     +101210020040100200402224304014230060140300541423106014230012100200
     +401002004021040524202200611403006014226061142300601440504010020040
     +100201112142006114030060140260611443006114005040100200401002010420
     +252101100304601403006413030461140300640242004010020040100445061003
     +046014030060130304621403046102420040100200401004210125040440142300
     +601403045414230460140310121002004010020040222430401423006014030054
     +142310601423041210020040100200402104052420220061140300601502606114
     +230060154050401002004010020111214200611403006014026061144300611440
     +504010020040100201042025210110030460140300611303046114030063024200
     +401002004010044506100304601403006013030462140304620242004010020040
     +100421012504044014230060140320541423046014030012100200401002004022
     +243040142300601403005414231060142314121002004010020040210405242022
     +006114030060142260611423006014605040100200401002011121420061140300
     +601402606114430061146050401002004010020104202521011003046014030064
     +130304611403006202420040100200401004450610030460140300601303046214
     +030464024200401002004010042101250404401423006014030454142304601403
     +141210020040100200402224304014230060140300541423106014232012100200
     +401002004021040524202200611403006015026061142300601500504010020040
     +100201112142006114030060140260611443006115205040100200401002010420
     +252101100304601403006113030461140300630242004010020040100445061003
     +046014030060130304621403046502420040100200401004210125040440142300
     +601403205414230460140330121002004010020040206475162504451625242440
     +142300611423041220620104202471072304451621620061100431222364644020
     +442506236511050243046014230462100445061003046014030060130304621403
     +006002420040100200401004210125040440142300601403045414230460140320
     +121002004010020040222430401423006014030054142310601403001210020040
     +100200402104052420220061140300601502606114230060140050401002004010
     +020111214200611403006014026061144300601420504010020040100201042025
     +210110030460140300611303046114030064024200401002004010044506100304
     +601403006013030462140300610242004010020040100421012504044014230060
     +140320541423046014031012100200401002004022243040142300601403005414
     +231060140310121002004010020040210405242022006114030060142260611423
     +006015005040100200401002011121420061140300601402606114430060144050
     +401002004010020104202521011003046014030064130304611403006402420040
     +100200401004450610030460140300601303046214030063024200401002004010
     +042101250404401423006014030454142304601403201210020040100200402224
     +304014230060140300541423106014031412100200401002004021040524202200
     +611403006015026061142300601540504010020040100201112142006114030060
     +140260611443006015005040100200401002010420252101100304601403006113
     +030461140300650242004010020040100445061003046014030060130304621403
     +006402420040100200401004210125040440142300601403205414230460140300
     +121002004010020040222430401423006014030054142310601403241210020040
     +100200402104052420220061140300601422606114230060152050401002004010
     +020111214200611403006014026061144300601520504010020040100201042025
     +210110030460140300641303046114030062024200401002004010044506100304
     +601403006013030462140300660242004010020040100421012504044014230060
     +140304541423046014032412100200401002004022243040142300601403005414
     +231060140330121002004010020040210405242022006114030060150260611423
     +006015005040100200401002011121420061140300601402606114430060156050
     +401002004010020104202521011003046014030061130304611403006502420040
     +100200401004450610030460140300601303046214030067024200401002004010
     +042101250404401423006014032054142304601403301210020040100200402224
     +304014230060140300541423106014034012100200401002004021040524202200
     +611403006014226061142300601540504010020040100201112142006114030060
     +140260611443006016005040100200401002010420252101100304601403006413
     +030461140300600242004010020040100445061003046014030060130304621403
     +007102420040100200401004210125040440142300601403045414230460140330
     +121002004010020040222430401423006014030054142310601403441210020040
     +100200402104052420220061140300601502606114230060144050401002004010
     +020111214200611403006014026061144300611400504010020040100201042025
     +210110030460140300611303046114030066024200401002004010044506100304
     +601403006013030462140304600242004010020040100421012504044014230060
     +140320541423046014032012100200401002004022243040142300601403005414
     +231060142304121002004010020040210405242022006114030060142260611423
     +006015405040100200401002011121420061140300601402606114430061142050
     +401002004010020104202521011003046014030064130304611403006602420040
     +100200401004450610030460140300601303046214030462024200401002004010
     +042101250404401423006014030454142304601403341210020040100200402224
     +304014230060140300541423106014231012100200401002004021040524202200
     +611403006015026061142300601400504010020040100201112142006114030060
     +140260611443006114605040100200401002010420252101100304601403006113
     +030461140300670242004010020040100445061003046014030060130304621403
     +046302420040100200401004210125040440142300601403205414230460140310
     +121002004010020040222430401423006014030054142310601423201210020040
     +100200402104052420220061140300601422606114230060156050401002004010
     +020111214200611403006014026061144300611500504010020040100201042025
     +210110030460140300641303046114030064024200401002004010044506100304
     +601403006013030462140304650242004010020040100421012504044014230060
     +140304541423046014033412100200401002004022243040142300601403005414
     +231060142324121002004010020040210405242022006114030060150260611423
     +006015405040100200401002010323647124222471252122006114030461144051
     +031003104021040516216461112344344020444524246201062444751510041105
     +214475222122704010046105202531052462011623620104202471072304451621
     +620102222521231004311724420116212541241004452421246456024304601423
     +106010044506100304601403006413030461140300600242004010020040100415
     +012304604014230061144304121002004010020040222430401423006014032054
     +142304601403101210020040100200402064051423020061140304621440504010
     +020040100201112142006114030060150260611423006015005040100200401002
     +010320246114100304601423106302420040100200401004450610030460140300
     +641303046114030066024200401002004010041501230460401423006114432012
     +100200401002004021040524202200611403006014626061146300611440504010
     +020040100201042025210110030460140300640242004010020040100445061003
     +046014030060130304621403006002420040100200401004210125040440142300
     +601403045414230460140300121002004010020040222430401423006014030054
     +142310601403041210020040100200402104052420220061140300601422606114
     +230060142050401002004010020111214200611403006014026061144300601440
     +504010020040100201042025210110030460140300611303046114030062024200
     +401002004010044506100304601403006013030462140300630242004010020040
     +100421012504044014230060140304541423046014031412100200401002004022
     +243040142300601403005414231060140320121002004010020040210405242022
     +006114030060142260611423006015005040100200401002011121420061140300
     +601402606114430060152050401002004010020104202521011003046014030061
     +130304611403006502420040100200401004450610030460140300601303046214
     +030066024200401002004010042101250404401423006014030454142304601403
     +301210020040100200402224304014230060140300541423106014033412100200
     +401002004021040524202200611403006014226061142300601560504010020040
     +100201112142006114030060140260611443006016005040100200401002010420
     +252101100304601403006113030461140300600242004010020040100445061003
     +046014030060130304621403007102420040100200401004210125040440142300
     +601403045414230460140304121002004010020040222430401423006014030054
     +142310601423001210020040100200402104052420220061140300601422606114
     +230060144050401002004010020111214200611403006014026061144300611420
     +504010020040100201042025210110030460140300611303046114030063024200
     +401002004010044506100304601403006013030462140304620242004010020040
     +100421012504044014230060140304541423046014032012100200401002004022
     +243040142300601403005414231060142314121002004010020040210405242022
     +006114030060142260611423006015205040100200401002011121420061140300
     +601402606114430061150050401002004010020104202521011003046014030061
     +130304611403006602420040100200401004450610030460140300601303046214
     +030465024200401002004010042101250404401423006014030454142304601403
     +341210020040100200402064751625044516252424401423006114430012206201
     +042024710723044516216200601402010624447515100411052144752221205061
     +140304621422011121420061140300601402606114430060140050401002004010
     +020104202521011003046014030061130304611403006002420040100200401004
     +450610030460140300601303046214030061024200401002004010042101250404
     +401423006014030454142304601403001210020040100200402224304014230060
     +140300541423106014031012100200401002004021040524202200611403006014
     +226061142300601400504010020040100201112142006114030060140260611443
     +006014605040100200401002010420252101100304601403006113030461140300
     +600242004010020040100445061003046014030060130304621403006402420040
     +100200401004210125040440142300601403045414230460140300121002004010
     +020040222430401423006014030054142310601403241210020040100200402104
     +052420220061140300601422606114230060140050401002004010020111214200
     +611403006014026061144300601540504010020040100201042025210110030460
     +140300611303046114030060024200401002004010044506100304601403006013
     +030462140300670242004010020040100421012504044014230060140304541423
     +046014030012100200401002004022243040142300601403005414231060140340
     +121002004010020040210405242022006114030060142260611423006014205040
     +100200401002011121420061140300601402606114430060162050401002004010
     +020104202521011003046014030061130304611403006102420040100200401004
     +450610030460140300601303046214030460024200401002004010042101250404
     +401423006014030454142304601403041210020040100200402224304014230060
     +140300541423106014230412100200401002004021040524202200611403006014
     +226061142300601420504010020040100201112142006114030060140260611443
     +006114405040100200401002010420252101100304601403006113030461140300
     +610242004010020040100445061003046014030060130304621403046302420040
     +100200401004210125040440142300601403045414230460140304121002004010
     +020040222430401423006014030054142310601423201210020040100200402104
     +052420220061140300601422606114230060142050401002004010020111214200
     +611403006014026061144300611520504010020040100201042025210110030460
     +140300611303046114030061024200401002004010041517234521112345250510
     +030460142310610244144021040516216461112344344014030440214511172322
     +010221243117244424121423006114431040222430401423006014030054142310
     +601403001210020040100200402104052420220061140300601422606114230060
     +144050401002004010020111214200611403006014026061144300601420504010
     +020040100201042025210110030460140300611303046114030062024200401002
     +004010044506100304601403006013030462140300620242004010020040100421
     +012504044014230060140304541423046014031012100200401002004022243040
     +142300601403005414231060140314121002004010020040210405242022006114
     +030060142260611423006014405040100200401002011121420061140300601402
     +606114430060150050401002004010020104202521011003046014030061130304
     +611403006202420040100200401004450610030460140300601303046214030065
     +024200401002004010042101250404401423006014030454142304601403101210
     +020040100200402224304014230060140300541423106014033012100200401002
     +004021040524202200611403006014226061142300601440504010020040100201
     +112142006114030060140260611443006015605040100200401002010420252101
     +100304601403006113030461140300620242004010020040100445061003046014
     +030060130304621403007002420040100200401004210125040440142300601403
     +045414230460140314121002004010020040222430401423006014030054142310
     +601403441210020040100200402104052420220061140300601422606114230060
     +146050401002004010020111214200611403006014026061144300611400504010
     +020040100201042025210110030460140300611303046114030063024200401002
     +004010044506100304601403006013030462140304610242004010020040100421
     +012504044014230060140304541423046014031412100200401002004022243040
     +142300601403005414231060142310121002004010020040210405242022006114
     +030060142260611423006014605040100200401002011121420061140300601402
     +606114430061146050401002004010020104202521011003046014030061130304
     +611403006302420040100200401004450610030460140300601303046214030464
     +024200401002004010042101250404401423006014030454142304601403141210
     +020040100200402224304014230060140300541423106014232412100200401002
     +004021040524202200611403006014226061142300601460504010020040100201
     +032364712422247125212200611403046214405103100421012344351422247107
     +100304601004312223646440204425062365110502430460142310631004450610
     +030460140300601303046214030060024200401002004010042101250404401423
     +006014030454142304601403201210020040100200402224304014230060140300
     +541423106014030412100200401002004021040524202200611403006014226061
     +142300601500504010020040100201112142006114030060140260611443006014
     +405040100200401002010420252101100304601403006113030461140300640242
     +004010020040100445061003046014030060130304621403006302420040100200
     +401004210125040440142300601403045414230460140320121002004010020040
     +222430401423006014030054142310601403201210020040100200402104052420
     +220061140300601422606114230060150050401002004010020111214200611403
     +006014026061144300601520504010020040100201042025210110030460140300
     +611303046114030064024200401002004010044506100304601403006013030462
     +140300660242004010020040100421012504044014230060140304541423046014
     +032012100200401002004022243040142300601403005414231060140334121002
     +004010020040210405242022006114030060142260611423006015005040100200
     +401002011121420061140300601402606114430060160050401002004010020104
     +202521011003046014030061130304611403006502420040100200401004450610
     +030460140300601303046214030071024200401002004010042101250404401423
     +006014030454142304601403241210020040100200402224304014230060140300
     +541423106014230012100200401002004021040524202200611403006014226061
     +142300601520504010020040100201112142006114030060140260611443006114
     +205040100200401002010420252101100304601403006113030461140300650242
     +004010020040100445061003046014030060130304621403046202420040100200
     +401004210125040440142300601403045414230460140324121002004010020040
     +222430401423006014030054142310601423141210020040100200402104052420
     +220061140300601422606114230060152050401002004010020111214200611403
     +006014026061144300611500504010020040100201042025210110030460140300
     +611303046114030065024200401002004010044506100304601403006013030462
     +140304650242004010020040100421012504044014230060140304541423046014
     +032412100200401002004020647516250445162524244014230061144314122062
     +010420247107230445162162006114220106244475151004110521447522212050
     +611403046215020111214200611403006014026061144300601400504010020040
     +100201042025210110030460140300611303046114030066024200401002004010
     +044506100304601403006013030462140300610242004010020040100421012504
     +044014230060140304541423046014033012100200401002004022243040142300
     +601403005414231060140310121002004010020040210405242022006114030060
     +142260611423006015405040100200401002011121420061140300601402606114
     +430060146050401002004010020104202521011003046014030061130304611403
     +006602420040100200401004450610030460140300601303046214030064024200
     +401002004010042101250404401423006014030454142304601403301210020040
     +100200402224304014230060140300541423106014032412100200401002004021
     +040524202200611403006014226061142300601540504010020040100201112142
     +006114030060140260611443006015405040100200401002010420252101100304
     +601403006113030461140300660242004010020040100445061003046014030060
     +130304621403006702420040100200401004210125040440142300601403045414
     +230460140330121002004010020040222430401423006014030054142310601403
     +401210020040100200402104052420220061140300601422606114230060156050
     +401002004010020111214200611403006014026061144300601620504010020040
     +100201042025210110030460140300611303046114030067024200401002004010
     +044506100304601403006013030462140304600242004010020040100421012504
     +044014230060140304541423046014033412100200401002004022243040142300
     +601403005414231060142304121002004010020040210405242022006114030060
     +142260611423006015605040100200401002011121420061140300601402606114
     +430061144050401002004010020104202521011003046014030061130304611403
     +006702420040100200401004450610030460140300601303046214030463024200
     +401002004010042101250404401423006014030454142304601403341210020040
     +100200402224304014230060140300541423106014232012100200401002004021
     +040524202200611403006014226061142300601560504010020040100201112142
     +006114030060140260611443006115205040100200401002010420252101100304
     +601403006113030461140300670242004010020040100415172345211123452505
     +100304601423106402441440206475162465210123452123024304611403006010
     +042101250404401422606002430461140300611004210125040440142260610243
     +046114030062100421012504044014226062024304611403006310042101250404
     +401422606302430461140300641004210125040440142260640243046114030065
     +100421012504044014226065024304611403006610042101250404401422606602
     +430461140300671004210125040440142260670243046214030060100421012504
     +044014426060140050611443006014220104202521011003105414030412142310
     +601403104021040524202200621303006202430462140300631004210125040440
     +144260601460506114430060150201042025210110031054140320121423106014
     +032440210405242022006213030065024304621403006610042101250404401442
     +606015405061144300601562010420252101100310541403341214231060140340
     +402104052420220062130300700243046214030071100421012504044014426060
     +162050611443006114020104202521011003105414230012142310601423044021
     +040524202200621303046102430462140304621004210125040440144260611440
     +506114430061146201042025210110031054142314121423106014232040210405
     +242022006213030464024304621403046510042101250404401442606115205061
     +146300611442010420252101100314541403046202434471162344711004210125
     +0404401503006014030054

2010-03-22T00:00:00.000-07:00

Here is 99 bottles of beer in RESOL.


C 99 BOTTLES IN RESOL
001   DATA 000001
      DATA 003,9876543210
      DATA 004,9876543210
      DATA 005,99
      CALL 007,7
      CALL 10002
      CALL 002
      STOP
002   DATA 000001
      DATA 002
      DATA 002,10001
      DATA 001,10001
      DATA 10001
      CONTINUE 002
003   DATA 000001
004   DATA 000001
005   DATA 000002
C DECREMENT COUNTER
006   IF 003,0
      DATA 003,9876543210
      IF 003,0
      DATA 004
      DATA 003
      DATA 005,004
      DATA 005,003
      DATA 005
      CONTINUE 006
007   DATA 000001
      CALL 100,005
      CALL 008
      CALL 10000,0200 0415 0406 0200 0402 0405 0405 0502
     +           0200 0415 0414 0200 0504 0408 0405
     +           0200 0507 0401 0412 0412 0212 0200
      CALL 100,005
      CALL 008
      CALL 10000,0200 0415 0406 0200 0402 0405 0405 0502 0214 0010
      CALL 002
      IF 00,005
      CONTINUE 007,009
      CALL 10000,0504 0401 0411 0405 0200 0415 0414 0405
     +           0200 0404 0415 0507 0414 0200 0401 0414 0404
     +           0200 0500 0401 0503 0503 0200 0409 0504
     +           0200 0401 0502 0415 0505 0414 0404 0212 0200
      CALL 006
      CALL 100,005
      CALL 008
      CALL 10000,0200 0415 0406 0200 0402 0405 0405 0502
     +           0200 0415 0414 0200 0504 0408 0405
     +           0200 0507 0401 0412 0412 0214 0010 0010
      CALL 002
      CONTINUE 007
C BOTTLE(S)
008   CALL 10000,0200 0402 0415 0504 0504 0412 0405
      IF 01,005
      CONTINUE 008
      CALL 10000,0503
      CONTINUE 008
009   CALL 10000,0407 0415 0200 0504 0415 0200 0504 0408 0405
     +           0200 0503 0504 0415 0502 0405 0200 0401 0414 0404
     +           0200 0402 0505 0509 0200 0503 0415 0413 0405
     +           0200 0413 0415 0502 0405 0212 0200 0309 0309
     +           0200 0402 0415 0504 0504 0412 0405 0503
     +           0200 0415 0406 0200 0402 0405 0405 0502
     +           0200 0415 0414 0200 0504 0408 0405
     +           0200 0507 0401 0412 0412 0214 0010
      DATA 007
      CONTINUE 007
C OUTPUT PASSED IN COUNT OR "NO MORE" WHEN COUNT IS 00
100   DATA 000001
      IF 100,0
      CALL 101
      CONTINUE 100,103
101   DATA 100
      IF 100,0
      CALL 10000,0414041502000413041505020405
      IF 100,0
      CONTINUE 100,102
      CALL 104
102   DATA 100
      CONTINUE 101
103   CALL 104
      DATA 100
      CALL 104
      DATA 100
      CONTINUE 100
104   IF 100,0
      CALL 10000,0300
      IF 100,1
      CALL 10000,0301
      IF 100,2
      CALL 10000,0302
      IF 100,3
      CALL 10000,0303
      IF 100,4
      CALL 10000,0304
      IF 100,5
      CALL 10000,0305
      IF 100,6
      CALL 10000,0306
      IF 100,7
      CALL 10000,0307
      IF 100,8
      CALL 10000,0308
      IF 100,9
      CALL 10000,0309
      CONTINUE 104
C THIS IS A LIBRARY THAT CONVERTS 4-BIT ITEMS ENQUEUED INTO 10000 AS 2 DIGITS
C INTO 3-BIT ITEMS IN 1 DIGIT THAT ARE AVAILABLE AT 10001.
C CALL 10000 TO PROCESS ITEMS FROM 10000 INTO 10001.
C CALL 10002 TO FLUSH THE FINAL DANGLING BITS (0-2 BITS).
C
C IF 000002 IS A DATA STATEMENT, CALLING 10000 WILL DEQUEUE FROM IT.  BEST
C NOT TO HAVE 000002 AS A LABEL (WHICH WOULD REQUIRE A CONTINUATION LINE).
C
10000 DATA 000002
      IF 10003,11000
      CALL 10100
      IF 10003,11001
      CALL 10110
      IF 10003,11002
      CALL 10120
      DATA 10003
      DATA 10000
      CONTINUE 10000
10001 DATA 1
C
C FLUSH THE FINAL DANGLING BITS
10002 IF 10003,11000
      CONTINUE 10002
      DATA 10001,10004
      DATA 10004
C REINITIALIZE 10003 TO 012
      IF 10003,11001
      DATA 10003
      DATA 10003
      DATA 10003,012
      CONTINUE 10002
C
C 10003 HOLDS THE NUMBER OF DANGLING BITS
10003 DATA 1,012
C 10004 HOLDS THE VALUE OF THE DANGLING BITS
10004 DATA 1
C
C NO DANGLING BITS FROM BEFORE.  LEAVES 1 DANGLING BIT FOR NEXT ITEM.
10100 IF 10000,12000
      DATA 10001,11000
      IF 10000,12000
      DATA 10004,11000
      IF 10000,12001
      DATA 10001,11000
      IF 10000,12001
      DATA 10004,11004
      IF 10000,12002
      DATA 10001,11001
      IF 10000,12002
      DATA 10004,11000
      IF 10000,12003
      DATA 10001,11001
      IF 10000,12003
      DATA 10004,11004
      IF 10000,12004
      DATA 10001,11002
      IF 10000,12004
      DATA 10004,11000
      IF 10000,12005
      DATA 10001,11002
      IF 10000,12005
      DATA 10004,11004
      IF 10000,12006
      DATA 10001,11003
      IF 10000,12006
      DATA 10004,11000
      IF 10000,12007
      DATA 10001,11003
      IF 10000,12007
      DATA 10004,11004
      IF 10000,12008
      DATA 10001,11004
      IF 10000,12008
      DATA 10004,11000
      IF 10000,12009
      DATA 10001,11004
      IF 10000,12009
      DATA 10004,11004
      IF 10000,12010
      DATA 10001,11005
      IF 10000,12010
      DATA 10004,11000
      IF 10000,12011
      DATA 10001,11005
      IF 10000,12011
      DATA 10004,11004
      IF 10000,12012
      DATA 10001,11006
      IF 10000,12012
      DATA 10004,11000
      IF 10000,12013
      DATA 10001,11006
      IF 10000,12013
      DATA 10004,11004
      IF 10000,12014
      DATA 10001,11007
      IF 10000,12014
      DATA 10004,11000
      IF 10000,12015
      DATA 10001,11007
      IF 10000,12015
      DATA 10004,11004
      CONTINUE 10100
C
C 1 DANGLING BIT FROM BEFORE.  LEAVES 2 DANGLING BITS FOR NEXT ITEM.
10110 IF 10004,11000
      CALL 10111
      IF 10004,11004
      CALL 10112
      DATA 10004
      CONTINUE 10110
C DANGLING 0 FROM BEFORE
10111 IF 10000,12000
      DATA 10001,11000
      IF 10000,12000
      DATA 10004,11000
      IF 10000,12001
      DATA 10001,11000
      IF 10000,12001
      DATA 10004,11002
      IF 10000,12002
      DATA 10001,11000
      IF 10000,12002
      DATA 10004,11004
      IF 10000,12003
      DATA 10001,11000
      IF 10000,12003
      DATA 10004,11006
      IF 10000,12004
      DATA 10001,11001
      IF 10000,12004
      DATA 10004,11000
      IF 10000,12005
      DATA 10001,11001
      IF 10000,12005
      DATA 10004,11002
      IF 10000,12006
      DATA 10001,11001
      IF 10000,12006
      DATA 10004,11004
      IF 10000,12007
      DATA 10001,11001
      IF 10000,12007
      DATA 10004,11006
      IF 10000,12008
      DATA 10001,11002
      IF 10000,12008
      DATA 10004,11000
      IF 10000,12009
      DATA 10001,11002
      IF 10000,12009
      DATA 10004,11002
      IF 10000,12010
      DATA 10001,11002
      IF 10000,12010
      DATA 10004,11004
      IF 10000,12011
      DATA 10001,11002
      IF 10000,12011
      DATA 10004,11006
      IF 10000,12012
      DATA 10001,11003
      IF 10000,12012
      DATA 10004,11000
      IF 10000,12013
      DATA 10001,11003
      IF 10000,12013
      DATA 10004,11002
      IF 10000,12014
      DATA 10001,11003
      IF 10000,12014
      DATA 10004,11004
      IF 10000,12015
      DATA 10001,11003
      IF 10000,12015
      DATA 10004,11006
      CONTINUE 10111
C DANGLING 1 FROM BEFORE
10112 IF 10000,12000
      DATA 10001,11004
      IF 10000,12000
      DATA 10004,11000
      IF 10000,12001
      DATA 10001,11004
      IF 10000,12001
      DATA 10004,11002
      IF 10000,12002
      DATA 10001,11004
      IF 10000,12002
      DATA 10004,11004
      IF 10000,12003
      DATA 10001,11004
      IF 10000,12003
      DATA 10004,11006
      IF 10000,12004
      DATA 10001,11005
      IF 10000,12004
      DATA 10004,11000
      IF 10000,12005
      DATA 10001,11005
      IF 10000,12005
      DATA 10004,11002
      IF 10000,12006
      DATA 10001,11005
      IF 10000,12006
      DATA 10004,11004
      IF 10000,12007
      DATA 10001,11005
      IF 10000,12007
      DATA 10004,11006
      IF 10000,12008
      DATA 10001,11006
      IF 10000,12008
      DATA 10004,11000
      IF 10000,12009
      DATA 10001,11006
      IF 10000,12009
      DATA 10004,11002
      IF 10000,12010
      DATA 10001,11006
      IF 10000,12010
      DATA 10004,11004
      IF 10000,12011
      DATA 10001,11006
      IF 10000,12011
      DATA 10004,11006
      IF 10000,12012
      DATA 10001,11007
      IF 10000,12012
      DATA 10004,11000
      IF 10000,12013
      DATA 10001,11007
      IF 10000,12013
      DATA 10004,11002
      IF 10000,12014
      DATA 10001,11007
      IF 10000,12014
      DATA 10004,11004
      IF 10000,12015
      DATA 10001,11007
      IF 10000,12015
      DATA 10004,11006
      CONTINUE 10112
C
C 2 DANGLING BITS FROM BEFORE.  LEAVES NO DANGLING BITS FOR NEXT ITEM.
10120 IF 10004,11000
      CALL 10121
      IF 10004,11002
      CALL 10122
      IF 10004,11004
      CALL 10123
      IF 10004,11006
      CALL 10124
      DATA 10003,13012
      DATA 10004
      IF 10000,12000
      DATA 10001,11000
      IF 10000,12001
      DATA 10001,11001
      IF 10000,12002
      DATA 10001,11002
      IF 10000,12003
      DATA 10001,11003
      IF 10000,12004
      DATA 10001,11004
      IF 10000,12005
      DATA 10001,11005
      IF 10000,12006
      DATA 10001,11006
      IF 10000,12007
      DATA 10001,11007
      IF 10000,12008
      DATA 10001,11000
      IF 10000,12009
      DATA 10001,11001
      IF 10000,12010
      DATA 10001,11002
      IF 10000,12011
      DATA 10001,11003
      IF 10000,12012
      DATA 10001,11004
      IF 10000,12013
      DATA 10001,11005
      IF 10000,12014
      DATA 10001,11006
      IF 10000,12015
      DATA 10001,11007
      CONTINUE 10120
C DANGLING 00 FROM BEFORE
10121 IF 10000,12000
      DATA 10001,11000
      IF 10000,12001
      DATA 10001,11000
      IF 10000,12002
      DATA 10001,11000
      IF 10000,12003
      DATA 10001,11000
      IF 10000,12004
      DATA 10001,11000
      IF 10000,12005
      DATA 10001,11000
      IF 10000,12006
      DATA 10001,11000
      IF 10000,12007
      DATA 10001,11000
      IF 10000,12008
      DATA 10001,11001
      IF 10000,12009
      DATA 10001,11001
      IF 10000,12010
      DATA 10001,11001
      IF 10000,12011
      DATA 10001,11001
      IF 10000,12012
      DATA 10001,11001
      IF 10000,12013
      DATA 10001,11001
      IF 10000,12014
      DATA 10001,11001
      IF 10000,12015
      DATA 10001,11001
      CONTINUE 10121
C DANGLING 01 FROM BEFORE
10122 IF 10000,12000
      DATA 10001,11002
      IF 10000,12001
      DATA 10001,11002
      IF 10000,12002
      DATA 10001,11002
      IF 10000,12003
      DATA 10001,11002
      IF 10000,12004
      DATA 10001,11002
      IF 10000,12005
      DATA 10001,11002
      IF 10000,12006
      DATA 10001,11002
      IF 10000,12007
      DATA 10001,11002
      IF 10000,12008
      DATA 10001,11003
      IF 10000,12009
      DATA 10001,11003
      IF 10000,12010
      DATA 10001,11003
      IF 10000,12011
      DATA 10001,11003
      IF 10000,12012
      DATA 10001,11003
      IF 10000,12013
      DATA 10001,11003
      IF 10000,12014
      DATA 10001,11003
      IF 10000,12015
      DATA 10001,11003
      CONTINUE 10122
C DANGLING 10 FROM BEFORE
10123 IF 10000,12000
      DATA 10001,11004
      IF 10000,12001
      DATA 10001,11004
      IF 10000,12002
      DATA 10001,11004
      IF 10000,12003
      DATA 10001,11004
      IF 10000,12004
      DATA 10001,11004
      IF 10000,12005
      DATA 10001,11004
      IF 10000,12006
      DATA 10001,11004
      IF 10000,12007
      DATA 10001,11004
      IF 10000,12008
      DATA 10001,11005
      IF 10000,12009
      DATA 10001,11005
      IF 10000,12010
      DATA 10001,11005
      IF 10000,12011
      DATA 10001,11005
      IF 10000,12012
      DATA 10001,11005
      IF 10000,12013
      DATA 10001,11005
      IF 10000,12014
      DATA 10001,11005
      IF 10000,12015
      DATA 10001,11005
      CONTINUE 10123
C DANGLING 11 FROM BEFORE
10124 IF 10000,12000
      DATA 10001,11006
      IF 10000,12001
      DATA 10001,11006
      IF 10000,12002
      DATA 10001,11006
      IF 10000,12003
      DATA 10001,11006
      IF 10000,12004
      DATA 10001,11006
      IF 10000,12005
      DATA 10001,11006
      IF 10000,12006
      DATA 10001,11006
      IF 10000,12007
      DATA 10001,11006
      IF 10000,12008
      DATA 10001,11007
      IF 10000,12009
      DATA 10001,11007
      IF 10000,12010
      DATA 10001,11007
      IF 10000,12011
      DATA 10001,11007
      IF 10000,12012
      DATA 10001,11007
      IF 10000,12013
      DATA 10001,11007
      IF 10000,12014
      DATA 10001,11007
      IF 10000,12015
      DATA 10001,11007
      CONTINUE 10124
C
C CONSTANTS
11000 DATA 1,0
11001 DATA 1,1
11002 DATA 1,2
11003 DATA 1,3
11004 DATA 1,4
11005 DATA 1,5
11006 DATA 1,6
11007 DATA 1,7
12000 DATA 2,00
12001 DATA 2,01
12002 DATA 2,02
12003 DATA 2,03
12004 DATA 2,04
12005 DATA 2,05
12006 DATA 2,06
12007 DATA 2,07
12008 DATA 2,08
12009 DATA 2,09
12010 DATA 2,10
12011 DATA 2,11
12012 DATA 2,12
12013 DATA 2,13
12014 DATA 2,14
12015 DATA 2,15
13012 DATA 3,012

2010-03-15T00:00:00.000-07:00

After getting reacquainted with Haskell, I really like using it. However, using lots of higher-order functions and operators makes for dense APL-like code that is inaccessible to those unfamiliar with those functions and operators. And, parser combinators introduce very expressive and extensible ways to create parsers, but would also look foreign to the uninitiated. But these operators and functions also can be used to make very elegant and maintainable code.

For example, I'm writing code to deal with JVM class files. To write to a class file, I want to convert various things to a list of bytes, so I made a typeclass for that:


class ToBytes a where
    toBytes :: a -> [Word8]

Then, since many objects, when converted to a list of bytes, are just the concatenation of the conversion of component objects, I defined


concatAccessors :: [a -> [b]] -> a -> [b]
concatAccessors = flip (.) (flip ($)) . flip concatMap

which is an example of dense APL-like code, using the (.) and ($) operators and the flip and concatMap higher-order functions. However, it enables this:


instance ToBytes JVMClass where
    toBytes = concatAccessors [
        toBytes . jvmClassMagic,
        toBytes . jvmClassMinorVersion,
        toBytes . jvmClassMajorVersion,
        toBytes . jvmClassConstantPool,
        toBytes . jvmClassAccessFlags,
        toBytes . jvmClassThisClass,
        toBytes . jvmClassSuperClass,
        toBytes . jvmClassInterfaces,
        toBytes . jvmClassFields,
        toBytes . jvmClassMethods,
        toBytes . jvmClassAttributes
        ]

For most of the cases, having the ToBytes type class doesn't buy me that much. It saves having to have separate names for jvmClassToBytes, word16ToBytes, word32ToBytes, etc, but they still have to be defined. However, when there are lists of items in the class file format, it is preceded with a 16 bit count, so I can define


instance ToBytes a => ToBytes [a] where
    toBytes l = toBytes (fromIntegral (length l) :: Word16) ++ concatMap toBytes l

so the constant pool (with a hack for the off by 1 length and the double-sized long and double constants), and the lists of interfaces, fields, methods, and attributes can be taken care of by defining toBytes for single items.

For reading class files, I learned how to make a state-transformer monad, which looks like this


newtype ST st a = ST (st -> (a,st))

instance Monad (ST st) where
    p >>= q = ST (uncurry (s . q) . s p)    where s (ST t) = t
    return = ST . (,)

runST :: ST st a -> st -> a
runST (ST t) = fst . t

There are the uncurry higher-order function and the (.) operator making things hard to understand for those unfamiliar with them, not to mention the odd looking (,) constructor. However, it enables code like this:


readJVMClass :: ST State JVMClass
readJVMClass = do
    magic <- readWord32
    minorVersion <- readWord16
    majorVersion <- readWord16
    constantPool <- readConstantPool
    accessFlags <- readWord16
    thisClass <- readWord16
    superClass <- readWord16
    interfaces <- readList readWord16
    fields <- readList readField
    methods <- readList readMethod
    attributes <- readList readAttribute
    return (JVMClass magic minorVersion majorVersion constantPool accessFlags
                     thisClass superClass interfaces fields methods attributes)

which is very maintainable.

Using Functor and Applicative


instance Functor (ST st) where
    fmap f p = do { a <- p; return (f a) }

instance Applicative (ST st) where
    pure = return
    p <*> q = do { f <- p; a <- q; return (f a) }

it could be written more concisely, but with more weird operators:


readJVMClass = JVMClass <$> readWord32
                        <*> readWord16
                        <*> readWord16
                        <*> readConstantPool
                        <*> readWord16
                        <*> readWord16
                        <*> readWord16
                        <*> readList readWord16
                        <*> readList readField
                        <*> readList readMethod
                        <*> readList readAttribute

readJVMClass (readWord32, readWord16, ...) doesn't return a JVMClass (Word32, Word16, ...), it returns a state transformer, which is a function that takes a state, and returns an updated state and a JVMClass (Word32, Word16, ...). readJVMClass just builds a state transformer that chains other state transformers and extracts the values that they return. To actually do the reading and building, one must use runST.

2010-03-08T00:00:00.000-08:00

There was some feature that, due to changes in an external service, stopped working. The trunk was fixed to work with the new version of the external service, but the release branch was not. The bug report classified it as a regression, but it wasn't a regression, as the feature had stopped working in the same manner in production. It was decided that it was too risky to copy the fix from the trunk to the release branch.

Now, this new release also included the launch of a new virtual host, where having the non-working feature was not an option, so it was decided that the feature had to be disabled for that virtual host, so an ugly hack got put in to disable that feature for one set of use cases. Then, I got called in to review the hack and was told that it needed to be extended to some other use cases. It turned out that I had added a general mechanism to do per-virtual host configuration 8 or 9 months earlier for another feature, so the ugly hack was reverted, and per-virtual host configuration was changed to disable that feature for all the use cases on that virtual host.

2010-03-01T00:00:00.000-08:00

I got a 3am call because of some problem when a new version went out to production. It turned out to be some code using an external hostname that was invisible to the internal host. I wasn't involved in figuring out the problem, because I was looking at the pieces that I had worked on. When it was figured out, I went back to sleep. These problems keep turning up because there are no distinct internal and external hostnames in the testing and development environments, and anyone new to the project hasn't gotten lots of these late-night calls.

2010-02-22T00:00:00.001-08:00

Here is an interpreter for 01_ that I wrote in 01_. It compiles the 01_ source code into a bit code, and then interprets that bit code.

One limitation is that the top-level function evaluated is the first function defined in the source, instead of the function specified on the command line or inferred from the filename. This could easily be coded to be, in a fashion, specified from the command line. This would be somewhat awkward, since the 01_ code does not get the actual command line data, but rather, the contents of the file named in the command line, so the name of the function to be evaluated would have to be put into a file or piped into stdin to be received by the interpreter.

Another limitation is that it can only pass in a maximum of 9 arguments to the top level function. (Any additional arguments will be given nil.) This limit can be easily changed by changing the arglist function (and the interp and bitcode functions) to take a different number of arguments.

Bit code format

Here is the bit code format used by my 01_ interpreter.

Parenthesis indicates a list. Ellipses indicates zero or more of the
preceding item. A vertical bar indicates alternatives.


program = (name ones names functions)
names = (name name ...)
functions = (definitions definitions ...)
definitions = (definition definition ...)
definition = (patterns body)
patterns = (pattern ...)
pattern = bound-pattern | literal-pattern | wild-pattern
bound-pattern = 0 bits
literal-pattern = 1 0 bits
wild-pattern = 1 1 bits
bits = bit ...
bit = 0 | 1
ones = 1 ...
body = op op ...
op = push | concat
push = 0 value
concat = 1 value
value = literal | binding | funcall
binding = 0 ones
literal = 1 0 bits
funcall = 1 1 (bits ones)

The program has the name of the function to apply, the number of arguments that function takes, a pair of lists forming an association list of names to functions.

A push op pushes its value onto the local stack to be used as an argument to a function call. A concat op concatenates its result to the value that is returned by the current function.

A binding value has an index to the bound parameters of the function. Let n = the number of bound parameters, then 0 is the last parameter, and n - 1 is the first parameter.

A funcall value has the name of the function and the number of arguments that function takes.

All the counts, the binding index and the number of arguments taken by a function, are in base 1.

Library functions


== library

== force a pattern match failure
error 0 = error _.

concat a b = a b.

== lists

== first item in the list
head 0. = _.
head 11rest = 1 head rest.
head 10rest = 0 head rest.
head _ = _.

== the list with the first item removed
tail 0rest = rest.
tail 11rest = tail rest.
tail 10rest = tail rest.
tail _ = _.

list-encode _ = 0.
list-encode 1x = 11 list-encode x.
list-encode 0x = 10 list-encode x.

== association lists

== association list lookup
alist-lookup key klist dlist =
    if-equal key head klist
             head dlist
             alist-lookup key tail klist tail dlist.
alist-lookup . _ . = _.

== association list update
alist-update key data klist dlist =
    if-equal key head klist
             concat list-encode data
                    tail dlist
             concat list-encode head dlist
                    alist-update key data
                                 tail klist
                                 tail dlist.

alist-append key data klist dlist =
    if-equal key head klist
             concat list-encode concat head dlist
                                       list-encode data
                    tail dlist
             concat list-encode head dlist
                    alist-append key data
                                 tail klist
                                 tail dlist.

== stacks

== new empty stack
empty-stack = 0_.

== number of items in the stack (in base 1)
stack-count 0stack = _.
stack-count 1stack = 1 stack-count stack.

drop-stack-count 0stack = stack.
drop-stack-count 1stack = drop-stack-count stack.

== top of the stack
top 0. = _. == stack underflow
top stack = top' decrement-count stack-count stack drop-stack-count stack.

top' count 0stack-data = _.
top' count 10stack-data = 0 top' count drop-stack-bit count stack-data.
top' count 11stack-data = 1 top' count drop-stack-bit count stack-data.

decrement-count 1count = count.

drop-stack-bit _ stack-data = stack-data.
drop-stack-bit 1count  0stack-data = drop-stack-bit count stack-data.
drop-stack-bit 1count 10stack-data = drop-stack-bit count stack-data.
drop-stack-bit 1count 11stack-data = drop-stack-bit count stack-data.

== returns stack with data pushed on top
push data stack =
    1 stack-count stack 0 push' data stack-count stack drop-stack-count stack.

push' _ count stack-data =
    0 take-stack-bit count stack-data
    push' _ count drop-stack-bit count stack-data.
push' 0data count stack-data =
    10 take-stack-bit count stack-data
    push' data count drop-stack-bit count stack-data.
push' 1data count stack-data =
    11 take-stack-bit count stack-data
    push' data count drop-stack-bit count stack-data.

take-stack-bit _ . = _.
take-stack-bit 1count  0stack-data =  0 take-stack-bit count stack-data.
take-stack-bit 1count 10stack-data = 10 take-stack-bit count stack-data.
take-stack-bit 1count 11stack-data = 11 take-stack-bit count stack-data.

== returns stack with the top item popped
pop 0. = 0_. == stack underflow
pop 10. = 0_. == 1 item optimization
pop 1stack = stack-count stack 0 pop' stack-count stack drop-stack-count stack.

pop' count 0stack-data =
    take-stack-bit count stack-data
    pop' count drop-stack-bit count stack-data.
pop' count 10stack-data =
    take-stack-bit count stack-data
    pop' count drop-stack-bit count stack-data.
pop' count 11stack-data =
    take-stack-bit count stack-data
    pop' count drop-stack-bit count stack-data.

== conditional
if-equal 0x 0y true false = if-equal x y true false.
if-equal 1x 1y true false = if-equal x y true false.
if-equal _ _ true . = true.
if-equal . . . false = false.

==
take-bits _ . = _.
take-bits . _ = _.
take-bits 0bits 0data = 0 take-bits bits data.
take-bits 1bits 0data = 0 take-bits bits data.
take-bits 0bits 1data = 1 take-bits bits data.
take-bits 1bits 1data = 1 take-bits bits data.

drop-bits _ data = data.
drop-bits . _ = _.
drop-bits 0bits 0data = drop-bits bits data.
drop-bits 1bits 0data = drop-bits bits data.
drop-bits 0bits 1data = drop-bits bits data.
drop-bits 1bits 1data = drop-bits bits data.

Tokenizer


== 01_ tokenizer
== token tokenized
== 0     0
== 1     1
== _     00
== .     01
== =     10

== input stream to list of tokens
tokenize in = tokenize' in _.

tokenize' _ . = _.

== comment
tokenize' 00111101 00111101in flag = end-symbol flag
                                    drop-comment in.

== 0
tokenize' 00110000in flag = end-symbol flag
                            100 tokenize' in _.

== 1
tokenize' 00110001in flag = end-symbol flag
                            110 tokenize' in _.

== _
tokenize' 01011111in flag = end-symbol flag
                            10100 tokenize' in _.

== .
tokenize' 00101110in flag = end-symbol flag
                            10110 tokenize' in _.

== =
tokenize' 00111101in flag = end-symbol flag
                            11100 tokenize' in _.

== whitespace
tokenize' 00100000in flag = end-symbol flag tokenize' in _. == SPC
tokenize' 00001001in flag = end-symbol flag tokenize' in _. == TAB
tokenize' 00001010in flag = end-symbol flag tokenize' in _. == LF
tokenize' 00001101in flag = end-symbol flag tokenize' in _. == CR

== symbol
tokenize' in . = take-symbol 00000000 in.

end-symbol _ = _.
end-symbol . = 0.

take-symbol _ in = tokenize' in 0.
take-symbol 0bits 0in = 10 take-symbol bits in.
take-symbol 0bits 1in = 11 take-symbol bits in.

== comment
drop-comment _ = _.
drop-comment 00001010in = tokenize' in _.
drop-comment in = drop-comment drop-bits 00000000 in.


==
test-tokenize in = test-tokenize-out tokenize in _.

test-tokenize-out _ . = _.
test-tokenize-out list flag = test-tokenize-out-one head list tail list flag.

test-tokenize-out-one 0_  list . = 00110000 test-tokenize-out list _.
test-tokenize-out-one 1_  list . = 00110001 test-tokenize-out list _.
test-tokenize-out-one 00_ list . = 01011111 test-tokenize-out list _.
test-tokenize-out-one 01_ list . = 00101110 test-tokenize-out list _.
test-tokenize-out-one 10_ list . = 00111101 test-tokenize-out list _.

test-tokenize-out-one one list flag = test-tokenize-out-sep flag one test-tokenize-out list 0.

test-tokenize-out-sep _ = _.
test-tokenize-out-sep . = 00100000.

Parser


== parse a list of 01_ tokens into a list of function names

parse-names tokens = parse-names' head tokens tail tokens _.

parse-names' _ . list = list.
parse-names' 0_  . . = error _. == expecting symbol
parse-names' 1_  . . = error _. == expecting symbol
parse-names' 00_ . . = error _. == expecting symbol
parse-names' 01_ . . = error _. == expecting symbol
parse-names' 10_ . . = error _. == expecting symbol
parse-names' name tokens list =
    parse-names' head parse-drop-def head tokens tail tokens
                 tail parse-drop-def head tokens tail tokens
                 add-unique name list.

add-unique item _ = list-encode item.
add-unique item list = list-encode head list
                       if-equal item head list
                                tail list
                                add-unique item
                                           tail list.

parse-drop-def 10_ tokens = parse-drop-def-body head tokens tail tokens.
parse-drop-def . tokens = parse-drop-def head tokens tail tokens.

parse-drop-def-body 01_ tokens = tokens.
parse-drop-def-body . tokens = parse-drop-def-body head tokens tail tokens.

test-parse-names in = test-tokenize-out parse-names tokenize in _.

== given a list of items, return a list of empty lists of equal length
== this can be used to initialize association lists
== keys cannot be nil
alist-empty-values keys = alist-empty-values' head keys tail keys.

alist-empty-values' _ . = _.
alist-empty-values' . keys = 0 alist-empty-values' head keys tail keys.

== collect arities from list of 01_ tokens
parse-arities names tokens = parse-arities' names
                                            alist-empty-values names
                                            head tokens
                                            tail tokens.

parse-arities' names arities _ . = arities.
parse-arities' names arities name tokens =
    parse-arities-count-args names arities name _
                             head tokens
                             tail tokens
                             _.

parse-arities-count-args names arities name count _ tokens flag = error _.
                == unexpected EOF

parse-arities-count-args names arities name count 10_ tokens _ =
    == got = without any bits
    parse-arities' names
                   alist-update name count names arities
                   head parse-drop-def-body head tokens tail tokens
                   tail parse-drop-def-body head tokens tail tokens.

parse-arities-count-args names arities name count 10_ tokens . =
    == got = with leading bits
    parse-arities' names
                   alist-update name
                                concat 1 count
                                names arities
                   head parse-drop-def-body head tokens tail tokens
                   tail parse-drop-def-body head tokens tail tokens.

parse-arities-count-args names arities name count 0_ tokens . =
    parse-arities-count-args names arities name count
                             head tokens
                             tail tokens
                             0.

parse-arities-count-args names arities name count 1_ tokens . =
    parse-arities-count-args names arities name count
                             head tokens
                             tail tokens
                             0.

parse-arities-count-args names arities name count . tokens . =
    parse-arities-count-args names arities name
                             concat 1 count
                             head tokens
                             tail tokens
                             _.

test-parse-arities in = test-parse-arities' parse-names tokenize in
                                            tokenize in.
test-parse-arities' names tokens =
    test-alist-out names parse-arities names tokens.

test-alist-out _ . = _.
test-alist-out klist dlist =
    head klist
    00111101
    test-bits-out head dlist
    00001010
    test-alist-out tail klist tail dlist.

test-bits-out _ = _.
test-bits-out 0b = 00110000 test-bits-out b.
test-bits-out 1b = 00110001 test-bits-out b.

== parse
parse tokens = parse' parse-names tokens tokens.
parse' names tokens = parse'' names parse-arities names tokens tokens.
parse'' names arities tokens =
    list-encode head names
    list-encode head arities
    list-encode names
    list-encode parse-functions names arities
                                alist-empty-values names
                                tokens.

parse-functions names arities functions _ = functions.

parse-functions names arities functions tokens =
    parse-functions names arities
                    alist-append head tokens
                                 parse-def-args names arities _ _ _
                                                head tail tokens
                                                tail tail tokens
                                 names
                                 functions
                    parse-drop-def head tokens tail tokens.

parse-def-args names arities bindings bits patterns 10_ tokens = == =
    if-equal bits _
             list-encode patterns
             list-encode concat patterns
                                list-encode concat 10 bits == literal pattern
    parse-def-body names arities bindings _ _ _ head tokens tail tokens.

parse-def-args names arities bindings bits patterns 0_ tokens = == 0
    parse-def-args names arities bindings
                   concat bits 0
                   patterns
                   head tokens
                   tail tokens.

parse-def-args names arities bindings bits patterns 1_ tokens = == 1
    parse-def-args names arities bindings
                   concat bits 1
                   patterns
                   head tokens
                   tail tokens.

parse-def-args names arities bindings bits patterns 00_ tokens = == _
    == literal pattern
    parse-def-args names arities bindings
                   _
                   concat patterns
                          list-encode concat 10 bits
                   head tokens
                   tail tokens.

parse-def-args names arities bindings bits patterns 01_ tokens = == .
    == wild pattern
    parse-def-args names arities bindings
                   _
                   concat patterns
                          list-encode concat 11 bits
                   head tokens
                   tail tokens.

parse-def-args names arities bindings bits patterns arg tokens =
    == bound pattern
    parse-def-args names arities
                   concat list-encode arg
                          bindings
                   _
                   concat patterns
                          list-encode concat 0 bits
                   head tokens
                   tail tokens.

parse-def-body names arities bindings argcounts funcalls bits _ . = error _.

parse-def-body names arities bindings argcounts funcalls bits 0_ tokens =
        parse-def-body names arities bindings
                       argcounts funcalls
                       concat bits 0
                       head tokens
                       tail tokens.

parse-def-body names arities bindings argcounts funcalls bits 1_ tokens =
        parse-def-body names arities bindings
                       argcounts funcalls
                       concat bits 1
                       head tokens
                       tail tokens.

parse-def-body names arities bindings argcounts funcalls _ 01_ . = _.
    == . end of definition

parse-def-body names arities bindings argcounts funcalls _ 00_ tokens =
    == _ nil constant
    list-encode if-equal argcounts _
                         110_ == concat nil
                         010  == push nil
    check-argcounts argcounts funcalls
                    head argcounts
    parse-def-body names arities bindings
                   decrement-argcounts argcounts head argcounts
                   decrement-funcalls argcounts funcalls head argcounts
                   _
                   head tokens
                   tail tokens.

parse-def-body names arities bindings argcounts funcalls _ token tokens =
    == symbol: either binding or funcall
    parse-def-try-binding names arities bindings argcounts funcalls tokens
                          token bindings _
                          alist-lookup token names arities.

parse-def-body names arities bindings argcounts funcalls _ token tokens =
    == symbol: either binding or funcall
    parse-def-try-binding names arities bindings argcounts funcalls
                          tokens
                          token bindings _
                          alist-lookup token names arities.

parse-def-body names arities bindings argcounts funcalls bits 00_ tokens =
    == _ terminated constant
    list-encode if-equal argcounts _
                         concat 110 bits == concat nil
                         concat 010 bits == push nil
    check-argcounts argcounts funcalls
                    head argcounts
    parse-def-body names arities bindings
                   decrement-argcounts argcounts head argcounts
                   decrement-funcalls argcounts funcalls head argcounts
                   _
                   head tokens
                   tail tokens.

parse-def-body names arities bindings argcounts funcalls bits token tokens =
    == end of constant
    list-encode if-equal argcounts _
                         concat 110 bits == concat nil
                         concat 010 bits == push nil
    check-argcounts argcounts funcalls
                    head argcounts
    parse-def-body names arities bindings
                   decrement-argcounts argcounts head argcounts
                   decrement-funcalls argcounts funcalls head argcounts
                   _
                   token
                   tokens.

parse-def-try-binding names arities bindings argcounts funcalls tokens
                      name _ . _ =
    == not in bindings, nullary funcall
    list-encode if-equal _ argcounts
                         concat 111 concat list-encode name 0
                         concat 011 concat list-encode name 0
    check-argcounts argcounts funcalls
                    head argcounts
    parse-def-body names arities bindings    
                   decrement-argcounts argcounts head argcounts
                   decrement-funcalls argcounts funcalls head argcounts
                   _
                   head tokens
                   tail tokens.

parse-def-try-binding names arities bindings argcounts funcalls tokens
                      name _ . arity =
    == not in bindings, push funcall
    parse-def-body names arities bindings    
                   concat list-encode arity
                          argcounts
                   concat list-encode concat list-encode name
                                             list-encode arity
                          funcalls
                   _
                   head tokens
                   tail tokens.

parse-def-try-binding names arities bindings argcounts funcalls tokens
                      name bind-list bind-index arity =
    if-equal name head bind-list
             parse-def-emit-bound names arities bindings
                                  argcounts funcalls tokens
                                  bind-index
             parse-def-try-binding names arities bindings
                                   argcounts funcalls tokens
                                   name
                                   tail bind-list
                                   concat 1 bind-index
                                   arity.

parse-def-emit-bound names arities bindings argcounts funcalls tokens
                     bind-index =
    list-encode if-equal _ argcounts
                         concat 10 bind-index == concat
                         concat 00 bind-index == push
    check-argcounts argcounts funcalls
                    head argcounts
    parse-def-body names arities bindings    
                   decrement-argcounts argcounts head argcounts
                   decrement-funcalls argcounts funcalls head argcounts
                   _
                   head tokens
                   tail tokens.

end-constant argcounts _ = _.
end-constant argcounts bits =
    list-encode if-equal argcounts _
                         concat 110 bits  == concat constant
                         concat 010 bits. == push constant

check-argcounts _ . . = _.
check-argcounts argcounts funcalls _ =
    list-encode concat if-equal _ tail argcounts
                                111_ == concat funcall
                                011  == push funcall
                       head funcalls
    check-argcounts tail argcounts tail funcalls
                    head tail argcounts.
check-argcounts argcounts funcalls 1_ =
    list-encode concat if-equal _ tail argcounts
                                111_ == concat funcall
                                011  == push funcall
                       head funcalls
    check-argcounts tail argcounts tail funcalls
                    head tail argcounts.
check-argcounts . . . = _.

decrement-argcounts _ . = _.
decrement-argcounts argcounts _ =
    decrement-argcounts tail argcounts head tail argcounts.
decrement-argcounts argcounts 1_ =
    decrement-argcounts tail argcounts head tail argcounts.
decrement-argcounts argcounts 1argcount =
    list-encode argcount
    tail argcounts.

decrement-funcalls _ . . = _.
decrement-funcalls argcounts funcalls _ =
    decrement-funcalls tail argcounts tail funcalls head tail argcounts.
decrement-funcalls argcounts funcalls 1_ =
    decrement-funcalls tail argcounts tail funcalls head tail argcounts.
decrement-funcalls . funcalls . = funcalls.

Bit code interpreter


== 01_ bitcode interpreter

bitcode bitcode arg arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 =
    interpret-bitcode bitcode
                      arglist arg arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9.

interpret-bitcode bitcode args =
    apply head tail tail bitcode == list of function names
          head tail tail tail bitcode == list of functions
          alist-lookup head bitcode == main function name
                       head tail tail bitcode == list of function names
                       head tail tail tail bitcode == list of functions
          push-arguments head tail bitcode == main function arity
                         args
                         empty-stack.

arglist arg arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 =
    list-encode arg  list-encode arg2 list-encode arg3
    list-encode arg4 list-encode arg5 list-encode arg6
    list-encode arg7 list-encode arg8 list-encode arg9.

push-arguments _ . stack = stack.
push-arguments 1count args stack =
    push-arguments count
                   tail args
                   push head args
                        stack.

apply fnames functions function args =
    match fnames functions args
          head function
          tail function.

match fnames functions args _ defs = error _. == pattern match failed

match fnames functions args def defs =
    match2 fnames functions args defs
           head head def == first pattern
           tail head def == remaining patterns
           tail def == body
           empty-stack == bindings
           args.

match2 fnames functions saved-args defs
       _ patterns body bindings args
    = eval fnames functions bindings
           head body
           tail body
           empty-stack.

== binding
match2 fnames functions saved-args defs
       0pattern-bits patterns body bindings args =
    if-match pattern-bits
             top args
             match2 fnames functions saved-args defs
                    head patterns
                    tail patterns
                    body
                    push drop-head pattern-bits
                                   top args
                         bindings
                    pop args
             match fnames functions saved-args
                   head defs
                   tail defs.

== literal
match2 fnames functions saved-args defs
       10pattern-bits patterns body bindings args =
    if-equal pattern-bits
             top args
             match2 fnames functions saved-args defs
                    head patterns
                    tail patterns
                    body
                    bindings
                    pop args
             match fnames functions saved-args
                    head defs
                    tail defs.

== wild
match2 fnames functions saved-args defs
       11pattern-bits patterns body bindings args =
    if-match pattern-bits
             top args
             match2 fnames functions saved-args defs
                    head patterns
                    tail patterns
                    body
                    bindings
                    pop args
             match fnames functions saved-args
                    head defs
                    tail defs.

eval fnames functions bindings _ ops stack = _.

== push bound expr
eval fnames functions bindings
     00index ops stack =
    eval fnames functions bindings
         head ops
         tail ops
         push get-binding index bindings
              stack.

== concat bound expr
eval fnames functions bindings
     10index ops 0. =
    get-binding index bindings
    eval fnames functions bindings
         head ops
         tail ops
         empty-stack.

get-binding _ bindings = top bindings.
get-binding 1index bindings = get-binding index pop bindings.

== push literal expr
eval fnames functions bindings
     010bits ops stack =
    eval fnames functions bindings
         head ops
         tail ops
         push bits stack.

== concat literal expr
eval fnames functions bindings
     110bits ops 0. =
    bits
    eval fnames functions bindings
         head ops
         tail ops
         empty-stack.

== push funcall expr
eval fnames functions bindings
     011funcall ops stack =
    eval fnames functions bindings
         head ops
         tail ops
         push apply fnames functions
                    alist-lookup head funcall
                                 fnames functions
                    pull-args head tail funcall
                              stack empty-stack
              pop-args head tail funcall
                       stack.

== concat funcall expr
eval fnames functions bindings
     111funcall ops stack =
    apply fnames functions
          alist-lookup head funcall
                       fnames functions
          pull-args head tail funcall
                    stack empty-stack
    eval fnames functions bindings
         head ops
         tail ops
         pop-args head tail funcall
                  stack.

pull-args _ . args = args.
pull-args 1count stack args =
    pull-args count
              pop stack
              push top stack
                   args.

pop-args _ stack = stack.
pop-args 1count stack =
    pop-args count
             pop stack.

if-match 0x 0y true false = if-match x y true false.
if-match 1x 1y true false = if-match x y true false.
if-match _ . true . = true.
if-match . . . false = false.

drop-head 0x 0y = drop-head x y.
drop-head 1x 1y = drop-head x y.
drop-head _ y = y.

Top-level


interp in arg arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 =
    interpret-bitcode parse tokenize in
                      arglist arg arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9.

compile in = parse tokenize in 0000000. == pad to at least an even byte

Code size comparisons

Since I've implemented multiple 01_ interpreters, here's a comparison of the source code sizes:

Haskell - 216 lines, 9k
Python - 424 lines, 12k
01_ - 746 lines, 25k
Java (slow original version) - 782 lines, 25k
Java (fast new version including compiler to Java) - 1188 lines, 34k
C - 1527 lines, 37k

2010-02-15T00:00:00.001-08:00

I had the crazy notion of implementing an 01_ interpreter in 01_. One first step would be to come up with some bit-code data structure and write an interpreter for that in 01_, and, to start with, write a compiler from 01_ source code to the bit-code in a sane language like Haskell or Java for testing. Then, the final step would be to write an 01_ source to the bit code compiler in 01_.

Which leads to data structures in 01_. The only data type in 01_ is the list of bits, and only pattern matching and list concatenation are the available operations. Higher-level data structures can be built on that, and that's what I'm writing about.

I had an idea on how to make lists of arbitrary (finite) data. However, 01_ programs can deal with infinite bit lists, so I came up with an idea on how to make a stack of potentially infinite bit lists as well.

An 01_ interpreter would need some dictionary datatype, so association lists can be built on top of the lists. One way would be to use nested lists. Another would be to use a pair of lists.

List of arbitrary finite data

The scheme uses a control bit, where 1 means a data bit follows, and there are more bits, and 0 means the end of the list.


== first item in the list
head 0. = _.
head 11rest = 1 head rest.
head 10rest = 0 head rest.
head _ = _.

== the list with the first item removed
tail 0rest = rest.
tail 11rest = tail rest.
tail 10rest = tail rest.
tail _ = _.

== the list with a new item added to the front (or end)
add data list = list-encode data list.
add-to-end data list = list list-encode data.

list-encode _ = 0.
list-encode 1x = 11 encode x.
list-encode 0x = 10 encode x.

Stack of potentially infinite lists

Let n = the number of items in the stack. The stack data structure starts with n 1s, followed by a 0, followed the stack data.

The stack data starts with the first bit of every item in the stack, followed by the second bit of every item in the stack, followed by the third bit, etc.

Each stack bit starts with the control bit for the top bit in the top item in the stack, where a 1 is followed by the data bit of the item, and a 0 means the item has no more bits, which is followed by next item in the stack, etc all the way to the bottom of the stack.

This implementation would undoubtedly be hugely inefficient. When dealing with the largest item yet to be in the stack, the entire history of operations on the stack will have to be unwound for the rightmost bits. The 1 item optimization in pop helps a little by limiting the history that has to be unwound to the last time the stack was empty.


== new empty stack
empty = 0_.

== number of items in the stack (in base 1)
stack-count 0stack = _.
stack-count 1stack = 1 stack-count stack.

drop-stack-count 0stack = stack.
drop-stack-count 1stack = drop-stack-count stack.

== top of the stack
top 0. = _. == stack underflow
top stack =
    top' decrement-count stack-count stack
         drop-stack-count stack.

top' count 0stack-data = _.
top' count 10stack-data =
    0 top' count
           drop-stack-bit count stack-data.
top' count 11stack-data =
    1 top' count
           drop-stack-bit count stack-data.

decrement-count 1count = count.

drop-stack-bit _ stack-data = stack-data.
drop-stack-bit 1count  0stack-data = drop-stack-bit count stack-data.
drop-stack-bit 1count 10stack-data = drop-stack-bit count stack-data.
drop-stack-bit 1count 11stack-data = drop-stack-bit count stack-data.

== returns stack with data pushed on top
push data stack =
    1 stack-count stack 0
    push' data count drop-stack-count stack.

push' _ count stack-data =
    0 take-stack-bit count stack-data
      push' _ count drop-stack-bit count stack-data.
push' 0data count stack-data =
    10 take-stack-bit count stack-data
       push' data count drop-stack-bit count stack-data.
push' 1data count stack-data =
    11 take-stack-bit count stack-data
       push' data count drop-stack-bit count stack-data.

take-stack-bit _ . = _.
take-stack-bit 1count  0stack-data =  0 take-stack-bit count stack-data.
take-stack-bit 1count 10stack-data = 10 take-stack-bit count stack-data.
take-stack-bit 1count 11stack-data = 11 take-stack-bit count stack-data.

== returns stack with the top item popped
pop 0. = 0_. == stack underflow
pop 10. = 0_. == 1 item optimization
pop 1stack =
    stack-count stack 0
    pop' stack-count stack
         drop-stack-count stack.

pop' count 0stack-data =
    take-stack-bit count stack-data
    pop' count
         drop-stack-bit count stack-data.
pop' count 10stack-data =
    take-stack-bit count stack-data
    pop' count
         drop-stack-bit count stack-data.
pop' count 11stack-data =
    take-stack-bit count stack-data
    pop' count
         drop-stack-bit count stack-data.

Association lists

For implementing association lists, a pair of lists would be more efficient, but more complicated and error-prone to use than nested lists. I'll include implementations of both, but I'd probably use a pair of lists.

Association list using nested lists.


lookup key alist = try-lookup key head alist lookup key tail alist.
lookup . _ = _.

try-lookup key pair fail = if-equal key head pair head tail pair fail.

add-alist key data alist = add add key add data _ alist.

Association list using a pair of lists.


lookup key klist dlist =
    if-equal key head klist head dlist lookup key tail klist tail dlist.
lookup . _ . = _.

They both use if-equal, defined here.


if-equal 0x 0y true false = if-equal x y true false.
if-equal 1x 1y true false = if-equal x y true false.
if-equal _ _ true . = true.
if-equal . . . false = false.

More association lists

These will use a pair of lists, one for the keys, and one for the data.


== test if key is present
if-has-key key _ true false = false.
if-has-key key klist true false =
    if-equal key head klist true if-has-key key tail klist true false.

== append to data associated with key
append-alist key data klist dlist =
    if-has-key key klist
               append-alist' key data klist dlist
               add data dlist.

append-alist' key data klist dlist =
    if-equal key head klist
             append-alist-matching data dlist
             append-alist-nonmatching key data klist dlist.

append-alist-matching data dlist =
    add add-to-end data head dlist
        tail dlist.

append-alist-nonmatching key data klist dlist =
    head dlist
    append-alist' key data tail klist tail dlist.

append-alist-key key klist =
    if-has-key key klist
               klist
               add key klist.

2010-02-08T00:00:00.001-08:00

I had the idea of making a compiler for the 01_ programming language that compiled to the Java Virtual Machine (JVM). For starters, I wrote a few classes for the runtime library.

rt01_.val: For values in the only datatype in 01_, a list of bits. I included the trampoline() method, which must be called before evaluation, to avoid stack overflows, and to allow discarded values to be garbage collected.
rt01_.constant: For literal constants. I decided on representing the constant as a string of 0 and 1, since strings are the only way to represent arbitrary length constants in the Java class file format without needing initialization code to construct it. Additionally, the same string in the constant pool could be reused as the name of the field holding that constant. Compiling to Java means the field names have to be valid Java identifiers, but they don't have to be when compiling directly to Java class files.
rt01_.concat: For the only operation in 01_, list concatenation.
rt01_.input: For reading input as a list of bits.
rt01_.function: To be extended by classes representing 01_ functions. They should receive their arguments in the constructor, and build their results in eval(), and have a main() for being invoked from the command line.

Then, to test it out, I started with using it to write an interpreter. At first, it was getting OutOfMemoryErrors. I had written Function.eval() as


    public rt01_.function eval(final rt01_.val[] args) {
        return new rt01_.function() {
            protected rt01_.val eval() {
                for (Def def : defs) {
                    rt01_.val val = def.eval(args);
                    if (val != null)
                        return val;
                }
                throw new RuntimeException(...);
            }
        };
    }

The capture of args in the anonymous class prevented the arguments from being garbage collected. Once I fixed that, the interpreter ran much faster than my previous interpreter in Java, faster than my interpreter in C, and even slightly faster than my interpreter in Haskell. Once I implemented the interpreter, it was a simple matter to extend it to compile to Java. The compiled code was maybe 5-10% faster than the interpreter.

I want to compile directly to class files rather than to Java, which will take a lot more work. This interpreter and compiler to Java was pretty much a weekend hack. I imagine the generated code would be pretty much the same as compiling to Java. The main difference is that the function names wouldn't have to be as heavily mangled, since they would no longer have to be valid Java identifiers, and would not have to avoid Java reserved words. Also, the SourceFile and LineNumberTable attributes could point to the 01_ source.

Here is the runtime:


package rt01_;

public abstract class val {
    protected val trampoline() {
        return null;
    }

    public boolean nil() {
        return false;
    }

    public abstract boolean head();
    public abstract val tail();

    public static final val NIL = new val() {
            public boolean nil() {
                return true;
            }

            public boolean head() {
                throw new NullPointerException();
            }

            public val tail() {
                throw new NullPointerException();
            }
        };

    public static val trampoline(val val) {
        for (val v = val.trampoline(); v != null; v = val.trampoline())
            val = v;
        return val;
    }
}

package rt01_;

public class constant extends val {
    private String bits;
    private int index;
    private val tail = null;

    public constant(String bits) {
        this(bits, 0);
    }

    private constant(String bits, int index) {
        this.bits = bits;
        this.index = index;
    }

    protected val trampoline() {
        if (index >= bits.length())
            return NIL;
        return null;
    }

    public boolean head() {
        return '1' == bits.charAt(index);
    }

    public val tail() {
        if (tail == null) {
            if (index + 1 < bits.length())
                tail = new constant(bits, index + 1);
            else
                tail = NIL;
        }
        return tail;
    }
}

package rt01_;

public class concat extends val {
    private val first;
    private val second;
    private val tail = null;

    public concat(val first, val second) {
        this.first = first;
        this.second = second;
    }

    protected val trampoline() {
        first = trampoline(first);
        if (first.nil())
            return second;
        else
            return null;
    }

    public boolean head() {
        return first.head();
    }

    public val tail() {
        if (tail == null)
            tail = new concat(first.tail(), second);
        return tail;
    }
}

package rt01_;

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;

public class input extends val {
    private InputStream in;
    private int byt;
    private int bit;
    private val tail = null;

    public input(String file) throws IOException {
        this(new FileInputStream(file));
    }

    public input(InputStream in) {
        this(in, -1, 0);
    }

    private input(InputStream in, int byt, int bit) {
        this.in = in;
        this.byt = byt;
        this.bit = bit;
    }

    protected val trampoline() {
        if (bit == 0) {
            try {
                byt = in.read();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            if (byt < 0)
                return NIL;
            bit = 128;
        }
        return null;
    }

    public boolean head() {
        return (byt & bit) != 0;
    }

    public val tail() {
        if (tail == null)
            tail = new input(in, byt, bit >> 1);
        return tail;
    }
}

package rt01_;

import java.io.OutputStream;
import java.io.PrintStream;

public abstract class function extends val {
    private val val = null;

    protected val trampoline() {
        if (val == null)
            val = eval();
        return val;
    }

    protected abstract val eval();

    public boolean nil() {
        throw new RuntimeException();
    }

    public boolean head() {
        throw new RuntimeException();
    }

    public val tail() {
        throw new RuntimeException();
    }

    public static void main(String[] args, int arity, String name) throws Exception {
        Class<?>[] types = new Class<?>[arity];
        for (int i = 0; i < arity; i++)
            types[i] = val.class;
        int index = 0;
        boolean bits = false;
        if (args.length > 0 && "-bits".equals(args[0])) {
            index = 1;
            bits = true;
        }
        val val = (function) Class.forName(name).getDeclaredConstructor(types).newInstance((Object[]) args(args, arity, index));
        if (bits)
            writeBits(val, System.out);
        else
            write(val, System.out);
        System.out.flush();
    }

    public static val[] args(String[] args, int arity, int index) throws Exception {
        val[] vals = new val[arity];
        val stdin = null;
        for (int i = 0; i < arity; i++) {
            if (index + i < args.length) {
                if (!"-".equals(args[index + i])) {
                    vals[i] = new input(args[index + i]);
                } else {
                    if (stdin == null)
                        stdin = new input(System.in);
                    vals[i] = stdin;
                }
            } else if (stdin == null) {
                stdin = new input(System.in);
                vals[i] = stdin;
            } else {
                vals[i] = NIL;
            }
        }
        return vals;
    }

    public static void writeBits(val val, PrintStream out) throws Exception {
        for (;;) {
            val = trampoline(val);
            if (val.nil())
                break;
            out.print(val.head() ? "1" : "0");
            val = val.tail();
        }
    }

    public static void write(val val, OutputStream out) throws Exception {
        int byt = 0;
        int bit = 128;
        for (;;) {
            val = trampoline(val);
            if (val.nil())
                break;
            byt |= val.head() ? bit : 0;
            bit >>= 1;
            if (bit == 0) {
                out.write(byt);
                byt = 0;
                bit = 128;
            }
            val = val.tail();
        }
    }
}

Here is the interpreter and compiler to Java:


public class BoundExpr extends Expr {
    private int index;

    public BoundExpr(Token token, int index) {
        super(token);
        this.index = index;
    }

    public rt01_.val eval(rt01_.val[] bindings) {
        return bindings[index];
    }

    public int getIndex() {
        return index;
    }
}

import java.io.FileWriter;
import java.io.PrintWriter;

public class Compiler {
    public static void main(String[] args) throws Exception {
        Parser parser = new Parser();
        for (String arg : args)
            parser.add(arg);
        for (Function function : parser.getFunctions().values()) {
            PrintWriter out = new PrintWriter(new FileWriter(function.getMangledName() + ".java"));
            function.compile(out);
            out.flush();
            out.close();
        }
    }
}

public class ConcatExpr extends Expr {
    private Expr first;
    private Expr second;

    public ConcatExpr(Expr first, Expr second) {
        super(first.getToken());
        this.first = first;
        this.second = second;
    }

    public rt01_.val eval(rt01_.val[] bindings) {
        return new rt01_.concat(first.eval(bindings), second.eval(bindings));
    }

    public Expr getFirst() {
        return first;
    }

    public Expr getSecond() {
        return second;
    }
}

import java.util.List;

public class ConstantExpr extends Expr {
    private String bits;
    private rt01_.constant val;

    public ConstantExpr(Token token, boolean[] bits) {
        super(token);
        StringBuilder sb = new StringBuilder();
        for (boolean bit : bits)
            sb.append(bit ? "1" : "0");
        this.bits = sb.toString();
        val = new rt01_.constant(this.bits);
    }

    public rt01_.val eval(rt01_.val[] bindings) {
        return val;
    }

    public String getBits() {
        return bits;
    }
}

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;

public class Def {
    private Token name;
    private Pattern[] patterns;
    private Token[] body;

    private int bindingCount;
    private Expr expr;

    public Def(Token name, Pattern[] patterns, Token[] body) {
        this.name = name;
        this.patterns = patterns;
        this.body = body;

        bindingCount = 0;
        for (Pattern pattern : patterns)
            if (pattern.isBinding())
                bindingCount++;
    }

    public int getArity() {
        return patterns.length;
    }

    public Token getName() {
        return name;
    }

    private class ParseState {
        int index;
        Expr expr;
    }

    public void parse(Map<String,Function> functions) {
        if (body.length == 0) {
            expr = new ConstantExpr(name, new boolean[0]);
        } else {
            ParseState state = new ParseState();
            state.index = 0;
            state.expr = null;
            parse(functions, state);
            expr = state.expr;
        }
        body = null;
    }

    private void parse(Map<String,Function> functions, ParseState state) {
        state.expr = null;
        parse1(functions, state);
        if (state.index < body.length) {
            Expr first = state.expr;
            parse(functions, state);
            state.expr = new ConcatExpr(first, state.expr);
        }
    }

    private void parse1(Map<String,Function> functions, ParseState state) {
        Token token = body[state.index];
        switch (token.getType()) {
        case EQUALS: case DOT:
            assert false;
            throw new RuntimeException();
        case ZERO: case ONE: case NIL:
            parseConstant(token, state);
            return;
        case SYMBOL:
            state.index++;
            state.expr = binding(token);
            if (state.expr != null)
                return;
            if (!functions.containsKey(token.getSymbol()))
                throw new RuntimeException(token.getLocation() + ": unknown function: " + token.getSymbol());
            Function function = functions.get(token.getSymbol());
            Expr[] args = new Expr[function.getArity()];
            for (int i = 0; i < args.length; i++) {
                parse1(functions, state);
                args[i] = state.expr;
            }
            state.expr = new FuncallExpr(token, function, args);
        }
    }

    private void parseConstant(Token token, ParseState state) {
        ArrayList<Boolean> bits = new ArrayList<Boolean>();
        loop: while (state.index < body.length) {
            switch (body[state.index].getType()) {
            case ZERO:
                state.index++;
                bits.add(false);
                break;
            case ONE:
                state.index++;
                bits.add(true);
                break;
            case NIL:
                state.index++;
            default:
                break loop;
            }
        }
        state.expr = new ConstantExpr(token, DefReader.toBitArray(bits));
    }

    private BoundExpr binding(Token token) {
        int bindingIndex = 0;
        for (Pattern pattern : patterns) {
            if (!pattern.isBinding())
                continue;
            if (pattern.getToken().getSymbol().equals(token.getSymbol()))
                return new BoundExpr(token, bindingIndex);
            bindingIndex++;
        }
        return null;
    }

    public Expr getExpr() {
        return expr;
    }

    public rt01_.val eval(rt01_.val[] args) {
        assert args.length == patterns.length;
        rt01_.val[] bindings = new rt01_.val[bindingCount];
        int bindingIndex = 0;
        for (int i = 0; i < args.length; i++) {
            rt01_.val val = patterns[i].match(args[i]);
            if (val == null)
                return null;
            if (patterns[i].isBinding())
                bindings[bindingIndex++] = val;
        }
        return expr.eval(bindings);
    }

    public void compile(int n, PrintWriter out) throws Exception {
        out.print("    private rt01_.val m");
        out.print(n);
        out.println("() {");
        if (patterns.length > 0)
            out.println("        rt01_.val val;");
        int bindingIndex = 0;
        for (int i = 0; i < patterns.length; i++) {
            Pattern pattern = patterns[i];
            boolean[] bits = pattern.getBits();
            if (bits.length > 0) {
                out.print("        a");
                out.print(i);
                out.print(" = trampoline(a");
                out.print(i);
                out.println(");");
            }
            out.print("        val = a");
            out.print(i);
            out.println(";");
            boolean start = true;
            for (boolean bit : bits) {
                if (start)
                    start = false;
                else
                    out.println("        val = trampoline(val);");
                out.print("        if (val.nil() || ");
                if (bit) out.print("!");
                out.println("val.head()) return null;");
                out.println("        val = val.tail();");
            }
            if (pattern.isLiteral()) {
                out.println("        val = trampoline(val);");
                out.println("        if (!val.nil()) return null;");
            } else if (pattern.isBinding()) {
                out.print("        rt01_.val b");
                out.print(bindingIndex);
                out.println(" = val;");
                bindingIndex++;
            }
        }
        out.print("        return ");
        compileExpr(expr, out);
        out.println(";");
        out.println("    }");
    }

    private void compileExpr(Expr e, PrintWriter out) throws Exception {
        if (e instanceof BoundExpr) {
            out.print("b");
            out.print(((BoundExpr) e).getIndex());
        } else if (e instanceof ConstantExpr) {
            out.print("_");
            out.print(((ConstantExpr) e).getBits());
        } else if (e instanceof ConcatExpr) {
            out.print("new rt01_.concat(");
            compileExpr(((ConcatExpr) e).getFirst(), out);
            out.print(",");
            compileExpr(((ConcatExpr) e).getSecond(), out);
            out.print(")");
        } else if (e instanceof FuncallExpr) {
            out.print("new ");
            out.print(((FuncallExpr) e).getFunction().getMangledName());
            out.print("(");
            boolean start = true;
            for (Expr arg : ((FuncallExpr) e).getArgs()) {
                if (start)
                    start = false;
                else
                    out.print(",");
                compileExpr(arg, out);
            }
            out.print(")");
        }
    }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class DefReader implements Iterator<Def> {
    private Iterator<Token> tokenizer;
    private Def def = null;

    public DefReader(Iterator<Token> tokenizer) {
        this.tokenizer = tokenizer;
    }

    public boolean hasNext() {
        if (def == null)
            def = readNext();
        return def != null;
    }

    public Def next() {
        if (def == null)
            return readNext();
        Def result = def;
        def = null;
        return result;
    }

    public void remove() {
    }

    private Def readNext() {
        if (!tokenizer.hasNext())
            return null;
        Token name = tokenizer.next();
        if (name.getType() != Token.Type.SYMBOL)
            throw new RuntimeException(name.getLocation() + ": symbol expected");
        ArrayList<Pattern> patterns = readPatterns(name);
        ArrayList<Token> body = new ArrayList<Token>();
        for (;;) {
            if (!tokenizer.hasNext())
                throw new RuntimeException(name.getLocation() + ": incomplete definition");
            Token token = tokenizer.next();
            if (token.getType() == Token.Type.DOT)
                break;
            body.add(token);
        }
        return new Def(name, patterns.toArray(new Pattern[patterns.size()]), body.toArray(new Token[body.size()]));
    }

    private ArrayList<Pattern> readPatterns(Token name) {
        ArrayList<Pattern> patterns = new ArrayList<Pattern>();
        ArrayList<Boolean> bits = new ArrayList<Boolean>();
        Token startToken = null;
        for (;;) {
            if (!tokenizer.hasNext())
                throw new RuntimeException(name.getLocation() + ": incomplete definition");
            Token token = tokenizer.next();
            if (startToken == null)
                startToken = token;
            switch (token.getType()) {
            case EQUALS:
                if (bits.size() > 0)
                    patterns.add(new Pattern(startToken, toBitArray(bits), null));
                return patterns;
            case ZERO:
                bits.add(false);
                break;
            case ONE:
                bits.add(true);
                break;
            case DOT:
            case NIL:
            case SYMBOL:
                patterns.add(new Pattern(startToken, toBitArray(bits), token));
                bits.clear();
                startToken = null;
                break;
            }
        }
    }

    public static boolean[] toBitArray(List<Boolean> list) {
        boolean[] bits = new boolean[list.size()];
        for (int i = 0; i < list.size(); i++)
            bits[i] = list.get(i);
        return bits;
    }
}
public abstract class Expr {
    private Token token;

    protected Expr(Token token) {
        this.token = token;
    }

    public abstract rt01_.val eval(rt01_.val[] bindings);

    public Token getToken() {
        return token;
    }
}

public class FuncallExpr extends Expr {
    private Function function;
    private Expr[] args;

    public FuncallExpr(Token token, Function function, Expr[] args) {
        super(token);
        this.function = function;
        this.args = args;
    }

    public rt01_.val eval(rt01_.val[] bindings) {
        rt01_.val[] argVals = new rt01_.val[args.length];
        for (int i = 0; i < argVals.length; i++)
            argVals[i] = args[i].eval(bindings);
        return function.eval(argVals);
    }

    public Function getFunction() {
        return function;
    }

    public Expr[] getArgs() {
        return args;
    }
}

import java.io.File;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Map;

public class Function {
    private Def[] defs;

    public Function(Def[] defs) {
        this.defs = defs;
    }

    public int getArity() {
        return defs[0].getArity();
    }

    public void parse(Map<String,Function> functions) {
        for (Def def : defs)
            def.parse(functions);
    }

    private class Result extends rt01_.function {
        private rt01_.val[] args;
        Result(rt01_.val[] args) {
            this.args = args;
        }

        protected rt01_.val eval() {
            for (Def def : defs) {
                rt01_.val val = def.eval(args);
                if (val != null) {
                    args = null; // let arguments get garbage collected
                    return val;
                }
            }
            Token name = defs[defs.length-1].getName();
            throw new RuntimeException(name.getLocation() + ": no matching pattern in definition of " + name.getSymbol());
        }
    }

    public rt01_.function eval(rt01_.val[] args) {
        return new Result(args);
    }

    private static final HashSet<String> reserved = new HashSet<String>();
    static {
        reserved.add("abstract");
        reserved.add("assert");
        reserved.add("boolean");
        reserved.add("break");
        reserved.add("byte");
        reserved.add("case");
        reserved.add("catch");
        reserved.add("char");
        reserved.add("class");
        reserved.add("const");
        reserved.add("continue");
        reserved.add("default");
        reserved.add("do");
        reserved.add("double");
        reserved.add("else");
        reserved.add("enum");
        reserved.add("extends");
        reserved.add("false");
        reserved.add("final");
        reserved.add("finally");
        reserved.add("float");
        reserved.add("for");
        reserved.add("goto");
        reserved.add("if");
        reserved.add("implements");
        reserved.add("import");
        reserved.add("instanceof");
        reserved.add("int");
        reserved.add("interface");
        reserved.add("long");
        reserved.add("native");
        reserved.add("new");
        reserved.add("null");
        reserved.add("package");
        reserved.add("private");
        reserved.add("protected");
        reserved.add("public");
        reserved.add("return");
        reserved.add("short");
        reserved.add("static");
        reserved.add("switch");
        reserved.add("synchronized");
        reserved.add("strictfp");
        reserved.add("super");
        reserved.add("this");
        reserved.add("throw");
        reserved.add("throws");
        reserved.add("transient");
        reserved.add("true");
        reserved.add("try");
        reserved.add("void");
        reserved.add("volatile");
        reserved.add("while");
    }

    public static String mangle(String name) {
        StringBuilder sb = new StringBuilder();
        if (reserved.contains(name))
            sb.append("__");
        for (int i = 0; i < name.length(); i++)
            switch (name.charAt(i)) {
            case '0': case '1': case '2': case '3': case '4': case '5':
            case '6': case '7': case '8': case '9':
                if (i == 0)
                    sb.append("__");
            case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
            case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
            case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
            case 's': case 't': case 'u': case 'v': case 'w': case 'x':
            case 'y': case 'z':
            case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
            case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
            case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
            case 'Y': case 'Z':
                sb.append(name.charAt(i));
                break;
            default:
                sb.append('_').append(Integer.toHexString(name.charAt(i))).append('_');
            }
        return sb.toString();
    }

    public String getMangledName() {
        return mangle(defs[0].getName().getSymbol());
    }

    public void compile(PrintWriter out) throws Exception {
        int arity = getArity();
        String name = getMangledName();
        out.print("public class ");
        out.print(name);
        out.println(" extends rt01_.function {");
        for (int i = 0; i < arity; i++) {
            out.print("    private rt01_.val a");
            out.print(i);
            out.println(";");
        }
        out.print("    public ");
        out.print(name);
        out.print("(");
        for (int i = 0; i < arity; i++) {
            if (i > 0)
                out.print(",");
            out.print("rt01_.val p");
            out.print(i);
        }
        out.println(") {");
        for (int i = 0; i < arity; i++) {
            out.print("        a");
            out.print(i);
            out.print("=p");
            out.print(i);
            out.println(";");
        }
        out.println("    }");
        out.println("    protected rt01_.val eval() {");
        out.println("        rt01_.val val;");
        out.print("        if (");
        for (int i = 0; i < defs.length; i++) {
            out.print("(val = m");
            out.print(i);
            out.print("()) == null && ");
        }
        out.print("true) throw new RuntimeException(\"");
        out.print(getLocation(defs[defs.length-1].getName()));
        out.println(": pattern match failed\");");
        for (int i = 0; i < arity; i++) {
            out.print("        a");
            out.print(i);
            out.println(" = null;");
        }
        out.println("        return val;");
        out.println("    }");
        HashSet<String> constants = new HashSet<String>();
        for (Def def : defs)
            collectConstants(constants, def.getExpr());
        for (String constant : constants) {
            out.print("    private static final rt01_.val _");
            out.print(constant);
            if (constant.length() == 0) {
                out.println(" = NIL;");
            } else {
                out.print(" = new rt01_.constant(\"");
                out.print(constant);
                out.println("\");");
            }
        }
        for (int i = 0; i < defs.length; i++)
            defs[i].compile(i, out);
        out.println("    public static void main(String[] args) throws Exception {");
        out.print("        main(args,");
        out.print(arity);
        out.print(",\"");
        out.print(name);
        out.println("\");");
        out.println("    }");
        out.println("}");
    }

    private void collectConstants(HashSet<String> constants, Expr expr) {
        if (expr instanceof ConstantExpr) {
            constants.add(((ConstantExpr) expr).getBits());
        } else if (expr instanceof ConcatExpr) {
            collectConstants(constants, ((ConcatExpr) expr).getFirst());
            collectConstants(constants, ((ConcatExpr) expr).getSecond());
        } else if (expr instanceof FuncallExpr) {
            for (Expr arg : ((FuncallExpr) expr).getArgs())
                collectConstants(constants, arg);
        }
    }

    public static String getLocation(Token token) {
        return new File(token.getFileName()).getName() + ":" + token.getLineNumber() + ":" + token.getColumn();
    }
}

import java.io.File;
import java.util.Map;

public class Interpreter {
    public static void main(String[] args) throws Exception {
        Parser parser = new Parser();
        int i;
        String fname = null;
        for (i = 0; i < args.length && !args[i].equals("-"); i++) {
            parser.add(args[i]);
            fname = getFunction(args[i]);
        }
        if (i + 1 < args.length) {
            fname = args[i+1];
            i = i + 2;
        }
        boolean writeBits = false;
        if (i < args.length && "-bits".equals(args[i])) {
            i++;
            writeBits = true;
        }
        Function f = parser.getFunctions().get(fname);
        if (writeBits)
            rt01_.function.writeBits(f.eval(rt01_.function.args(args, f.getArity(), i)), System.out);
        else
            rt01_.function.write(f.eval(rt01_.function.args(args, f.getArity(), i)), System.out);
        System.out.flush();
    }

    private static String getFunction(String fileName) {
        String fn = new File(fileName).getName();
        if (fn.indexOf('.') > 0)
            return fn.substring(0, fn.indexOf('.'));
        else
            return fn;
    }
}

import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class Parser {
    private HashMap<String,Integer> arities = new HashMap<String,Integer>();
    private HashMap<String,List<Def>> functions = new HashMap<String,List<Def>>();

    public void add(String fileName) throws Exception {
        add(new Tokenizer(fileName));
    }

    public void add(Reader in, String fileName, int lineNumber, int column) {
        add(new Tokenizer(in, fileName, lineNumber, column));
    }

    public void add(Iterator<Token> tokenizer) {
        addDefs(new DefReader(tokenizer));
    }

    public void addDefs(Iterator<Def> defs) {
        while (defs.hasNext()) {
            Def def = defs.next();
            Token name = def.getName();
            if (arities.containsKey(name.getSymbol())) {
                if (def.getArity() != arities.get(name.getSymbol()))
                    throw new RuntimeException(name.getLocation() + ": arity mismatch in definition of " + name.getSymbol());
            } else {
                arities.put(name.getSymbol(), def.getArity());
                functions.put(name.getSymbol(), new ArrayList<Def>());
            }
            functions.get(name.getSymbol()).add(def);
        }
    }

    public Map<String,Function> getFunctions() {
        HashMap<String,Function> fns = new HashMap<String,Function>();
        for (Map.Entry<String,List<Def>> entry : functions.entrySet()) {
            List<Def> defs = entry.getValue();
            fns.put(entry.getKey(), new Function(defs.toArray(new Def[defs.size()])));
        }
        for (Function function : fns.values())
            function.parse(fns);
        return fns;
    }
}

public class Pattern {
    private Token startToken;
    private boolean[] bits;
    private Token token;
    private String fileName;
    private int lineNumber;

    public Pattern(Token startToken, boolean[] bits, Token token) {
        this.startToken = startToken;
        this.bits = bits;
        this.token = token;
    }

    public Token getStartToken() {
        return startToken;
    }

    public boolean[] getBits() {
        return bits;
    }

    public Token getToken() {
        return token;
    }

    public boolean isLiteral() {
        return token == null || token.getType() == Token.Type.NIL;
    }

    public boolean isWild() {
        return token != null && token.getType() == Token.Type.DOT;
    }

    public boolean isBinding() {
        return token != null && token.getType() == Token.Type.SYMBOL;
    }

    public rt01_.val match(rt01_.val val) {
        for (int i = 0; i < bits.length; i++) {
            val = rt01_.val.trampoline(val);
            if (val.nil() || val.head() != bits[i])
                return null;
            val = val.tail();
        }
        if (isLiteral()) {
            val = rt01_.val.trampoline(val);
            if (!val.nil())
                return null;
        }
        return val;
    }
}

public class Token {
    public enum Type {
        ZERO, ONE, NIL, DOT, EQUALS, SYMBOL
    }

    private Type type;
    private String symbol;
    private String fileName;
    private int lineNumber;
    private int column;

    public Token(Type type, String symbol, String fileName, int lineNumber, int column) {
        this.type = type;
        this.symbol = symbol;
        this.fileName = fileName;
        this.lineNumber = lineNumber;
        this.column = column;
    }

    public Type getType() {
        return type;
    }

    public String getSymbol() {
        return symbol;
    }

    public String getFileName() {
        return fileName;
    }

    public int getLineNumber() {
        return lineNumber;
    }

    public int getColumn() {
        return column;
    }

    public String getLocation() {
        return fileName + ":" + lineNumber + ":" + column;
    }
}

import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;

public class Tokenizer implements Iterator<Token> {
    private Reader in;
    private String fileName;
    private int lineNumber;
    private int column = 0;

    private int pushback = -1;
    private Token next;

    public Tokenizer(String fileName) throws Exception {
        this(new FileReader(fileName), fileName, 1, 0);
    }

    public Tokenizer(Reader in, String fileName, int lineNumber, int column) {
        this.in = in;
        this.fileName = fileName;
        this.lineNumber = lineNumber;
    }

    public boolean hasNext() {
        if (next == null)
            readNext();
        return next != null;
    }

    public Token next() {
        if (next == null)
            readNext();
        Token result =  next;
        next = null;
        return result;
    }

    public void remove() {
    }

    private void pushback(int lastChar) {
        assert pushback < 0;
        pushback = lastChar;
        column--;
        if (lastChar == '\n')
            lineNumber--;
    }

    private int nextChar() {
        int nextChar = -1;
        if (pushback >= 0) {
            nextChar = pushback;
            pushback = -1;
        } else {
            try {
                nextChar = in.read();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        if (nextChar >= 0) {
            column++;
            if (nextChar == '\n') {
                lineNumber++;
                column = 0;
            }
        }
        return nextChar;
    }

    private void readNext() {
        for (;;) {
            int nextChar = nextChar();
            if (nextChar < 0)
                return;
            int saveLineNumber = lineNumber;
            int saveColumn = column;
            switch (nextChar) {
            case '0':
                next = new Token(Token.Type.ZERO, null, fileName, lineNumber, column);
                return;
            case '1':
                next = new Token(Token.Type.ONE, null, fileName, lineNumber, column);
                return;
            case '_':
                next = new Token(Token.Type.NIL, null, fileName, lineNumber, column);
                return;
            case '.':
                next = new Token(Token.Type.DOT, null, fileName, lineNumber, column);
                return;
            case '=':
                nextChar = nextChar();
                if (nextChar != '=') {
                    pushback(nextChar);
                    next = new Token(Token.Type.EQUALS, null, fileName, saveLineNumber, saveColumn);
                    return;
                }
                while (nextChar >= 0 && nextChar != '\n')
                    nextChar = nextChar();
                continue;
            case ' ': case '\t': case '\r': case '\n':
                continue;
            default:
                StringBuilder sb = new StringBuilder();
                sb.append((char) nextChar);
                for (;;) {
                    nextChar = nextChar();
                    if (nextChar < 0) {
                        next = new Token(Token.Type.SYMBOL, sb.toString(), fileName, saveLineNumber, saveColumn);
                        return;
                    }
                    switch (nextChar) {
                    case '0': case '1': case '_': case '.': case '=':
                    case ' ': case '\t': case '\r': case '\n':
                        pushback(nextChar);
                        next = new Token(Token.Type.SYMBOL, sb.toString(), fileName, saveLineNumber, saveColumn);
                        return;
                    default:
                        sb.append((char) nextChar);
                    }
                }
            }
        }
    }
}

Here is 99 bottles of beer compiled to Java:


public class __2 extends rt01_.function {
    private rt01_.val a0;
    public __2(rt01_.val p0) {
        a0=p0;
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && true) throw new RuntimeException("99.01_:5:1: pattern match failed");
        a0 = null;
        return val;
    }
    private static final rt01_.val _010 = new rt01_.constant("010");
    private rt01_.val m0() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || !val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || !val.head()) return null;
        val = val.tail();
        rt01_.val b0 = val;
        return new rt01_.concat(_010,b0);
    }
    public static void main(String[] args) throws Exception {
        main(args,1,"__2");
    }
}
public class __33r extends rt01_.function {
    public __33r() {
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && true) throw new RuntimeException("99.01_:8:1: pattern match failed");
        return val;
    }
    private static final rt01_.val _001000000110111101101110001000000111010001101000011001010010000001110111011000010110110001101100 = new rt01_.constant("001000000110111101101110001000000111010001101000011001010010000001110111011000010110110001101100");
    private rt01_.val m0() {
        return _001000000110111101101110001000000111010001101000011001010010000001110111011000010110110001101100;
    }
    public static void main(String[] args) throws Exception {
        main(args,0,"__33r");
    }
}
public class __4 extends rt01_.function {
    private rt01_.val a0;
    public __4(rt01_.val p0) {
        a0=p0;
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && (val = m1()) == null && (val = m2()) == null && (val = m3()) == null && true) throw new RuntimeException("99.01_:14:1: pattern match failed");
        a0 = null;
        return val;
    }
    private static final rt01_.val _ = NIL;
    private static final rt01_.val _1 = new rt01_.constant("1");
    private static final rt01_.val _1001 = new rt01_.constant("1001");
    private static final rt01_.val _0 = new rt01_.constant("0");
    private rt01_.val m0() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (!val.nil()) return null;
        return _1001;
    }
    private rt01_.val m1() {
        rt01_.val val;
        val = a0;
        val = trampoline(val);
        if (!val.nil()) return null;
        return _;
    }
    private rt01_.val m2() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        rt01_.val b0 = val;
        return new rt01_.concat(_1,new __4(b0));
    }
    private rt01_.val m3() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || !val.head()) return null;
        val = val.tail();
        rt01_.val b0 = val;
        return new rt01_.concat(_0,b0);
    }
    public static void main(String[] args) throws Exception {
        main(args,1,"__4");
    }
}
public class __5 extends rt01_.function {
    private rt01_.val a0;
    private rt01_.val a1;
    public __5(rt01_.val p0,rt01_.val p1) {
        a0=p0;
        a1=p1;
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && (val = m1()) == null && (val = m2()) == null && (val = m3()) == null && true) throw new RuntimeException("99.01_:20:1: pattern match failed");
        a0 = null;
        a1 = null;
        return val;
    }
    private static final rt01_.val _00110001 = new rt01_.constant("00110001");
    private static final rt01_.val _01101110011011110010000001101101011011110111001001100101 = new rt01_.constant("01101110011011110010000001101101011011110111001001100101");
    private static final rt01_.val _0011 = new rt01_.constant("0011");
    private static final rt01_.val _01110011 = new rt01_.constant("01110011");
    private rt01_.val m0() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        a1 = trampoline(a1);
        val = a1;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (!val.nil()) return null;
        return new rt01_.concat(_01101110011011110010000001101101011011110111001001100101,new rt01_.concat(new __7(),_01110011));
    }
    private rt01_.val m1() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        a1 = trampoline(a1);
        val = a1;
        if (val.nil() || !val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (!val.nil()) return null;
        return new rt01_.concat(_00110001,new __7());
    }
    private rt01_.val m2() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = a1;
        rt01_.val b0 = val;
        return new rt01_.concat(_0011,new rt01_.concat(new __6(b0),new rt01_.concat(new __7(),_01110011)));
    }
    private rt01_.val m3() {
        rt01_.val val;
        val = a0;
        rt01_.val b0 = val;
        val = a1;
        rt01_.val b1 = val;
        return new rt01_.concat(_0011,new rt01_.concat(new __6(b0),new rt01_.concat(_0011,new rt01_.concat(new __6(b1),new rt01_.concat(new __7(),_01110011)))));
    }
    public static void main(String[] args) throws Exception {
        main(args,2,"__5");
    }
}
public class __6 extends rt01_.function {
    private rt01_.val a0;
    public __6(rt01_.val p0) {
        a0=p0;
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && (val = m1()) == null && (val = m2()) == null && true) throw new RuntimeException("99.01_:25:1: pattern match failed");
        a0 = null;
        return val;
    }
    private static final rt01_.val _ = NIL;
    private static final rt01_.val _1 = new rt01_.constant("1");
    private static final rt01_.val _0 = new rt01_.constant("0");
    private rt01_.val m0() {
        rt01_.val val;
        val = a0;
        val = trampoline(val);
        if (!val.nil()) return null;
        return _;
    }
    private rt01_.val m1() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        rt01_.val b0 = val;
        return new rt01_.concat(new __6(b0),_0);
    }
    private rt01_.val m2() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || !val.head()) return null;
        val = val.tail();
        rt01_.val b0 = val;
        return new rt01_.concat(new __6(b0),_1);
    }
    public static void main(String[] args) throws Exception {
        main(args,1,"__6");
    }
}
public class __7 extends rt01_.function {
    public __7() {
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && true) throw new RuntimeException("99.01_:28:1: pattern match failed");
        return val;
    }
    private static final rt01_.val _00100000011000100110111101110100011101000110110001100101 = new rt01_.constant("00100000011000100110111101110100011101000110110001100101");
    private rt01_.val m0() {
        return _00100000011000100110111101110100011101000110110001100101;
    }
    public static void main(String[] args) throws Exception {
        main(args,0,"__7");
    }
}
public class __8 extends rt01_.function {
    private rt01_.val a0;
    private rt01_.val a1;
    public __8(rt01_.val p0,rt01_.val p1) {
        a0=p0;
        a1=p1;
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && (val = m1()) == null && true) throw new RuntimeException("99.01_:32:1: pattern match failed");
        a0 = null;
        a1 = null;
        return val;
    }
    private rt01_.val m0() {
        rt01_.val val;
        val = a0;
        rt01_.val b0 = val;
        a1 = trampoline(a1);
        val = a1;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (!val.nil()) return null;
        return new __4(b0);
    }
    private rt01_.val m1() {
        rt01_.val val;
        val = a0;
        rt01_.val b0 = val;
        val = a1;
        return b0;
    }
    public static void main(String[] args) throws Exception {
        main(args,2,"__8");
    }
}
public class __9 extends rt01_.function {
    private rt01_.val a0;
    private rt01_.val a1;
    public __9(rt01_.val p0,rt01_.val p1) {
        a0=p0;
        a1=p1;
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && (val = m1()) == null && true) throw new RuntimeException("99.01_:36:1: pattern match failed");
        a0 = null;
        a1 = null;
        return val;
    }
    private static final rt01_.val _1001 = new rt01_.constant("1001");
    private static final rt01_.val _0010110000100000 = new rt01_.constant("0010110000100000");
    private static final rt01_.val _001011100000101001010100011000010110101101100101001000000110111101101110011001010010000001100100011011110111011101101110001000000110000101101110011001000010000001110000011000010111001101110011001000000110100101110100001000000110000101110010011011110111010101101110011001000010110000100000 = new rt01_.constant("001011100000101001010100011000010110101101100101001000000110111101101110011001010010000001100100011011110111011101101110001000000110000101101110011001000010000001110000011000010111001101110011001000000110100101110100001000000110000101110010011011110111010101101110011001000010110000100000");
    private static final rt01_.val _0010111000001010 = new rt01_.constant("0010111000001010");
    private static final rt01_.val _0000 = new rt01_.constant("0000");
    private static final rt01_.val _00101110000010100100011101101111001000000111010001101111001000000111010001101000011001010010000001110011011101000110111101110010011001010010000001100001011011100110010000100000011000100111010101111001001000000111001101101111011011010110010100100000011011010110111101110010011001010010110000100000 = new rt01_.constant("00101110000010100100011101101111001000000111010001101111001000000111010001101000011001010010000001110011011101000110111101110010011001010010000001100001011011100110010000100000011000100111010101111001001000000111001101101111011011010110010100100000011011010110111101110010011001010010110000100000");
    private static final rt01_.val _001011100000101000001010 = new rt01_.constant("001011100000101000001010");
    private rt01_.val m0() {
        rt01_.val val;
        a0 = trampoline(a0);
        val = a0;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        a1 = trampoline(a1);
        val = a1;
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (val.nil() || val.head()) return null;
        val = val.tail();
        val = trampoline(val);
        if (!val.nil()) return null;
        return new rt01_.concat(new __2(new __5(_0000,_0000)),new rt01_.concat(new b(),new rt01_.concat(new __33r(),new rt01_.concat(_0010110000100000,new rt01_.concat(new __5(_0000,_0000),new rt01_.concat(new b(),new rt01_.concat(_00101110000010100100011101101111001000000111010001101111001000000111010001101000011001010010000001110011011101000110111101110010011001010010000001100001011011100110010000100000011000100111010101111001001000000111001101101111011011010110010100100000011011010110111101110010011001010010110000100000,new rt01_.concat(new __5(_1001,_1001),new rt01_.concat(new b(),new rt01_.concat(new __33r(),_0010111000001010))))))))));
    }
    private rt01_.val m1() {
        rt01_.val val;
        val = a0;
        rt01_.val b0 = val;
        val = a1;
        rt01_.val b1 = val;
        return new rt01_.concat(new __5(b0,b1),new rt01_.concat(new b(),new rt01_.concat(new __33r(),new rt01_.concat(_0010110000100000,new rt01_.concat(new __5(b0,b1),new rt01_.concat(new b(),new rt01_.concat(_001011100000101001010100011000010110101101100101001000000110111101101110011001010010000001100100011011110111011101101110001000000110000101101110011001000010000001110000011000010111001101110011001000000110100101110100001000000110000101110010011011110111010101101110011001000010110000100000,new rt01_.concat(new __5(new __8(b0,b1),new __4(b1)),new rt01_.concat(new b(),new rt01_.concat(new __33r(),new rt01_.concat(_001011100000101000001010,new __9(new __8(b0,b1),new __4(b1)))))))))))));
    }
    public static void main(String[] args) throws Exception {
        main(args,2,"__9");
    }
}
public class __99 extends rt01_.function {
    public __99() {
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && true) throw new RuntimeException("99.01_:38:1: pattern match failed");
        return val;
    }
    private static final rt01_.val _1001 = new rt01_.constant("1001");
    private rt01_.val m0() {
        return new __9(_1001,_1001);
    }
    public static void main(String[] args) throws Exception {
        main(args,0,"__99");
    }
}
public class b extends rt01_.function {
    public b() {
    }
    protected rt01_.val eval() {
        rt01_.val val;
        if ((val = m0()) == null && true) throw new RuntimeException("99.01_:2:1: pattern match failed");
        return val;
    }
    private static final rt01_.val _0010000001101111011001100010000001100010011001010110010101110010 = new rt01_.constant("0010000001101111011001100010000001100010011001010110010101110010");
    private rt01_.val m0() {
        return _0010000001101111011001100010000001100010011001010110010101110010;
    }
    public static void main(String[] args) throws Exception {
        main(args,0,"b");
    }
}

2010-02-01T00:00:00.001-08:00

Here is a Parenthesis Hell interpreter in Java. It uses a mutable trie for the letrec bindings, where the interpreter in Haskell uses an immutable trie. Also, phi.Value.iterator() is a bit more complicated than the Haskell equivalent, which would be


data Flattened = HEAD | TAIL

flattened :: Value -> [Flattened]
flattened Nil = []
flattened (Cons head tail) = HEAD : flattened head ++ TAIL : flattened tail

I originally wrote the interpreter as multiple classes, but contained all of them as nested classes in a single class for this post. Some of the code would have been more straightforward had it been written recursively, but then larger data would cause stack overflows.


import java.io.EOFException;
import java.io.FileReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Reader;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.LinkedList;

public class phi {
    public static class EnumTrie<K extends Enum<K>,V> {
        private EnumMap<K,EnumTrie<K,V>> map;
        private V value = null;

        public EnumTrie(Class<K> keyType) {
            map = new EnumMap<K,EnumTrie<K,V>>(keyType);
        }

        private EnumTrie(EnumTrie<K,V> trie) {
            map = new EnumMap<K,EnumTrie<K,V>>(trie.map);
            map.clear();
        }

        public V getValue() {
            return value;
        }

        public EnumTrie<K,V> getSubtrie(K k) {
            return map.get(k);
        }

        public EnumTrie<K,V> findPrefix(Iterator<K> iterator) {
            EnumTrie<K,V> trie = this;
            while (trie != null && iterator.hasNext())
                trie = trie.map.get(iterator.next());
            return trie;
        }

        public V get(Iterable<K> key) {
            EnumTrie<K,V> trie = findPrefix(key.iterator());
            return trie != null ? trie.value : null;
        }

        private EnumTrie<K,V> addPrefix(Iterator<K> iterator) {
            EnumTrie<K,V> trie = this;
            while (iterator.hasNext()) {
                K k = iterator.next();
                EnumTrie<K,V> subtrie = trie.map.get(k);
                if (subtrie == null) {
                    subtrie = new EnumTrie<K,V>(trie);
                    trie.map.put(k, subtrie);
                }
                trie = subtrie;
            }
            return trie;
        }

        public V put(Iterable<K> key, V value) {
            EnumTrie<K,V> trie;
            if (value != null) {
                trie = addPrefix(key.iterator());
            } else {
                trie = findPrefix(key.iterator());
                if (trie == null)
                    return null;
            }
            trie.value = value;
            return value;
        }
    }

    public static abstract class Value implements Iterable<Value.Flattened> {
        public enum Flattened { HEAD, TAIL }

        public static final Value NIL = new NilValue();

        public boolean isNil() {
            return false;
        }

        public abstract Value getHead();
        public abstract Value getTail();

        public static Value read(Reader reader) throws IOException {
            LinkedList<Value> stack = new LinkedList<Value>();
            LinkedList<Boolean> open = new LinkedList<Boolean>();
            for (;;) {
                int c = reader.read();
                if (c < 0) {
                    throw new EOFException();
                } else if (c == '(') {
                    open.push(true);
                } else if (c == ')') {
                    if (open.size() == 0)
                        throw new EOFException();
                    if (open.pop()) {
                        if (open.size() == 0)
                            return NIL;
                        open.push(false);
                        stack.push(NIL);
                    } else {
                        Value value = new Pair(stack.pop(), NIL);
                        while (!open.pop())
                            value = new Pair(stack.pop(), value);
                        if (open.size() == 0)
                            return value;
                        stack.push(value);
                        open.push(false);
                    }
                }
            }
        }

        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append('(');
            toString(sb);
            sb.append(')');
            return sb.toString();
        }

        private void toString(StringBuilder sb) {
            if (!isNil()) {
                sb.append('(');
                getHead().toString(sb);
                sb.append(')');
                getTail().toString(sb);
            }
        }

        public Iterator<Flattened> iterator() {
            final LinkedList<Value> stack = new LinkedList<Value>();
            return new Iterator<Flattened>() {
                private Value value = Value.this;

                public boolean hasNext() {
                    return !value.isNil() || stack.size() > 0;
                }

                public Flattened next() {
                    if (value.isNil()) {
                        value = stack.pop().getTail();
                        return Flattened.TAIL;
                    } else {
                        stack.push(value);
                        value = value.getHead();
                        return Flattened.HEAD;
                    }
                }

                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        private static class NilValue extends Value {
            public boolean isNil() {
                return true;
            }

            public Value getHead() {
                return NilValue.this;
            }

            public Value getTail() {
                return NilValue.this;
            }
        }

        public static class Pair extends Value {
            private Value head;
            private Value tail;

            public Pair(Value head, Value tail) {
                this.head = head;
                this.tail = tail;
            }

            public Value getHead() {
                return head;
            }

            public Value getTail() {
                return tail;
            }
        }

        public static void write(Value value, OutputStream out) throws IOException {
            int bit = 128;
            int b = 0;
            while (!value.isNil()) {
                Value head = value.getHead();
                if (head.isNil()) {
                    value = value.getTail();
                } else {
                    b |= bit;
                    value = head;
                }
                if (bit == 1) {
                    out.write(b);
                    bit = 128;
                    b = 0;
                } else {
                    bit >>= 1;
                }
            }
        }

        public static class InputValue extends Value {
            private InputStream in;
            private int bit;
            private int b;
            private Value head = null;
            private Value tail = null;

            public InputValue(InputStream in) {
                this(in, 128, 0);
            }

            private InputValue(InputStream in, int bit, int b) {
                this.in = in;
                this.bit = bit;
                this.b = b;
            }

            private void init() {
                if (head == null) {
                    head = Value.NIL;
                    tail = Value.NIL;
                    if (bit == 0) {
                        try {
                            b = in.read();
                        } catch (IOException e) {
                            b = -1;
                        }
                        if (b < 0)
                            return;
                        bit = 128;
                    }
                    if ((b & bit) != 0)
                        head = new InputValue(in, bit>>1, b);
                    else
                        tail = new InputValue(in, bit>>1, b);
                }
            }

            public Value getHead() {
                init();
                return head;
            }

            public Value getTail() {
                init();
                return tail;
            }
        }
    }

    public static class Scope {
        private Scope outer;
        private EnumTrie<Value.Flattened,Interp.Op> bindings;
        private Value arg;

        public Scope(Scope outer, EnumTrie<Value.Flattened,Interp.Op> bindings, Value arg) {
            this.outer = outer;
            this.bindings = bindings;
            this.arg = arg;
        }

        public Value getArg() {
            Scope scope = this;
            while (scope.arg == null)
                scope = scope.outer;
            return scope.arg;
        }

        public Interp.Op getBinding(Value name) {
            Scope scope = this;
            while (scope != null) {
                if (scope.bindings != null) {
                    Interp.Op op = scope.bindings.get(name);
                    if (op != null)
                        return op;
                }
                scope = scope.outer;
            }
            return null;
        }
    }

    public static class Interp {
        private Scope rootScope;

        public Interp(Value input) {
            rootScope = new Scope(null, rootBindings(), input);
        }

        public Value eval(Value expr) {
            return eval(expr, rootScope);
        }

        protected Value eval(final Value expr, final Scope scope) {
            if (expr.isNil())
                return scope.getArg();
            return new LazyValue() {
                protected Value getValue() {
                    return scope.getBinding(expr.getHead()).op(expr.getTail(), scope);
                }
            };
        }

        public interface Op {
            public Value op(Value expr, Scope scope);
        }

        private EnumTrie<Value.Flattened,Interp.Op> rootBindings() {
            Value E3 = Value.NIL;
            Value EE33 = new Value.Pair(E3,E3);
            Value EE3E33 = new Value.Pair(E3,EE33);
            Value EE3E3E33 = new Value.Pair(E3,EE3E33);
            Value EEE333 = new Value.Pair(EE33,E3);
            Value EEE33E33 = new Value.Pair(EE33,EE33);
            Value EEEE3333 = new Value.Pair(EEE333,E3);
            Value EE3EE333 = new Value.Pair(E3,EEE333);
            EnumTrie<Value.Flattened,Interp.Op> rootBindings = new EnumTrie<Value.Flattened,Interp.Op>(Value.Flattened.class);
            rootBindings.put(E3, new QuoteOp());
            rootBindings.put(EE33, new LetOp());
            rootBindings.put(EE3E33, new CdrOp());
            rootBindings.put(EE3E3E33, new IfOp());
            rootBindings.put(EEE333, new CarOp());
            rootBindings.put(EEE33E33, new ConsOp());
            rootBindings.put(EEEE3333, new EvalOp());
            rootBindings.put(EE3EE333, new ConcatOp());
            return rootBindings;
        }

        private class QuoteOp implements Op {
            public Value op(Value arg, Scope scope) {
                return arg;
            }
        }
 
        private class LetOp implements Op {
            public Value op(Value arg, Scope scope) {
                EnumTrie<Value.Flattened,Interp.Op> bindings = new EnumTrie<Value.Flattened,Interp.Op>(Value.Flattened.class);
                Scope letScope = new Scope(scope, bindings, null);
                Value bindingList = arg.getHead();
                while (!bindingList.isNil()) {
                    Value binding = bindingList.getHead();
                    bindingList = bindingList.getTail();
                    bindings.put(binding.getHead(), new DefinedOp(binding.getTail(), letScope));
                }
                return eval(arg.getTail(), letScope);
            }
        }

        private class DefinedOp implements Op {
            private Value body;
            private Scope letScope;

            public DefinedOp(Value body, Scope letScope) {
                this.body = body;
                this.letScope = letScope;
            }

            public Value op(final Value arg, final Scope scope) {
                return eval(body, new Scope(letScope, null, eval(arg, scope)));
            }
        }

        private class CdrOp implements Op {
            public Value op(Value arg, Scope scope) {
                return eval(arg, scope).getTail();
            }
        }
 
        private class IfOp implements Op {
            public Value op(Value arg, Scope scope) {
                if (arg.isNil())
                    return Value.NIL;
                Value body = arg.getTail();
                if (body.isNil())
                    return Value.NIL;
                if (eval(arg.getHead(), scope).isNil())
                    return eval(body.getTail(), scope);
                else
                    return eval(body.getHead(), scope);
            }
        }
 
        private class CarOp implements Op {
            public Value op(Value arg, Scope scope) {
                return eval(arg, scope).getHead();
            }
        }
 
        private class ConsOp implements Op {
            public Value op(Value arg, Scope scope) {
                if (arg.isNil())
                    return Value.NIL;
                return new Value.Pair(eval(arg.getHead(), scope), eval(arg.getTail(), scope));
            }
        }
 
        private class EvalOp implements Op {
            public Value op(Value arg, Scope scope) {
                return eval(eval(arg, scope), scope);
            }
        }
 
        private class ConcatOp implements Op {
            public Value op(Value arg, Scope scope) {
                if (arg.isNil())
                    return Value.NIL;
                Value value = eval(arg.getHead(), scope);
                Value rest = eval(arg.getTail(), scope);
                LinkedList<Boolean> stack = new LinkedList<Boolean>();
                LinkedList<Value> tails = new LinkedList<Value>();
                for (;;) {
                    if (value.isNil())
                        break;
                    Value head = value.getHead();
                    Value tail = value.getTail();
                    if (head.isNil()) {
                        if (tail.isNil())
                            break;
                        stack.push(false);
                        value = tail;
                    } else {
                        stack.push(true);
                        tails.push(tail);
                        value = head;
                    }
                }
                while (!stack.isEmpty()) {
                    if (stack.pop())
                        rest = new Value.Pair(rest, tails.pop());
                    else
                        rest = new Value.Pair(Value.NIL, rest);
                }
                return rest;
            }
        }

        private abstract class LazyValue extends Value {
            private Value value = null;
            protected abstract Value getValue();
            public boolean isNil() {
                if (value == null)
                    value = getValue();
                return value.isNil();
            }

            public Value getHead() {
                if (value == null)
                    value = getValue();
                return value.getHead();
            }

            public Value getTail() {
                if (value == null)
                    value = getValue();
                return value.getTail();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Value expr;
        Value input;
        if (args.length == 0) {
            expr = Value.read(new InputStreamReader(System.in));
            input = Value.NIL;
        } else {
            expr = Value.read(new FileReader(args[0]));
            input = new Value.InputValue(System.in);
        }
        Value.write(new Interp(input).eval(expr), System.out);
        System.out.flush();
    }
}

2010-01-25T00:00:00.000-08:00

I got pulled into optimizing some ancient C code. This was pre-ANSI C. This first thing I found was that there was floating-point function being called repeatedly in some loops with identical arguments, so I added some code near the top of the file that was something like this:


static float floating_point_function_table[20];
static int floating_point_function_table_initialized = 0;

static void init_floating_point_function_table()
{
    int i;
    if (floating_point_function_table_initialized)
        return;
    for (i = 0; i < 20; i++)
        floating_point_function_table[i] = floating_point_function((float) i);
}

When I tried it out, it was a lot faster. After replacing the function_point_function() calls with the table lookups, the loops, which did some other stuff as well, ran in about one sixth the time. But the results were garbage. And I was baffled for at least an hour. The function looked something like this:


float floating_point_function(arg)
  float arg;
{
    ...
}

Since this was ancient code, it was implicitly declared to return int when it was being called in init_floating_point_function_table(), so I moved init_floating_point_function_table() below the definition of floating_point_function(), and it worked.

I also discovered a bunch of loops like this:


    for (i = 0; i < SOME_CONSTANT/SOME_CONSTANT_ARRAY[some_parameter]; i++) ...

in code that stood out when profiling, and declared a new int variable at the top of the function:


    int SOME_CONSTANT_OVER_SOME_CONSTANT_ARRAY_some_parameter;
   SOME_CONSTANT_OVER_SOME_CONSTANT_ARRAY_some_parameter = SOME_CONSTANT/SOME_CONSTANT_ARRAY[some_parameter];

and changed the loops to:


    for (i = 0; i < SOME_CONSTANT_OVER_SOME_CONSTANT_ARRAY_some_parameter; i++) ...

and, surprisingly, even when compiled with full optimization, this change caused this section of code to run in less than half the time.

2010-01-18T00:00:00.000-08:00

Here is 99 bottles of beer in Parenthesis Hell.


((())((((())(()))(()()())(((())))((()()())(((()))((())))(((())()
)(((())(()))((())())(((()))((())))(()()))(()())((())))(()()())((
()())((())))(((())())(())((())(()))((())())((()())((())))(()()))
(()()))(()()))((()((()()(()()()((()(()()(()((()()(((()((()(()()(
()(((()(()()())))))))))))))))))))))(()()())()((()()())(((())))((
()()())(((()))((())))((()()())(((()))((()))((())))((()()())(((()
))((()))((()))((())))((()()())(((()))((()))((()))((()))((())))((
()()())(((()))((()))((()))((()))((()))((())))((()()())(((()))(((
)))((()))((()))((()))((()))((())))((()()())(((()))((()))((()))((
()))((()))((()))((()))((())))(()()()(((()()(())))))()()()(((()()
()()))))()()()((()(((()))))))()()()((()((()())))))()()()((()(()(
())))))()()()((()(()()()))))()()()((()()((())))))()()()((()()(()
()))))()()()((()()()(()))))()()()((()()()()())))((()((()()()((()
((()((((()(((()(()(()((()(((()()(((()(()()()))))))))))))))))))))
)))))(()()())(((())))(((())(()))((())())((()((()()(()()()((()(()
()(()((()()(((()((()(()()(()(((()(()()())))))))))))))))))))))(((
))))(()((()()(()()()((()(()()(()((()()(((()((()(()()(()(((()(()(
)())))))))))))))))))))))(()()))(()()())((()()))((()((()()(()()()
((()(()()(()((()()(((()((()(()()(()(((()(()()())))))))))))))))))
))))(()()))()()((()(((()()((()((((()()(()()()()()()((()((()(()((
()((((()(((()()(()()((()()(()(()))))))))))))))))))))))))))))))))
((()(()()()()((()((()((((()(((()(()(()((()(((()()(((()(()()())))
)))))))))))))))))))))(()()())(((())))(((())(()))((())())((()((()
()(()()()((()(()()(()((()()(((()((()(()()(()(((()(()()()))))))))
)))))))))))))((())))(()((()()(()()()((()(()()(()((()()(((()((()(
()()(()(((()(()()())))))))))))))))))))))(()()))(()()())((()()))(
(()((()()(()()()((()(()()(()((()()(((()((()(()()(()(((()(()()())
))))))))))))))))))))(()()))()()(()()(((()()((()((((()()(()()()()
()()((()((()(()((()((((()(((()()(()()((()()(()(())))))))))))))))
))))))))))))))))((()(((()()((()))))))(()()())(((())))(()()(((()(
)((()))))))(()()())((()()))((()()())(((()))(()()))(()()(((()()((
()))))))()())()()(((()()((()))))))((()((()()()(()()((()((((()(((
()(()()()(((()(()()()((()((()()()((()()(()(()(((()()((()))))))))
)))))))))))))))))))))))((())(()))((())())((()((()()()((()((()(((
(()(((()(()(()((()(((()()(((()(()()()))))))))))))))))))))))))))(
(())(()))((())())(()()()(()()()()()()((()()()(()()((()((((()((((
)(()()()(((()(()()()((()((()()()((()()(()(()))))))))))))))))))))
)))))))((())(()))((())())((()(((()()((())))))))()()()(()()()()()
()((()((((()((()()((()()()(()()()()()()((()()()(()()((()()(()(()
((()()(()(()(((()()(()()))))))))))))))))))))))))))))((()(()()()(
)(()()((()((((()(((()(()()()(((()(()()()((()((()()()((()()(()(()
(((()()((()))))))))))))))))))))))))))))))((())(()))((())())((()(
()()()()((()((()((((()(((()(()(()((()(((()()(((()(()()()))))))))
)))))))))))))))))((())(()))((())())(()()()(()()()()()()((()()()(
()()((()((((()(((()(()()()(((()(()()()((()((()()()((()()(()(()))
)))))))))))))))))))))))))((())(()))((())())((()(((()()((()))))))
)()()()(()()()()()()((()((((()((()()((()()()(()()()()()()((()()(
)(()()((()()(()(()((()()(()(()(((()()(()()))))))))))))))))))))))
))))))((()((()()(()()()((()()(()(()((()()()((()))))))))))))(()()
())((()()))(((())())(((())))((()))(()()))((())())(((()))((())))(
)((((((((())))))))))((()(((()((()()()((()()()(())))))))))((())((
)))((())())((()(()()()()(()()((()((((()(((()(()()()(((()(()()()(
(()((()()()((()()(()(()(((()()((()))))))))))))))))))))))))))))))
)((())(()))((())())(()()()(()()()()()()((()((((()((()(((()()()((
)()()()()()(((()(()()()((()(()()()()((()()(()(()()(()()()()()()(
((()(((()((()()()()(()((()((()()()((()((()()()()(()((()()()()(()
()()()()())))))))))))))))))))))))))))))))))))))))))))))))((())((
)))((())())((()((()()()(()()((()((((()(((()(()()()(((()(()()()((
()((()()()((()()(()(()(((()()((())))))))))))))))))))))))))))))))
)(()()())(((())))((()(((()((()()()((()()(()())))))))))(()((()()(
()()()((()()(()(()((()()()((())))))))))))))(()()())((()()))((()(
((()((()()()((()()(()())))))))))(()((()()(()()()((()()(()(()((()
()()((())))))))))))))()()()(()(((()()()()()(()(()()(()()()(((()(
(()((((()()(()()()()()()(((()(()()()((()((((()()(()()()()()()(((
()(()()()((()(()()()()((()()(()(()()(()()()()()()(((()()((()((((
)(()()()((()((((()(((()()(()()((()()(()(()()(()()()()()()((()()(
)()(()((()(((()()((()()(()()()()(()()()()()()((()()()(()()(((()(
()(()((((()()(()()(()()()()()()(((()()((()((()((((()((()((()(()(
(()()(()(()()(()()()()()()((()((()(()((()((((()(((()()(()()((()(
)(()(()()(()((()()()()(()()()()()()()(((()()(()()(((()()(()()(()
()()()()()((()()()(()()((()((((()(((()(()()()(((()(()()()((()(((
)()()((()()(()(()(((()()((()()(()()()()()()((()((((()((()()((()(
)()(()()()()()()((()()()(()()((()()(()(()((()()(()(()(((()()(()(
)()(()()()()()()((()((((()((()(((()()()(()()()()()()(((()(()()()
((()(()()()()((()()(()(()()(()()()()()()(((()(((()((()()()()(()(
(()((()()()((()((()()()()(()(((()()()()()(()(()())))))))))))))))
))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
))))))))))))))))))))))))))))))))))))))))))((()(((()((()()()((()(
)(()())))))))))((())(()))((())())(()()()(()(((()()()()()(()(()()
(()(()(()()()((()()()()(()((()(()((()((()()(()(()()(()()()()()()
((()((((()((()(((()()((()()(()(()()(()()()()()()((()()(()()()(((
)((((()(((()(((()((()(((()()()(()()()()()()((()()()()(()((()((((
)()((()()(()()()()(()()()()()()(((()()()()()((()()()()(()(((()()
((()(((()()((()()(()()()()()()((()(()()(()(((()(()()()()(()()()(
)()()((()()()()(()(((()()(()()((()((((()(((()(()(()((()(((()()((
()()(()()()()(()((()()()()(()()()()()())))))))))))))))))))))))))
))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
)))))))))))))))))))))))))))))))))))))))((())(()))((())())((()(((
)()()(()()((()((((()(((()(()()()(((()(()()()((()((()()()((()()((
)(()(((()()((()))))))))))))))))))))))))))))))))()()()(()()()()()
()((()((((()((()(((()()()(()()()()()()(((()(()()()((()(()()()()(
(()()(()(()()(()()()()()()(((()(((()((()()()()(()((()((()()()(((
)((()()()()(()(((()()()()()(()(()()()()()(()(()())))))))))))))))
))))))))))))))))))))))))))))))))))))((()(((()((()()))))))((())((
)))((())())((()(((()((()()()((()()()(()))))))))))(()()())(((()))
)((()(((()((()()))))))(()((()()(()()()((()()(()(()((()()()((()))
)))))))))))(()()())((()()))((()(((()((()()))))))(()((()()(()()()
((()()(()(()((()()()((())))))))))))))()))(()(((()((()()))))))()(
((((((((())))))))))((((((((())))))))))

I did not actually write the preceding code. I actually wrote what follows, which looks much more Lisp-like, and ran it through a preprocessor that did symbol and string substitutions.


(((arg   . ())
  (quote . ())
  (let   . (()))
  (cdr   . (()()))
  (if    . (()()()))
  (car   . ((())))
  (cons  . ((())()))
  (eval  . (((()))))
  (concat  . ((())(()))))
 .
 (let ((concat
 . (if (car . arg)
       (if (car car . arg)
    (cons (concat cons (car car . arg) . (cdr . arg))
   . (cdr car . arg))
  . (if (cdr car . arg)
        (cons (quote . ())
       . (concat cons (cdr car . arg) . (cdr . arg)))
      . (cdr . arg)))
     . (cdr . arg)))
       ("digit" . 
 (if arg
     (if (car . arg)
  (if (car car . arg)
      (if (car car car . arg)
   (if (car car car car . arg)
       (if (car car car car car . arg)
    (if (car car car car car car . arg)
        (if (car car car car car car car . arg)
     (if (car car car car car car car car . arg)
         (quote . "9")
       . (quote . "8"))
          . (quote . "7"))
      . (quote . "6"))
         . (quote . "5"))
     . (quote . "4"))
        . (quote . "3"))
    . (quote . "2"))
       . (quote . "1"))
   . (quote . "0")))
       ("count" .
 (if (car . arg)
     (concat cons ("digit" car . arg) . ("digit" cdr . arg))
   . (if (cdr . arg)
  ("digit" cdr . arg)
       . (quote . "no more"))))
       ("Count" .
 (if (car . arg)
     (concat cons ("digit" car . arg) . ("digit" cdr . arg))
   . (if (cdr . arg)
  ("digit" cdr . arg)
       . (quote . "No more"))))
       ("s" .
 (if (car . arg)
     (quote . "s")
   . (if (cdr . arg)
  (if (car cdr . arg)
      (quote . "s")
    . (quote . ""))
       . (quote . "s"))))
       ("bottles" .
 (concat cons ("count" . arg) .
  (concat cons (quote . " bottle") .
   (concat cons ("s" . arg) . (quote . " of beer")))))
       ("Bottles" .
 (concat cons ("Count" . arg) .
  (concat cons (quote . " bottle") .
   (concat cons ("s" . arg) . (quote . " of beer")))))
       ("dec" .
 (if (cdr . arg)
     (cons (car . arg) . (car cdr . arg))
   . (cons (car car . arg) . (quote . (((((((((())))))))))))))
       ("v1" .
 (concat cons ("Bottles" . arg)
  concat cons (quote . " on the wall, ")
  concat cons ("bottles" . arg) .
  (if (car . arg)
      ("v2" "dec" . arg)
    . (if (cdr . arg)
   ("v2" "dec" . arg)
        . (quote . ".
Go to the store and buy some more, 99 bottles of beer on the wall.
")))))
       ("v2" .
 (concat cons (quote . ".
Take one down and pass it around, ")
  concat cons ("bottles" . arg)
  . (quote . " on the wall.

")))
       ("v" .
 (concat cons ("v1" . arg)
  . (if (car . arg)
        ("v" "dec" . arg)
      . (if (cdr . arg)
     ("v" "dec" . arg)
   . (quote . ()))))))
   . ("v" quote . ((((((((((()))))))))) . (((((((((())))))))))))))