A Java geek

This is the 5th post in the JVM Security focus series. A post brought to light an interesting feature of the JDK I didn’t know about: the ability to update a code running in a JVM. The referenced post shows how to apply a bugfix using that feature. The devious white hat JVM hacker in me started to think how one could apply that trick for other less beneficial purposes. And of course, how to prevent that.

When streams were added to Java 8, I wanted to jump on the bandwagon. I read blog posts, watched videos, attended workshops to understand what this was all about. After a while, I became comfortable enough…​ but I was unhappy with the implementation: while streams offer methods with a functional approach, legacy collections do not. When one wants to use Java capabilities on an existing collection, the later needs to be transformed to a stream, and then back again. For example, the f

Some weeks ago, I read the post referenced in a tweet. In short, the article provides two ways to generate the boilerplate code required by the Builder pattern: Lombok, to generate code at compile time and the Spark Eclipse plugin, to generate code at development time. However, I already wrote about the Builder pattern. And it’s a bit more complex than what’s described in the referenced post.

This is the 6th post in the Learning Clojure focus series. In general, one learns by comparing to what one already knows: I’m learning Clojure in that way. Coming from a Java background, I naturally want to use streaming features. So, what would be the Clojure counterparts of Java’s functions filter(), map(), etc.?

The Java EE platform is huge, and I must confess I’m not aware of every one of its API. This is also true of the Spring framework, even though I think I know more of Spring than of Java EE. Lately, I was working on the version 10 of the Vaadin framework also known as Vaadin Flow. This version introduces routes. When a path is requested, the Vaadin Servlet displays the component. Routes are created by annotating specific components with the @Route annotation. Thus, Vaadin needs to list all a

This is the 5th post in the Learning Clojure focus series. While describing how to cope with dynamic typing, we used the spec library. The library is not a true replacement for types - checks are executed at runtime instead of compile-time. On the flip side, it can go further than mere types, including emulating dependent types and programming-by-contract.

Some time ago, I described a couple of surprising design choices in the JDK functional interfaces API. Lately, during a lesson, a student of mine proposed to shallow-copy an ArrayList by using the clone() method: I thought this is another API gotcha worth writing about. Cloning an object means a new object is created with the same state as the original one. As per the JavaDoc: Creates and returns a copy of this object. The precise meaning of 'copy' may depend on the class of the object.

This is the 4th post in the Learning Clojure focus series. A common pattern in software development is the dynamic dispatching (or routing) table. The table is responsible for returning the relevant output for a specific input. In the Object-Oriented programming world, the object model would look something like the following.

This is the 3rd post in the Learning Clojure focus series. For me, learning a new language is like getting into the sea: one toe at a time. This week, we will have a look at some powerful macros.