palindrome(X) :-
  reverse(X,X).

It reverses the list, then checks if the result is the same as the original (that’s the definition of a palindrome). It checks that by going through both lists and comparing elements at corresponding positions.

What’s ugly about this is that this is at least twice as many comparisons as needed. Since we know one list is the reverse of the other, it suffices to compare the first half of one to the last half of the other. (In lists of odd length, the center element does not to be compared at all, since it is always identical to itself.)

Alternatively, we could just traverse the list to check, carrying along a reversed version of what we have traversed so far, stop in the middle and then compare the reversed first half to the remainder (i.e. to the last half). The problem is: where to stop? We don’t know the length of the list until we have traversed the whole of it, hence we also don’t know what half is length is.

Enter the intriguing solution that was given on the Haskell Wiki, humbly titled “Here’s one that does half as many compares”, and that gave me a very nice lightbulb moment when I had gotten my head around it. Here’s my Prolog translation:

palindrome(List) :-
  palindrome(List,[],List).

palindrome([First|Rest],Rev,[_,_|Rest2]) :-
  palindrome(Rest,[First|Rev],Rest2).
palindrome([_|Rev],Rev,[_]).
palindrome(Rev,Rev,[]).

The trick is to carry along a second copy of the original list, popping two elements from it every time we pop one from the main copy. This way, when we reach the end of the second copy, we know we have reached the center of the first. There’s two recursion-ending clauses, one for odd-length and one for even-length lists. Ingenious!

No related posts.

No related posts.

• The new Twitter takes the “eventually consistent” principle of NoSQL very seriously: the data displayed is consistent on Judgement Day.

March

• “We cannot predict whether such a query will timeout every time. This will be learned heuristically between keyboard and chair.”
• Switched another web forum over from Latin-1 to UTF-8. The world is now a better place.

Apr

• “We identified a tweak to the algorithm to prevent generation of swastika-like identicons.” http://bit.ly/jJsMgY

May

• Funny how ”foreign” in Prolog and “native” in Java mean very similar things.
• Nutzen von grafischen Tracern, Folge 121: Ein System kennenlernen, um einen grafischen Tracer dafür zu schreiben.

June

• Duh, git users, Subversion has a “staging area” too. It’s called working directory. You’re welcome.
• Wort des Tages: Commitsau
• Heute: Race conditions.

August

• Eine Hochleistungs-Rechenanlage in Stanford hat angeblich einen String gefunden, der kein gültiges Perl-Programm ist.

September

• Vom Push-Paradigma zum Pull-Paradigma gewechselt, Tag gerettet.
• Yay worst practices.
• There’s no StackOverflowError that some randomly added System.out.println can’t fix. #Heisenbug #WTF #Java

October

• “It’s not botchy, it’s *modular*!”
• xmllint is delusional, it thinks it’s cat.
• “This will be done manually and annually.”
• Of all the possible ways to represent a pair in #Prolog, (A, B) is probably the most braindead one. Especially if functor(B, (,), 2).
• You know your bug tracking workflow is broken when Google Alerts is part of it.
• The best things in life start with cat $file |
• 11 AM: type ‘pos_tags = ‘. 11:01 AM – 5:59 PM: read Ajax/jQuery introductions. 6:00 PM: hit backspace 11 times.
• Nicht testen. Denken!
• Immer wieder ernüchternd, wie weit „gut funktionierende Klasse“ von „gut funktionierende und erweiterbare Klasse“ entfernt ist. #OOP
• Class names ending in “Helper”: not helping as far as understanding is concerned.
• “Have you ever felt like you needed to be rewritten?”

November

• Heute: Deadlocks.
• Si creavisses minimum exemplum, non quaesivisses.
• Removed one if (…) { throw …; } – and so there was a new feature.
• Curse you, 80/20 rule in UI design.
• }]); #BeautifulLinesOfCode
• Word of the day: errput (the data a program sends to STDERR)
• Nu nog even lekker formatteren.
• And this is where I fire up Eclipse to experimentally learn yet another fact about Java.
• Wenn schon böser CSS-Hack, dann ruhig pixelgenau.

December

• seize.sh: mv $1 $1.bk; cp $1.bk $1; rm $1.bk
• Welche Programmiersprache hat eigentlich diese Seuche „Ausrufezeichen als Negationsoperator“ eingeführt? Warum nicht gleich das Leerzeichen?
• The one and only major version number: 0. The one and only development environment: production.

