Clojure arrow threading

Learning Clojure: the arrow and doto macros

For me, learning a new language is like getting into the sea: one toe at a time. Last week was the occasion to get familiar with the spec library. This week, we will have a look at some powerful macros. The problem When you’re not used to Clojure, parentheses may sometimes impair the readability of code. (- 25 (+ 5 (* 3 (- 5 (/ 12 4))))) The Kotlin equivalent of the above snippet would be: 25 - (5 + (3 * (5 - (12 / 4)))) Obviously, it’s related neither to Clojure nor

Clojure specifications type

Learning Clojure: coping with dynamic typing

My new position requires me to get familiar with the Clojure language. In intend to document what I learn in a series of posts, to serve as my personal reference notes. As a side-effect, I hope it will also be beneficial to others who want to take the same path. There are already a multitude of great tutorials available: hence, each post will focus on a specific theme, that is specific to Clojure considering that most of my experience comes from OOP. As a newcomer to Clojure, a big issue of min

API design interface default method Java 8

Default methods in Java 8, and what it changes in API design

Java 8 introduced default methods in interfaces. This post describes what they are, and how they can change the design of APIs. A nominal design Earlier, in Java, interfaces could only have contracts - method signatures with no implementation. In order to add some implementation, a class was required, whether abstract or not. Hence, traditional API design then followed this hierarchy: The root interface defines the contractAn intermediate class implements common behavior i.e. BarIf

Clojure Functional Programming

Decoding Clojure code, getting your feet wet

Recently, I had some some fun writing functional Kotlin to solve the FizzBuzz test. I asked for some feedback, and one of the answer I received was in Clojure: In Clojure there's the classic way, with condp and mod. There's also another way using cycle that I saw some years ago. The range and the 2 cycles will generate the fizz & buzz, the rest just decides what to print.Will be easier for you with syntax highlighting -> screenshots pic.twitter.com/wOPJD0BpGM— Alexandre Gri

serialization

Java serialization

In one of my recent courses, we talked about Java 5 annotations. I told my students that before that time, one had to use marker interface instead: an interface without any method. Then, I showed the Serializable interface as an example. I started to explain it, then realized I would need a lot of time to fully cover it. This post is an attempt at that. Serialization is the process of transforming an existing in-memory Java object to a stream of bytes. That stream can then be transferred over t

GraalVM native AOT reflection

Configuring Graal Native AOT for reflection

I’ve been following GraalVM with a lot of interest. One of the interesting areas is its ability to compile bytecode Ahead-Of-Time, and create a native image. Such images have a lot of advantages, including small size, no dependency on a JRE, etc. However, AOT has some limitations. In particular, the native image executable cannot compile what it doesn’t know about. This post aims to describe how to configure the compilation process when code is using reflection. Let’s start