For my diploma thesis, I use a simple continuous integration system. It doesn’t keep logs except mailing me, but it works fine for the simple one-person setup I have.

Wer baggert da so spät noch am Baggerloch?

Advantages:

• Makes sure my project can be checked out from SVN and then “just works” using Ant.
  • …so everything is checked into SVN.
  • …it builds using Ant (I usually use Eclipse)
  • …there are no rogue dependencies from production code to test.¹
  • …and it’s harder for me to forget how to setup the project, of course.

How to do it:

• Create a new SVN checkout (Git clone, Perforce Client, …) into a directory named continuous_build or similar.
• In this directory, create a shell script like the one shown below.
• To your (user) crontab, add the line 00,15,30,45 * * * * cd /home/guenther/continuous_build/ && sh continuous_integration.sh. (Note that crontab automatically sends the script’s output to the user via email.)

Update: I just couldn’t resist to hack this together as well: Have a look at the new build status indicator on my diploma thesis homepage. (Click, if you’re in the university subnet.)

Here’s the source code for continuous_integration.sh:

#!/bin/sh
# Run from same directory!

# JSR 308
export JSR308=`pwd`/jsr308

echo "================================="
echo "  Configuration"
echo "================================="
echo "JSR308   : $JSR308"
echo "JAVA_HOME: $JAVA_HOME"
echo "PATH     : $PATH"

echo "================================="
echo "  SVN Update"
echo "================================="
svn up

cd jsr308/checkers

echo "================================="
echo "  Clean"
echo "================================="
ant clean

echo "================================="
echo "  Build"
echo "================================="

if ant all-tests; then
    echo "WIN"
    DISPLAY=":0.0" xsetroot -solid black
else
    echo "FAIL"
    DISPLAY=":0.0" xsetroot -solid red
    killall rhythmbox
    mplayer -really-quiet /usr/share/sounds/ubuntu/stereo/dialog-error.ogg > /dev/null 2> /dev/null
fi

Insert whatever it needs to draw your attention in the “fail” block.

Footnotes
¹ I regularly fall for this one. Eclipse doesn’t check it, and sometimes I just forget to hit Ctrl-Shift-O after cleaning up.

I’m happy to announce that the Grr RSS Reader application is now part of the GNUstep Application Project (GAP).

Grr running on the Letux 400 netbook. -- Image shamelessly copied from Riccardo Mottola's weblog (Click!)

Riccardo Mottola’s announcement: http://multixden.blogspot.com/2009/10/grr-rss-to-go-on-gnustep.html

A great introduction to garbage collectors: “Storage Management, cont’d” (Paul Hilfinger). It was fun to figure out how to implement this. Just a short link, I didn’t want this to get lost in my twitter stream.

More links:

• Course Homepage (University of Berkeley, CS61B)
• Podcast (Get lecture 41.)

Lessons learned: My first C program with a void***. Should have used more unions. Just about 200 lines of C, a working stop-and-copy garbage collector. A fun hack, but hard to test. It’s probably buggy.

This is a handy trick to see whether you’re in a directory managed by version control or not.

To enable this prompt, I use the following code snippet (in my .bashrc file):

pimpmyprompt() {
  if test -d `pwd`/.svn ; then
    pwd | sed -e "s#^$HOME/*# #" -e "s#/.*\$##"
  fi
}

export PS1="\u\e[0;32m\$(pimpmyprompt)\e[m:\w$ "

Note: This will always print the name of the first path component after $HOME, which is not necessarily a SVN working copy.

Update: Also have a look at Frank’s hint in the comments, which looks quite useful for when the customizations start to grow.

Here’s a neat trick with htaccess files: The page on my diploma thesis should be available to everyone within my university subnet, and to selected people from outside, who may authenticate using usernames and passwords.

This .htaccess file seems to work for it:

AuthUserFile "/home/guenther/htpasswd"
AuthName "Only visible from the TU Kaiserslautern subnet or with username (ask me for it)"
AuthType Basic

Satisfy any

order deny,allow
deny from all
allow from 131.246.

Require valid-user