Related posts:

1. Translating with Semantic Representations

$(OUT)%/en.tok.corr : $(OUT)%/en.tok $(OUT)%/en.tok.db ${PYTHON}/correct_tokenization.py
	${PYTHON}/correct_tokenization.py $> $@

$(OUT)%/en.tok.db :
	touch -t $$(${PYTHON}/latest_correction.py $@) $@

But how can I force make to apply that second rule every time? We need to know if there are new corrections in the database, after all. My first idea was to declare the target $(OUT)%/en.tok.db phony by making it a prerequisite of the special target .PHONY, but that doesn’t work since the % wildcard is apparently only interpreted in rules whose target contains it. Thanks to this post by James T. Kim, I found a solution: instead of declaring $(OUT)%/en.tok.db phony itself, just make it depend on an explicit phony dummy target:

$(OUT)%/en.tok.db : dummy
	touch -t $$(${PYTHON}/latest_correction.py $@) $@

.PHONY : dummy

Related posts:

1. Simplify
2. Porter Stemmer for German in Python
3. CDU-Politiker

Another lesson learned: Do use the first DVD to install Debian, it contains a whole lot of very useful things such as network-manager-gnome or synaptic that are not included with the CD and that are a hassle to install one by one. And there’s also a new unanswered question: why did the i386 DVD install an amd64 kernel?

Related posts:

1. text/html decoder

<deep portentous voice used for film trailers>When the fight for internationalisation hots up, mild mannered web developer Martin Sammtleben becomes Unicode Man, defender of diacritics, champion of challenging codepoints. Faced with an ASCII-fixated enemy, Unicode Man must free the badly programmed text engines of the world of their inability to implement international standards before all are assimilated by their failure to put the right glyph in the right place</deep portentous voice used for film trailers>

Related posts:

1. Zwiebelfischchen

Anonymous classes

These are fairly well-known, so let’s go for a freaky example – an anonymous class declaration within the head of a (labeled!) for loop:

sentence : for (List children :
        node.getOrderedChildrenBySpan(
        sentence.getOrderedTerminals(), new Test() {

	@Override
	public boolean test(Node object) {
		return false;
	}

})) {
	for (Node child : children) {
		String tag = child.getLabel().getTag();

		if (tag.contains("-SBJ")) {
			break sentence;
		}

		tags.add(PTBUtil.pureTag(child));
	}
}

Enums

Boring, I know. I’m mentioning them here for completeness because I found out about them rather late and was like, hey, cool, that’s much nicer and cleaner than working with explicit integer constants.

public enum EditOperationType {

	DELETE, INSERT, SWAP, MATCH;

	@Override
	public String toString() {
		switch(this) {
		case DELETE:
			return "delete";
		case INSERT:
			return "insert";
		case SWAP:
			return "swap";
		default:
			return "match";
		}
	}

}

Generic methods

Luckily, the following code is no longer live.

@SuppressWarnings("unchecked")
public  T retrieve(
        Class type, int id) {
    return (T) getStoreForType(type).retrieve(id);
}}

Instance initializers

I know I discovered these once thinking I needed a constructor in an anonymous class and wondering how to do this, because how would one declare a constructor in a class without a name? It did not remain in my workspace, however, and I never used an instance initializer again. In the case of anonymous classes, I tend to use final variables outside of the anonymous class, or derive them from classes whose constructors already handle everything I need. So I’m pulling an example from someone else’s code:

_result = new ContainerBlock() {
    {
        setPanel(_panel);
        setLayout(LayoutFactory.getInstance()
                .getReentrancyLayout());
        addChild(unboundVarLabel);
    }
};

Multiple type bounds

public abstract class IncrementalComparator<
        T extends HasSize & HasID> {
    // ...
}

I wonder what’s next.

Related posts:

1. LaTeX, PSTricks, pdfTeX and Kile

“Navigational” elements like application launchers and overviews over active applications have no business being full-screen monsters by default, as is the case with Mission Control in Mac OS X or with the Activities view in GNOME Shell. There’s nothing wrong with traditional panels and menus. Make them as lean as possible while staying intuitive. I think Windows (with the task bar in Windows 7) and Ubuntu (with the launcher in Unity) are on the right track by adopting the design pioneered by Mac OS X’s dock: frequently used and currently open applications are in the same place. This may first seem dubious conceptually, but it makes more and more sense as applications are becoming more and more state-persisting.

