It’s a turing tarpit, but one not very complicated at that (for something more esoteric see Malbolge or Whitespace).

The language is very simple, it has eight instructions. So I had to write a compiler for it. It turns out to be quite easy to do:

import static java.lang.System.out;

public class BrainFk
{
    public static void main(String[] args) {
        out.println("public class " + args[0] + "{");
        out.println("public static void main(String args[]) throws Throwable {");
        out.println("int[] memory = new int[30000];");
        out.println("int data = 0;");
        final String code = args[1];
        for(int i = 0; i < code.length(); i++) {
            char c = code.charAt(i);
            switch(c) {
                case '>':
                    out.println("++data;");
                    break;
                case '<':
                    out.println("--data;");
                    break;
                case '+':
                    out.println("++memory[data];");
                    break;
                case '-':
                    out.println("--memory[data];");
                    break;
                case '.':
                    out.println("System.out.print((char)(0xFF & memory[data]));");
                    break;
                case ',':
                    out.println("memory[data] = System.in.read();");
                    break;
                case '[':
                    out.println("while(memory[data] != 0) {");
                    break;
                case ']':
                    out.println("}");
                    break;
            }
        }
        out.println("}}");
    }
}

You can use it to compile the hello world sample from the Wikipedia page:

~>java BrainFk Hello "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>." > Hello.java
~>javac Hello.java
~>java Hello
Hello World!

Sometime I’ll have to post the Forth interpreter in Java I wrote (I know some might consider sacrilege to use both languages in the same sentence, but you can’t please everyone!).

I remebered reading an article about the types of issues when downsampling an image (and specifically a difficult one). After a few tests, I settled for a gaussian pre-blur.

I think I got pretty good results:

Go to the original article to get the source image.

The code also tries to fit and center the image in the target. That means it will return an image with the exact size you request. It will center and rescale the source image and leav transparent background for filler space.

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.*;
import java.io.File;
import java.io.IOException;

public class FitImage {

    public static BufferedImage fitImage(final BufferedImage input, final int width, final int height) {
        final int inputWidth = input.getWidth();
        final int inputHeight = input.getHeight();

        final double hScale = width/(double)inputWidth;
        final double vScale = height/(double)inputHeight;

        final double scaleFactor = Math.min(hScale, vScale);

        //Create a temp image
        final BufferedImage temp = new BufferedImage(inputWidth,inputHeight, BufferedImage.TYPE_INT_ARGB);

        if(scaleFactor < 1) {
            //Create a gaussian kernel with a raduis proportional to the scale factor and convolve it with the image
            final Kernel kernel = make2DKernel((float) (1 / scaleFactor));
            final BufferedImageOp op = new ConvolveOp(kernel);
            op.filter(input, temp);
        } else {
            temp.createGraphics().drawImage(input, null, 0,0);
        }

        final BufferedImage output = new BufferedImage(width,height, BufferedImage.TYPE_INT_ARGB);
        final Graphics2D g = output.createGraphics();
        g.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        g.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
        g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        final int xOffset = (int) Math.max(0, (width - inputWidth * scaleFactor) / 2);
        final int yOffset = (int) Math.max(0, (height - inputHeight * scaleFactor) / 2);
        final AffineTransform scaleInstance = AffineTransform.getScaleInstance(scaleFactor, scaleFactor);
        final AffineTransformOp transformOp = new AffineTransformOp(scaleInstance, AffineTransformOp.TYPE_BICUBIC);
        g.drawImage(temp, transformOp, xOffset, yOffset);
        return output;
    }

    public static Kernel make2DKernel(float radius) {
        final int r = (int)Math.ceil(radius);
        final int size = r*2+1;
        float standardDeviation = radius/3; //Guess a standard dev from the radius

        final float center = (float) (size/2);
        float sigmaSquared = standardDeviation * standardDeviation;

        final float[] coeffs = new float[size*size];

        for(int x = 0; x < size; x++ ) {
            for(int y = 0; y < size; y++ ) {
                double distFromCenterSquared = ( x - center ) * (x - center ) + ( y - center ) * ( y - center );
                double baseEexponential = Math.pow( Math.E, -distFromCenterSquared / ( 2.0f * sigmaSquared ) );
                coeffs[y*size+x]= (float) (baseEexponential / (2.0f*Math.PI*sigmaSquared ));
            }
        }

        return new Kernel(size, size, coeffs);
    }