From the outside, you’re asked for a password, from inside the subnet, you can see it without password. Works.

Ralph Johnson (Yes, from the Gang of Four) writes in “Comment on a comment on 4+1 views”:

“The book Documenting Software Architectures: Views and Beyond is a great source of ideas for different viewpoints. If you take the book literally, however, you’ll write bloated documentation. So, don’t take it literally. Use it to jog your creativity. It is the only book on software architecture documentation that I know of, hence the best.”

Yes, this sounds obvious. Too obvious to mention, you think? I don’t think so. Take a look at the secondary literature that references this book and judge for yourself. (I won’t publicly speak bad of people, so there’s no link. Come ask me.)

Example: The aforementioned SEI book on architectural documentation says in its preface (p xxvi):

“The goal of this book is to help you decide what information about an architecture is important and to provide guidelines, notations and examples to capturing it.”

So actually, the intent was not actually to make strict rules for creating documentation. It’s a pity that the chapters with the actual documentation strategies mostly forget to remind you of that.

Software Craftsmanship: While sounding really nice at first glance, I really don’t see where to draw the boundary between a software craftsman and anyone else working in the industry. Of course the things listed in the Software Craftsmanship Manifesto (“Not only X, but also Y.”) are all good things ™. However, improving on one thing always comes at the price of getting worse at something else. So at what cost does it come? I like the wording of the Agile manifesto much more (“We value X over Y.”). I’m not surprised that the whole Software Craftsmanship idea is so vague and romaticized.

via Heise: Tom DeMarco questions the idea of Software Engineering:

My early metrics book, Controlling Software Projects: Management, Measurement, and Estimation (Prentice Hall/Yourdon Press, 1982), played a role in the way many budding software engineers quantified work and planned their projects. In my reflective mood, I’m wondering, was its advice correct at the time, is it still relevant, and do I still believe that metrics are a must for any successful software development effort? My answers are no, no, and no.

In your face, quoters of “You can’t control what you can’t meaure”!

http://www2.computer.org/cms/Computer.org/ComputingNow/homepage/2009/0709/rW_SO_Viewpoints.pdf

Also see “Software Engineering ist eine Idee, deren Zeit gekommen und auch wieder gegangen ist.” (in german). This is an interview with Tom DeMarco where he says basically the same.

An interesting read.

Yes, I do like Test Driven Development. It works for me.

What doesn’t work for me are articles like this one by Tim Bray¹, or rather their endless number of contradicting comments on what TDD and its properties are. You think you know what TDD is? Time to meet an infinite number of monkeys who have understood it in a completely different way. Or haven’t they?

Some random opinions (with remarks by me):

• If your tests are too hard to make, you know that your API is too complicated. [link]
• TDD doesn’t make sense in small projects. [link]
• Never use mocks unless you’re sure their interface is absolutely stable. [link]
• TDD doesn’t help when people don’t do it properly. It’s hard to introduce tests when the code base grew too large without them. This is a major weakness in the TDD philosophy. [link]
• TDD is too expensive. We have had code rot in our automated tests. [link] (When doing TDD, I usually run tests about ten times in each commit cycle. How can your test code rot?)
• Don’t fall for the seductive TDD trap! In practice, everybody hates it, even if they first thought they liked it. TDD sucks away your soul and desire. [link] (I’m not paraphrasing this last sentence.)
• TDD is inpractical for anything above bowling card calculators and stacks. [link] (Note to self: I’m waiting for the blog post explaining this on this weblog.)
• This is not TDD. TDD is Test Driven *Design*. [link] (Hey, why don’t you get a copy of the Test Driven Development by Example book?)
• My tests are often copied from the REPL that I use anyway for my exploratory coding. It doesn’t feel hard to me to write them. [link]

I like the comment about the REPL. This is an observation that I also made. However, would it help if C++ had a REPL? :->

I cannot escape the feeling that these commenters come from very different backgrounds. Who can I trust there? Whose background is closest to mine? Can these comments help anyone without this context information at all?

Or am I maybe just naive to assume I could learn something from discussions on the internet? NO, don’t comment on this yet! I just realized that I probably am. Never mind. I go read TDD by Example again, that’ll help me more.