No desktop! When the traditional desktop metaphor dies, make sure the desktop dies with it. Sadly, no major desktop environment seems to be tackling this. The desktop is sort of like a window, but can only be shown by moving all windows out of the way. It lacks a clearly defined purpose and tends to clutter up one way or the other. Get rid of it!

Go tiling! Now that there’s no desktop before which windows can float, windows should float no more. What overstrains users’ (read: my) minds is not more than one window visible at a time. On the contrary, there are many tasks that require working with two applications simultaneously. What annoys users (read: me) is having to arrange windows themselves. Full-screen is a nice feature that moves and resizes one window so that it occupies the whole available screen space. I want that for two or more windows! They should always be arranged automatically to use the screen space optimally. The answer to this plea is tiling window managers, here’s one in action:

A tiling window manager with four windows open and one panel (screenshot by Jonathas Rodrigues)

Current tiling window managers are for technical users willing to do quite some configuration before it works, do a hell of a lot of configuration before everything works nicely, and memorize a lot of keyboard commands. So far all of this has been putting me off going tiling. There is no reason why it should stay that way. Complex GUIs like those of Photoshop or Eclipse already consist of multiple “subwindows” called views that can be rearranged, docked, undocked, grouped etc. freely using the mouse. The same principle could be applied to the whole desktop, for example in a Linux distribution that makes sure there’s a decent set of standard configuration settings, and that special things like indicator applets and input methods work as we’re used to from the traditional GNOME desktop. Monbuntu, anyone?

Related posts:

1. Developments in Desktop Environments, Part 1: The Awkward Present
2. Dekorativ, aber nicht funktional (2)

Windows 95 with two open windows, task bar and start menu (screenshot by Microsoft)

Always-visible gadgets like “task bars”, “docks” and “menu bars” were introduced for basic tasks like managing open windows and opening new ones.

It took for the advent of super-user-friendly mobile devices (limited multitasking ability, limited screen space) for developers to notice that unlike modern desktop computers, people aren’t actually very good at multitasking. At least for the tasks they do with mobile devices, people are perfectly happy with only having one window, or menu, open at a time.

The new Mac OS X Launchpad (screenshot by Apple)

This trend is now coming to the desktop computer. Apple recently announced a new release of Mac OS X, explicitly stating that many of the new features are inspired by the iPhone and the iPad. The most striking one is Launchpad. It is nothing more than a menu of all available applications, but one that takes up the whole screen. Together with Dashboard and Exposé (now called Mission Control), that’s quite a long list of special-purpose full-screen gadgets taking over window managing/application launching functions traditionally fulfilled by task bars etc. And together with Mac OS X’s new full-screen apps (not quite your traditional maximized windows), it quite clearly marks a turn toward a one-window-is-visible-at-a-time principle.

The Activities view of GNOME Shell (screenshot by DanieVDM)

A similar thing is going on in GNOME Shell. They are cramming everything for which there used to be panels and menus into one full-screen view called Activities, including Exposé-like overviews of the desktop(s). If the multitude of full-screen gadgets in Mac OS X seems confusing, the GNOME approach of cramming so many things into one full-screen view seems bizarre. If upon clicking a button with the ultimate goal of, say, firing up the calculator, the contents of the whole screen change and hide my currently open windows, I consider this a high price to pay. In return, there should at least be a gain in focus, as with the Mac OS X gadgets, each of which shows more or less one kind of thing only.

So what is a desktop environment developer to do if she really wants to advance the state of the art instead of just haphazardly introducing new misfeatures (or taking it slow with moving away from the traditional desktop metaphor, as Microsoft does)? Is there a happy medium between overview and focus? Bear with me for Part 2: The Glorious Future.

Related posts:

1. Developments in Desktop Environments, Part 2: The Glorious Future
2. Dekorativ, aber nicht funktional (2)
3. Kleine Bilderode an den Kaffee

Prompted by this page.

Keywords: Firefox, Ubuntu Firefox Modifications, ubufox, WTF.

Related posts:

1. Tag stripper/text ripper
2. Ich lobe Adobe