Docker optimization Gemfile npm

Layering your Docker images with dependencies

Since already some years, this site uses the Jekyll static site generator. Generating the complete site takes about 15 minutes. Some time ago, I decided to setup Gulp to minimize HTML in order to speed up page view for readers. This change added about 10 minutes to the build time, for a total of ~25 minutes, which is a long time…​ too long. I wanted to decrease the build time, so I decided to play around. The initial state A Docker image is used to build the site. The image is bas

testing assertion library software craftmanship

A comparison of assertion libraries

I was not a fan of assertions libraries at first. Whether assertions provided by the testing frameworks were enough is debatable. But those libraries provides the way to write custom assertions closer to the business language. While the intention is commendable, I always thought this path was a slippery slope. If one starts writing such custom assertions, then they need to be tested obviously. And then, when will it stop? However, there’s no denying assertion libraries make writing assert

deduplication API

Deduplication trick in legacy code

It might happen that you need to deduplicate a list of items…​ coming from legacy code. The class - let’s call it LegacyObject has already implementations for equals() and hashCode(). It’s not possible to change the implementation, for fear of breaking the running code. And unfortunately, the Java API doesn’t offer a distinctBy() feature. In that case, a cheap trick is to create a wrapper class around LegacyObject, with the desired implementation: public class L

Kotlin software design UML

Options for managing derived attributes in Kotlin

A derived attribute is an attribute computed from other attributes e.g.: The fullName is aggregated from the first, middle and last nameThe age is computed from the birthdateetc. Kotlin offers different options to manage such derived attributes. Let’s browse through them. Inline field initialization The simplest way to manage derived attributes is to declare a property, and compound its declaration with its initialization: class Person(val firstName: String, val middle

Spring DevTools Maven Jib IntelliJ IDEA tip

Spring DevTools with Jib and IntelliJ IDEA

I’ve been recently developing a Spring Boot application, and to speed up my development speed, I added Developer Tools as a dependency. By default, classes loaded in the HotSpot JVM can be updated only if the later runs in debug mode, and only for changes regarding method implementation. This means adding an attribute to an class requires a full restart. DevTools is an improvement over that. It works by tweaking the standard classloading mechanism: one classloader is dedicated to librar

streams Functional Programming state Object-Oriented Programming

Java streams and state

With Java 8 streams, it seems Functional Programming has won. Long live statelessness and recursion! Reality is a bit more nuanced: as always in software programming, it depends. I believe that the more tools in your toolbelt, the better it is. When all you have is a hammer, everything looks like a nail. In Functional Programming, every function needs to be pure: output only depends on input, and there are no side-effects. For this reason, Java methods to create infinite streams are not u

Functional Programming group by

From Imperative to Functional Programming: a grouping issue (and how to solve it)

This is the third post in a series about migrating to functional programming: From FP to imperative using ArrowFrom FP to imperative, an approach There’s a whole category of problems related to grouping e.g.: given a collection of person, return a list of pairs with the first value the age, and the second one the collection of persons of that agegiven a collection of orders, return a list of pairs with some price range e.g. $0-$100, $101-$200, etc. as the first value, and the number of s

Functional Programming paradigm

From Imperative to Functional Programming, an approach

Last week, we ported the migration of a Scala application from imperative to functional in Kotlin with the help of the Arrow library. This was pretty easy: the example was laid out for us. This week, I’d like to go for more fundamental stuff. On HackerRank, there’s this problem: Consider a staircase of size 4: # ## ### #### Observe that its base and height are both equal to n, and the image is drawn using # symbols and spaces. The last line is not preceded by any sp