¹Wow, this guy even has his own Wikipedia article. I didn’t know him before, though, and I also can’t tell you who it is. Everything looks important when you got the link from the Delicious social bookmarking service’s home page.

A few images from the last weeks. The Bavaria at the Theresienwiese is very large and can be climbed up. I sat in her head together with two other people and looked out.

I also saw the surfers in the English Garden, Anne!

Update: Solution posted, see below.

The visitor pattern allows to structure programs in conventional OO languages such that a method implementation is chosen based on the type of two arguments instead of just the receiver of a message (a.k.a. the object which a method is called on).

In one of the exercises to the “advanced aspects of OO programming” class, we had to write a little program with an “Expression” hierarchy and an expression-evaluating visitor class, just like in this illustration:

The solution to this exercise as presented to us was to keep track of the current ongoing evaluation in the visitor by using a stack. So, each visit method looked something like this:

def visitMul(mulExp)
  mulExp.leftSubExpression.accept(self)
  mulExp.rightSubExpression.accept(self)
  @stack.push(@stack.pop(), @stack.pop())
end

The important invariant is: When accept or one of the visit methods are called for an expression instance, the overall effect is pushing the result of that expression’s evaluation onto the stack. Consequently, by using accept recursively, the subexpressions’ values can be popped from the stack afterwards.

That solution is not very elegant. There’s a variation of the visitor pattern that solves the problem without using an explicit stack. Can you guess how it works?

Update: For the solution, see the third comment.

Update: Here’s quite a prominent example where this is used: TreeVisitor in the javac compiler.

Morning in Munich

Fantastic weather for bicycling to one of the parks. More photos are about to come soon. Be prepared!

Best wishes from Munich!

Warning: This article may contain trace amounts of three different programming languages, compiler internals, object oriented method dispatchers, bitwise binary arithmetic on pointer variables and term rewriting systems (which are cool).

Update: To put this first, dispatching strategies similar to the one proposed here have been taken into account in the implementation of Pragmatic Smalltalk / the Etoile LanguageKit. The current implementation that inlines parts of the dispatch into the message sending (calling) method, was chosen to allow for very fast number computations and indeed performs very good in that aspect when compared to other scripting languages. Seen from the “mathematical operation performance” perspective, the decision is very reasonable.

The implementation of programming languages can probably be considered a comparably mature field. For a few months now, I was exceptionally lucky to have the possibility to follow the development of such a language implementation from the first row. During the development of David’s LanguageKit framework (and the accompanying Pragmatic Smalltalk language), there’s one specific design lesson that I believe to be very important:

Every piece of functionality can be implemented on very different levels of abstraction. Think carefully where it belongs.

An example: In Smalltalk implementations, ifTrue: messages to objects aren’t dispatched but simply converted into a simple conditional branch on assembler or bytecode level. The straightforward way to implement this would be to change the code that generates byte code message sends[1] and make it produce a conditional branch instead.

However, LanguageKit takes a much more elegant (imho) solution there, which decouples the implementation of message sends from its optimization. Before a program’s AST is converted into byte code, special optimizations can be done on the AST. An optimization on the AST is similar to a term rewriting rule[2]: When a specific kind of AST node is encountered in the AST, it can be replaced by whatever other AST node the rule likes. So, the LowerIfTrue rule can be loaded into the compiler, which replaces LKMessageSend nodes with LKIfStatement nodes if the message send nodes send ifTrue:-like messages.

So this basically changed LanguageKit in such a way that:

• The code on byte code generation level can stay very straightforward and clear. No exceptions and corner cases for ifTrue: and friends there.
• There’s a mechanism for pluggable rules (“LKPlugins”) which change the AST and in which terms the ifTrue: optimization is implemented.
• Minor drawback: LanguageKit needs to support the additional LKIfStatement AST node, which is otherwise not required for Smalltalk.
• Big advantage: The ifTrue: optimization is now implemented in terms of an AST transformation. This way, you don’t need to understand the internals of the specific byte code language. (Maintainability!)

