You will note that its essence is 5 lines of code. Again, I await your Java solution
You think this is nitpicking? First, it has *nothing* at all to do with OOA/OOD and neither does Java for that matter. I only just had a whinge recently about passing under-qualified comment and the topic was “OO” (how about that?), so I best refrain for now for my own sanity. Interestingly, Wadler’s type-classes came up in that discussion; have you heard of them before? I find that they are a good place to start a discussion and meaningful critique of OO. Certainly, Java and its offensive type system isn’t.

Good luck with that Levenshtein Distance without laziness!!

I think you want to open Wikipedia at “dynamic programming”.

“dynamic programming algorithm” != “an algorithm written in a dynamic programming language”

If you’re really talking about dynamic programming algorithms, then I’d like you to cite at least of the famous DP algo that would be problematic to write in Java…

DP algorithms like 0-1 Knapsack and Levenhstein have been known as “dynamic programming” since decades. So I think “dynamic programming algorithm” doesn’t mean what you think it means.

Besides that your blog is interesting but it’s all hair-splitting at the 3GL level. Anyone at least half interested in OOA/OOD can only but laugh at all this nitpicking.

public final class Test {
    private static final MyBool TRUE;
    private static final MyBool FALSE;
    private static final MyBool BOTTOM;

    static {
        TRUE = new MyBool() {
            public boolean myBool() {
                return true;
            }
        };

        FALSE = new MyBool() {
            public boolean myBool() {
                return false;
            }
        };

        BOTTOM = new MyBool() {
            public boolean myBool() {
                throw new Error();
            }
        };
    }

    public static void main(String[] args) {
        System.out.println(and(TRUE, TRUE));
        System.out.println(and(FALSE, TRUE));
        System.out.println(and(FALSE, BOTTOM));
    }

    static boolean and(MyBool b, MyBool c) {
        if (b.myBool()) {
            return c.myBool() ? true : false;
        } else {
            return false;
        }
    }

    private interface MyBool {
        boolean myBool();
    }
}

As Tony pointed out to me, you can rename MyBool to Thunk and add a type parameter (which in this case would be Boolean).

You could write your own && in Java, but it would be called with lambdas rather than the same way && is. Here’s a sample call:

boolean b=myAnd(new Lazyb()
{
    public boolean invoke()
    {
        return false;
    }
},new Lazyb()
{
    public boolean invoke()
    {
        throw new Error();
    }
});

or, in the hypothetical Java 7:

boolean b=myAnd({=>false},{=>throw new Error()});

__bool and(lazy bool b, lazy bool c) { return b && c; }

Or a slightly more powerful version

__// takes an arbitrary number of lazy arguments
__bool and(bool delegate()[] dgs…) {
____assert(dgs.length);
____foreach (dg; dgs) if (!dg()) return false;
____return true;
__}
(The underscores are just indentation)

We can demonstrate that it works by means of the following example:

__import std.stdio;
__bool bottom() {
____throw new Exception(”You hit rock bottom”);
__}
__void main() { writefln(and(false, bottom)); }

which, correctly, outputs “false”.

I’d like to see you expand this further by mentioning imperative programming and how this can be used to describe more precise or perhaps more intricate imperative knowledge. Doing so would tie up the last discussion we had nicely and also be a good way to introduce really powerful control structures like continuations - think about it.

( note you could have explained the + equivalence with a nice recursion.)

Apart from that, thanks for bringing up an important point.