Over the decades, numerous software system architectures have emerged which require invocations across subsystems to be done via message-passing instead of programmatic interface method calls. Such architectures are so common that many programmers have come to regard message-passing as an end in and of itself, oblivious of the fact that it is nothing but a (poor) technical mechanism for accomplishing a certain architectural goal.

Let me get one thing out of the way first: I am open to Test-Driven Development (TDD). I am not currently practicing it, because when I gave it a try some time ago it did not seem to resonate with me, but I do not have any objections to it in principle, so I might give it another try in the future. Let us just say that it was not love at first sight, but then again some relationships do take some time to warm up.

Having said that, let me now express a few reasons why I am skeptical of TDD. The previous paragraph should have established that I am not trashing TDD, I am just expressing some reservations.

Abstract

A mechanism is described for automatically converting method invocations of any programmatic interface into a single-method normal form and converting back to invocations of the original interface, so that general-purpose operations can be performed on the normal form without explicit knowledge of the interface being invoked. Implementations are provided for C# and for Java.

The most awesome Stack Overflow question ever posted was later deemed unsuitable for the site, so it was not just closed; it was deleted. It does not exist anymore. The title of the question was: "New programming jargon you coined?" and as you might imagine, it received hundreds of answers. Most of the answers would make you laugh; some would make you laugh hard; some would have you in stitches.

This is only of interest to people who are into Stack Overflow.

Have you ever wondered why Stack Overflow is exactly the way it is? Here are some insights.

(Note: this presentation violates one of the cardinal rules of presentations, which is to avoid long texts, so here is a tip: ignore every screen that contains a long text, just listen to what Jeff Atwood is saying.)

Note: as I look at him, I can't help but think that all he is missing is the upward curved tie, i.e. he has to be the real-life person after whom Dilbert was fashioned.

The latest version of IntelliJ IDEA supports a new option for excluding certain methods from code coverage by annotation, and it is the result of a feature request posted by me!