Just like in this example, it looks to me that it’s a general design principle that you should implement things on the highest abstraction level possible. In dynamic languages like Pragmatic Smalltalk and Objective-C, this is ultimately even outside the actual compiler: In the runtime system. (Note that Objective-C’s objc_msg_sendv is implemented in its runtime, not in the compiler.)

In that respect, I’m still not entirely happy with CodeGenLexicalScope::MessageSend in LanguageKit: It’s a design philosophy of Pragmatic Smalltalk to use the Objective-C runtime and become a “native citizen” there. So it’s obviously a good idea to call the Objective-C method dispatcher. However, unlike Objective-C, everything is an object in Pragmatic Smalltalk, including integers, leading to the usual dynamic language small-integer pointer hackery[3]. Because of this, extra caution must be applied to avoid sending Objective-C messages to small integers via the objc_msg_sendv. To be more precise, it needs to be checked whether that’s the case. If the receiver is a small int, a specific different type of dispatch is done.

I don’t understand much about LLVM, but looking at CodeGenLexicalScope::MessageSend (I assume you now also take a look at it), I’d guess that this can be implemented more elegantly by simply calling a specifically written pragmaticst_msg_sendv dispatcher, which is written in plain old C and relies on objc_msg_sendv in the generic case. This way, there wouldn’t be so many basic blocks (so many generated byte code operations) everytime a Pragmatic Smalltalk program calls a method => pragmaticst_msg_sendv can stay in cache much longer than these basic blocks, less generated code. But the biggest advantage to me is, it’s understandable without understanding LLVM. (Maintainability!)

The dispatch process would then be explicitly two-staged. However, looking at the current implementation, it currently is two-staged anyway. (This becomes clear if you refactor the generated byte code out into a dispatch function (in your head ).) The basic observation is, Pragmatic Smalltalk can’t live directly in the Objective-C runtime, there has to be a wrapped-around dispatch mechanism which handles small integers. (It doesn’t matter if you call it like this or not.)

An additional benefit would be the following: pragmaticst_msg_sendv could dispatch to a special NilClasses’ instance methods when the receiver is nil, thereby allowing to have an isNil method[4].

It’s interesting how software evolves sometimes. Sometimes you’re just a tiny step away from a familiar concept, then the code collapses to something that looks trivial, but noone can see any more how large it has been before. The big paradoxon: The more reflective work you put into it, the smaller it gets[5].

References
[1] In this case these are actually LLVM language message sends.
[2] I recently realized how cool these are, now I start seeing them everywhere.
[3] A reference to an integer i below 2³¹ is not a pointer to a real memory location but (i<<1)+1. The lowest significant bit indicates that it’s a small integer. No collisions with real pointers because these usually have word-alignment.
[4] For that to work with the type inference that checks whether a variable can be a small int, the dispatch process would actually need to be three-staged, like (1) dispatch to smallints (2) dispatch to nil (3) dispatch to ObjC objects. Objective-C message sends enter the dispatch process at stage (3), Smalltalk message sends that can’t be small ints enter at stage (2), other Smalltalk message sends need to start at stage (1).
[5] Note the fatal negation: The less reflective work you put into it, the bigger it will become. The bigger it is, the better it looks (to your non-technical boss?).

via Slashdot: Even though it’s almost certain Sabine will finally accuse me of supreme uncurable nerdiness this time, I just cannot resist to post this. Enjoy this video of Bohemian Rhapsody played on old computer hardware. Wow! Breathtaking!

Awesome video! (via imagine27, more can be found here.)

Day of the Triffords from Andrew Sorensen on Vimeo.

Via Michael Feather’s blog: “On programming language design”

I used to think that statically checked languages are better for teaching because they prevent the students from doing obviously stupid things. About two years ago I changed my mind. The students learn much better by doing stupid things than by being told by an oppressive compiler that their programs are stupid. So this year I switched to Python. The students are happier, and so am I (because I don’t have to explain that code must be properly indented). Python does not whine all the time. Instead it lets them explore the possibilities, and by discovering which ones crash their programs they seem to understand better how the machine works.

