On Test-Driven Development (TDD)

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 work for 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.

So the "master" branch is not kosher anymore

The origins of the debate go so far back that they are lost in the mists of time, but a good starting point (which contains references to prior debate) is an Internet Draft from 2018 titled Terminology, Power, and Inclusive Language in Internet-Drafts and RFCs. Some especially woke communities like the Python community had already started applying some of the recommendations in this draft as early as 2019, but things really picked up steam in 2020, with the murder of George Floyd.

On messages and message-passing

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.

Intertwine

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.

Jeff Atwood: Building Social Software for the Antisocial

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.

IntelliJ IDEA can now exclude methods from code coverage

Screenshot from "What's New in IntelliJ IDEA 2022.3"

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!

Setting up Windows 11

Instructions for future reference.

How to ALWAYS show all icons on the Windows 11 taskbar

To always show all system tray icons in Windows 11:

Open the Run prompt (Win+R) and execute the following nonsense:

explorer shell:::{05d7b0f4-2121-4eff-bf6b-ed3f69b894d9}

In the dialog that appears, there will be a checkbox to always show all icons and notifications on the taskbar.

Original source of information: TheWindowsClub

<rant-mode>

About these papers

I am one of those people who choose to publish their ideas on a blog. 

The practical reason behind doing this is so that in a conversation I can refer my interlocutor to a text which elucidates my points better than I could conversationally. Admittedly, the opportunity to do this does not arise as often as I wish it did, and even when it does happen, about half the time the interlocutor appears to be reluctant to go and actually read the post, so let's just say that I publish my ideas mainly because I like doing it.

Incremental Integration Testing

A new method for Automated Software Testing is presented as an alternative to Unit Testing. The new method retains the benefit of Unit Testing, which is Defect Localization, but eliminates the need for mocking, thus greatly lessening the effort of writing and maintaining tests.