A Java geek

As an ardent promoter of Mutation Testing, I sometimes get comments that it’s too slow to be of real use. This is always very funny as it also applies to Integration Testing, or GUI. Yet, this argument is only used againt Mutation Testing, though it cost nothing to setup, as opposed to the former. This will be the subject of another post. In this one, I will provide proposals on how to speed up mutation testing, or more precisely PIT, the Java Mutation Testing reference. Setting the bar

Logging is a not a sexy subject but it’s important nonetheless. In the Java world, logging frameworks range from Log4J to SLF4J via Commons Logging and JDK logging (let’s exclude Log4J 2 for the time being). Though different in architecture and features, all of their API look the same. The logger has a method for each log level e.g.: debug(String message)info(String message)error(String message)etc. Levels are organized into a hierarchy. Once the framework is configured at a certain

My post about immutability provoked some stir and received plenty of comments, from the daunting to the interesting, both on reddit and here. Comment types They can be more or less divided into those categories: Let’s not consider anything and don’t budge an inch - with no valid argument beside 'it’s terrible'One thread wondered about the point of code review, to catch bugs or to share knowledgeRational counter-arguments that I’ll be happy to debate in a future post'I

A little more than 2 years ago, I wrote a post on how you could create a Die rolling API in Scala. As I’m more and more interested in Kotlin, let’s do that in Kotlin. At the root of the hierarchy lies the Rollable interface

Some developers have hardly ever touched software labels translation, some do it on a day-to-day basis. It sure helps to work in a country with more than one language – official or de facto. Even for in the first case, it’s considered good practice to externalize labels in properties files. As for the second case, languages are in general related. In Java, the whole label translation mechanism is handled through a hierarchy of properties files. At the top of the hierarchy lies the root file,

Before being software developers, we are people - and thus creatures of habits. It’s hard for someone to change one’s own habits, it’s harder for someone to change someone else’s habits - and for some of us, it’s even harder. This, week, during a code review, I stumbled upon this kind of structure.

When one thinks about hosting one’s Git repository online, one’s first choice is just Github, no questions asked. It’s so successful that it has become the de facto standard of Git solutions in the cloud. It’s so well-entrenched that developers are advised to use it as their portfolio. At first glance, Github has it all: public repositories, group collaboration, metrics, page hosting, on-premise install option, etc. Major players host their Open-Source code on Github: Sp

This week, I tried to improve my pet Android application developed in Kotlin. As I was very new to Kotlin when I started it, most of the code just looks like Java written in Kotlin. I will start simply.

Last week, a colleague pointed out to my team an online developer recruitment challenge. As I find it fun and there was no need to disclose one’s email, I decided to try, just to check if I could to it. The problem is quite simple but not easy: consider a rectangular maze of finite size. One has to find a specific cell on the board - the exit, starting from the origin. One has 2 move options: one cell at a time in one of the 4 cardinal points or jumping to any previously visited cell. Of

Since about a year and a half, I do a lot of presentations on Mutation Testing. In those, my point is to show that Code Coverage’s only benefit is that it’s easy to compute but that it’s meaningless - hence Mutation Testing. Since some time, I’ve been interested in Kotlin, a language from JetBrains that runs on the JVM. It’s only natural that I wanted to check how Mutation Testing could be applied to the Kotlin language.