Implementing the Singleton Pattern in One Line: Scala vs. Java

The author presents a concise example of the Singleton design pattern implemented with just one line of Scala code. object Config In Scala, the object keyword is a language feature that guarantees a single instance, directly satisfying the core intent of the Singleton pattern: the entire system has only one instance.

By contrast, achieving the same effect in Java requires several lines of boilerplate code:

public class Config {
    private static final Config INSTANCE = new Config();
    private Config() {}
    public static Config getInstance() {
        return INSTANCE;
    }
}

The verbosity stems from Java’s language design choices. The language’s creator emphasized safety and limited programmer freedom, which reduces expressive power and forces developers to write more code to express patterns such as Singleton.

The article argues that design patterns themselves are not flawed; they are simply reusable solutions to recurring problems. For example, the Factory pattern decouples object creation from usage, the Strategy pattern enables interchangeable behavior, and the Observer pattern lets publishers ignore subscriber details.

Consequently, developers should first identify the concrete problem they need to solve before deciding whether a design pattern is appropriate.

If a global single instance is required and the project uses Java, the multi‑line implementation is the correct approach unless the language later adopts a built‑in singleton feature. In Scala, a single object declaration suffices.

Criticism of design patterns often stems from misuse: over‑engineering, Java’s inherent verbosity leading to hard‑to‑read code, and developers lacking the skill to know when a pattern is needed.

The article concludes that the pattern itself is not at fault; misuse by developers is the real issue.