Topic

Java

A collection of 40 issues

Java - Static Factory Methods and Autoboxing

While Java's focus on performance made the primitive types inevitable in the language, its commitment to strong backward compatibility made primitives continue to remain in Java. Thus, the divide between primitive types and reference types (objects) continues to exist. This means conversions between primitive and reference types are

Influence of fluent APIs on Refactoring

Refactoring is applying a transformation to source code, which does not change the code's behaviour. Then, one might ask - what is the purpose of such transformations? It is to change the structure of the code, which results in better maintainability. In this post, we explore an interesting

Effective Java with Groovy - Favour Composition to Inheritance

One of the key lessons from the Gang-of-Four Design Patterns is to favour composition over inheritance to achieve better maintainability in our Object-Oriented design. However, most of the codebases written in Java seem to favour inheritance over composition. The main force behind this is the ease of implementing inheritance with

Effective Java with Groovy - Singleton

Singleton is one of the most popular patterns among the ones from the Gang-of-Four design patterns. Many times, we would require just one instance of a class. Say our application connects to exactly one database; then, we would need one instance of the class that manages database connections. If developers

Ladder of constructors - pattern or anti-pattern?

The ladder of constructors is a popular pattern one can see in Java applications. In this post, let us try to understand where this pattern becomes necessary and what features the programming languages can provide to come out of the ladder of constructors. Context We want to create a class

Favour empirical evidence over extended arguments

Often, we get into extended arguments when we have to pick an optimal solution from multiple available options. Especially in the case of science and technology, gathering empirical evidence is a highly effective solution. In this post, I share my experience of a code review. This was the first piece

Micronaut Dependency Injection - The stand-alone Setup

In this post, let's explore how to use Micronaut as the Dependency Injection container in a stand-alone Java application. Let's start by creating a stand-alone Java application. I make use of the initialisers provided by Gradle (gradle init command). The application structure looks as follows. ➜ microdemo

Effective Java with Groovy - Immutability

It would seem like mutability is the default design approach when it comes to Java. However, reading "Effective Java" makes you change your mind. The book suggests - 'minimise mutability'. Also, what is highly useful is the reason for favouring immutability - "immutability is simple&

Effective Java with Groovy - Enabling Order

This post shows how does Groovy make it convenient for you to implement Comparable and Comparator interfaces.

Java - end of the road for Paths

Java introduced NIO 2 APIs with version 1.7. I wrote an article several years ago, after seeing not many developers make use of the new API. With this API, you would use java.nio.file.Path instead of java.io.File to represent a file. To get an instance