Interesting final words for an article that’s so much in favor of static types. So according to this, you learn more with a dynamically typed, “exploratory” language. If that’s true, it makes me wonder what’s better:

• A language that allows programmers to learn a lot, while having no static types,
• or a language with a type system that prevents certain errors while you don’t learn so much.

…and of course, in which scenarios are they better?

The article is generally an interesting read regarding the topic of if-im-ever-going-to-design-a-programming-language.

SHAME ON ME! And on C, too!

If I’m ever going to design a programming language, the expression

(index == selected & (totalsize - 1))

is going to translate into

(index == (selected & (totalsize - 1)))

, not into

((index == selected) & (totalsize - 1))

I’m really ashamed I came up with this kind of optimisation for calculating a modulo for a number which is a power of 2 (which the compiler couldn’t know). When you really optimize for speed on platforms where you still unroll your code by hand, you sometimes lose sight of clarity. (But that’s not an excuse. Big SVN Blame to myself!) I also should have unit tested this earlier.

Now, time to pass the blame on to C!

If I’m ever going to design a programming language, it will also have an interactive interpreter for evaluating expressions. Actually, I tried to test the expression in Python’s interactive shell, which has a more sensible operator precedence. (Or is it just that it makes a difference between numbers and truth values, unlike C?) I probably would have searched for a few more hours, if Steffen hadn’t pointed out the issue. (Thanks!)

>>> a = 30
>>> b = 30+64
>>> a == b
False
>>> a == (b % 64)
True
>>> a == b & (64-1)
True
>>> c = 31
>>> c == b & (64-1)
False
>>>


Oh, wasted time! The weather was so beautiful today!

Aus aktuellem Anlass ein Beitrag auf Deutsch.

Dominik weist zu recht darauf hin, dass die empfohlene Literatur im Hitch Hiker, unserem kleinen Infoheftchen für Erstsemester, sowohl quantitativ als auch — und das ist schlimmer — qualitativ nachgelassen hat.

So sind mehrere reflektierende und kritische Auseinandersetzungen mit dem eigenen Tun und Handeln als Informatiker ganz stillschweigend und leise leider in der Versenkung verschwunden. Doch warum sind sie überhaupt aus der Liste rausgeflogen? Die erschreckende Antwort lautet: Es hat sie niemand mehr gekannt.

Und das ist schade, denn anders als so mancher behaupten mag, handelt es sich nicht bei allem was die Altersgrenze von 30 Jahren überschritten hat, schon gleich um ein Relikt aus grauer Vorzeit. Sind es nicht gerade diese Bücher, die auch noch in 30 Jahren Relevanz besitzen, die es sich heute lohnt zu lesen?

Zurückblickend auf die Dinge die man innerhalb seines Studiums so liest — und damit meine ich nicht nur die vorlesungsrelevanten Dinge — was hält denn davon diesem Test stand?

Wäre es nicht gelacht, wenn wir als Fachschaft feststellen müssten, dass jeder einzelne von uns nur Sachen gelesen hat, nach denen in ein paar Jahren kein Hahn mehr kräht?

Gejammer, Gejammer! Zum Ende noch was positives: Wir haben ein sehr schönes Regal in unserer wohlsortierten, wenngleich kaum genutzten Infbib, in dem Bücher stehen, die allerhand technologieunabhängige (und damit tendentiell zeitlosere) Gedanken beinhalten. So manches Buch aus der alten Empfehlungsliste kann dort noch ausgehoben werden, sowie verschiedene andere Kleinode. (Ich erinnere nur an den Gedichtband “Palmström als Programmierer”, falls sich daran jemand erinnert. Oktal! Dezimal! Nicht trivial!) Ich fände es schön, wenn wir die Ersties in der E-Woche zumindest mal an diesem Regal vorbeilotsen könnten, zum Beispiel im Rahmen der Uni-Rallye.

Example: C-x ( C-w \ e m p h { C-y } C-x )
This surrounds the selected region with \emph{} (a LaTeX command) and places the cursor after the closing bracket.

References
Also have a look at the Emacs wiki’s page on this and that nice article with video tutorial on that weblog on Emacs.