    public static void main(String[] args)
            throws IOException
    {
        BufferedImage out = fitImage(ImageIO.read(new File("Rings1.gif")), 200, 200);
        ImageIO.write(out, "png", new File("test.png"));
    }

}

 Writing multithreaded code is like juggling chainsaws; amazing when it works and truly sucky when it doesn’t.

Truly summarizes the feeling when you’ve had to deal with a multithreaded system. He argues that probably one of the most difficult thing to achieve is “avoiding doing nothing”. I agree with his thoughts in the sense that if you are even considering multithreading something, you are trying to achieve maximum utilization (i.e. not wasting resources). But I’m not sure that getting maximum utilization is the hardest part by itself.

Besides the usual problems, like avoiding deadlocks or protecting shared data, I always found that the hardest part was, to paraphrase Andrew, “avoid doing something”.

What I mean is that in multithreaded applications (it also applies to distributed applications), probably the hardest part is coming up with ways to avoid needing synchronization.

At least in my experience, figuring out ways to make the system exhibit consistent and predictable behavior without relying on atomicity, has always been the part that most of the design effort is invested in, and if done properly, where the greatest gains in scalability is achieved.

Take for example the Google File System, a massive, multi-petabyte storage filesystem. It is designed to work on clusters of several thousand machines, distibuted across several datacenters (even on different countries).

To achieve the expected performance, they had to throw away the usual file semantics, and think completely out-of-the box. But don’t take my word for it, go, fetch the paper (if you haven’t already done so), and read it yourself.

After reading it, I began doing a small implementation in Java (quite ugly, btw), and I was astonished by the possibilities. So quite naturally (being the geek I am), I started toying with the idea of implementing a set of extensions for Java.

In this and other posts, I’ll try to make an introduction to the basic idea. Note that I will probably change existing posts quite often to correct mistakes or ommissions. In this post I’ll focus on an overview of the basic idea, in a future post I’ll address composition of transactions (the C in CMT), static checking for side effects, and alternatives to implement the runtime part of this. If you’re really curious, I recommend reading the original paper.

The gist of the idea is to replace common locking based semantics with in-memory transactions, so instead of writing complex locking semantics, you rely on optimistic locking handled by the runtime.

The following example shows how a producer-consumer problem can be solved with a queue of fixed size using Java with CMT:

public class BufferedQueue {
    private LinkedList list;
    public BufferedQueue() {
        list = new LinkedList();
    }
    public Object consume() {
        Object value;
        atomic {
            if(list.isEmpty()) {
                retry;
            }
            value = list.removeFirst();
        }
        return value;
    }
    public void produce(Object value) {
        atomic {
            if(list.size() > 10) {
                retry;
            }
            list.add(value);
        }
    }
    public Object peek() {
        Object value;
        atomic {
            if(list.isEmpty()) {
                retry;
            }
            value = list.getFirst();
        } else {
            value = null;
        }
        return value;
    }
}

Take a look at two keywords: atomic and retry

The atomic keyword demarcates a transaction. That means that this block is all-or-nothing (well get to the else later). For example let’s take a closer look at the consume method.

public Object consume() {
    Object value;
    atomic {
        if(list.isEmpty()) {
            retry;
        }
        value = list.removeFirst();
    }
    return value;
}

The atomic statement starts a transaction. In this transaction we first check to see if the list is empty. If it is, we issue a retry statement.
The retry statement, rolls-back all changes and suspends the transaction until at least one of the fields used in the block (either directly or indirectly) is modified by another transaction committing. When this happens, the execution is restarted in a new transaction at the beginning of the enclosing atomic block.
If this time the list is not empty, the first element is removed from the list, and the transaction is committed. If at the time of the commit there is a conflict with another transaction, the execution is rolled back and retried.

Note that it is very important that the atomic blocks do not have side-effects (such as creating files, etc.) outside of the control of the transaction manager.

(to be continued…)

So here I am, joining this campaign by posting this entry in protest! Apple, please don’t let us down!