# Menos boilerplate en Java, o generación de código en tiempo de compilación con annotations

![alt](https://s3.us-west-2.amazonaws.com/aleph-content/photos/598/ac190074-be4c-411a-b871-5c8480e1c522)

*— Quisiera actualizar mi conexión a la red de 28.8 kilobaudios a una línea T1 de fibra óptica. Tiene usted un servidor con routeador compatible con mi configuración LAN Ethernet Token Ring?*

*— ... Puede darme dinero?*

## Vamos por partes

* **Menos boilerplate en Java**: un objetivo muy noble.
* **Generación de código**: lo que haremos es que Java arme clases con cierta funcionalidad de forma genérica por nosotros.
* **En tiempo de compilación**: el código que generemos va a estar en archivos *.java*, iguales a los que escribimos al programar siempre, con tipado estático.
* **Annotations**: para marcar dónde y respecto de qué generar el código.

*Esta solución se inspira en la forma de trabajar de [MapStruct](https://mapstruct.org/).*

***

#### Otras soluciones: tradeoffs

* Usar [runtime reflection](https://www.baeldung.com/java-reflection)
* Hacer [modificación del AST a la Lombok](https://www.baeldung.com/lombok-custom-annotation) o [Spoon](https://spoon.gforge.inria.fr/)

Generar archivos *.java* en compilación **es más robusto** ya que podemos ver el código generado y usamos el compilador para asegurarnos que nuestra implementación no rompe.

Sin embargo, **es menos flexible**: por ejemplo, no podemos editar clases existentes, solo crear nuevas (aunque sí podemos referenciarlas de antemano).

Otra opción es *escribir el boilerplate a mano*, que es menos mantenible, y por supuesto, mucho más aburrido.

# Show me the code!
Tenemos como requisito de ejemplo **poder mergear dos objetos de la misma clase**, o sea: dados dos objetos, devolver uno que contenga todos los campos no nulos de ambos. Veamos esta value class:

```java
public class Country {
    private final String name;
    private final Long inhabitantCount;
    // constructor, getters, builder...
}
```

Si [googleamos "java merge objects"](https://www.google.com/search?q=java+merge+objects) vamos a encontrar soluciones con runtime reflection que pueden ser poco performantes, poco extensibles/customizables y poco robustas. Y escribir el boilerplate para mergear objetos... Por algo todos buscan soluciones con reflection. Pero hagamos algo mejor!

***

**Implementemos, entonces, un merger autogenerado en tiempo de compilación**. Para eso necesitamos ver dos cosas:

1) Cómo queremos que el developer/usuario nos use para `Country`?

Algo simple es que el usuario anote una interfaz suya con nuestra annotation, a la cual le generaremos su implementación. Para que ande en tiempo de compilación, también necesitamos que a su vez extienda de una interfaz con el método `merge`. Veamos:

```java
// user's interface
@Merger
public interface CountryMerger extends IMerger<Country> { }
```

2) Qué vamos a necesitar dentro de nuestra solución?

* La interfaz `IMerger<T>`
* Una annotation custom, que llamamos `@Merger`
* Un processor con toda la lógica, usando la [Java Mirror API](https://docs.oracle.com/javase/7/docs/jdk/api/apt/mirror/overview-summary.html) y [JavaPoet](https://github.com/square/javapoet)

###### Interfaz

```java
public interface IMerger<T> {
    T merge(T one, T other);
}
```

###### Annotation

```java
@Target(ElementType.TYPE) // usable on classes and interfaces
@Retention(RetentionPolicy.SOURCE) // erase after compiling
public @interface Merger { }
```

###### Annotation processor
**Nota**: para resumir el ejemplo, asumo que tu implementación de `IMerger<T>` tiene un `<T>` con Builder y getters.

Además, en este caso validamos que no estemos usando un `T` con atributos primitivos, que nunca son `null` y por lo tanto no son mergeables.

```java
@SupportedAnnotationTypes("my.package.Merger") // your annotation's FQCN
@SupportedSourceVersion(SourceVersion.RELEASE_17) // your java source version
public class MergerProcessor extends AbstractProcessor {
    private Types typeUtils;
    private Elements elementUtils;
    private Filer filer;
    private Messager messager;

    public MergerProcessor() {
        super();
    }

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) { // get some processor utils
        super.init(processingEnv);
        typeUtils = processingEnv.getTypeUtils();
        elementUtils = processingEnv.getElementUtils();
        filer = processingEnv.getFiler();
        messager = processingEnv.getMessager();
    }

@Override
    public boolean process(Set<? extends TypeElement> annotationSet, RoundEnvironment roundEnvironment) {
        for (var annotation : annotationSet) {
            var annotatedClasses = roundEnvironment.getElementsAnnotatedWith(annotation);
            annotatedClasses.forEach(clazz -> {
                // get necessary stuff from annotated class using Java Mirror API
                var packageName = elementUtils.getPackageOf(clazz).toString();
                var annotatedClass = clazz.asType(); // CountryMerger
                var genericFillableType = typeUtils.directSupertypes(annotatedClass).stream().filter(
                                it -> it.getKind() == TypeKind.DECLARED && it.toString().toLowerCase().contains("merger"))
                        .findFirst().get(); // Merger<Country>
                 var fillingErasureType = typeUtils.erasure(genericFillableType); // Merger
                var innerGenericType = ((DeclaredType) genericFillableType).getTypeArguments().get(0); // Country

// build method and class using JavaPoet and obtained data from Java Mirror API
                var methodBuilder = MethodSpec.methodBuilder("merge")
                        .addAnnotation(Override.class)
                        .addModifiers(Modifier.PUBLIC)
                        .returns(TypeName.get(innerGenericType))
                        .addParameter(TypeName.get(innerGenericType), "one")
                        .addParameter(TypeName.get(innerGenericType), "other")
                        .addStatement("var builder = one.toBuilder()");

                var fields = typeUtils.asElement(innerGenericType).getEnclosedElements();

                ElementFilter.fieldsIn(fields).forEach(field -> {
                    if (field.asType().getKind().isPrimitive()) {
                        this.messager.printMessage(Diagnostic.Kind.ERROR, "Illegal type: field '" + field.getSimpleName() + "' cannot be of primitive type.");
                    }

                    var isOrGet = (field.asType().getKind().equals(TypeKind.BOOLEAN) ? "is" : "get");
                    methodBuilder.addStatement("builder." + field.toString() + "($T.ofNullable(one." + isOrGet
                            + StringUtils.capitalize(field.toString()) + "()).orElseGet(other::" + isOrGet
                            + StringUtils.capitalize(field.toString()) + "))", Optional.class);
                });
                methodBuilder.addStatement("return builder.build()");

                // build class
                var classPoem = TypeSpec.classBuilder(clazz.getSimpleName().toString() + "Impl")
                        .addAnnotation(Component.class) // annotation for spring DI, optional
                        .addModifiers(Modifier.PUBLIC)
                        .addSuperinterface(ParameterizedTypeName.get(annotatedClass))
                        .addMethod(methodBuilder.build())
                        .build();

                // write class
                var fileObject = JavaFile.builder(packageName, classPoem);
                try {
                    fileObject.build().writeTo(filer);
                } catch (IOException e) {
                    messager.printMessage(Diagnostic.Kind.ERROR, "Oops");
                }
            });
        }
        return true;
    }
}
```

***

## Resultado
Ahora compilamos el proyecto, y vemos que se generó una clase nueva:

```java
@Component
public class CountryMergerImpl implements CountryMerger {
  public Country merge(Country one, Country other) {
    var builder = one.toBuilder();
builder.name(Optional.ofNullable(one.getName()).orElseGet(other::getName));
builder.inhabitantCount(Optional.ofNullable(one.getInhabitantCount()).orElseGet(other::getInhabitantCount));
    return builder.build();
  }
}
```
Esta clase `CountryMergerImpl` puede ser inyectada como Bean o creada con `new`.

Este ejemplo es de una clase con dos atributos, pero imaginen todo el boilerplate ahorrado en *merges* para un proyecto con muchas clases de muchos atributos.

## Customizando el merger
![java mascot looking in the mirror](https://s3.us-west-2.amazonaws.com/aleph-content/photos/598/db6bb0d4-fae3-4cc0-a005-82f3e825778a)

Ahora imaginemos que queremos **excluir ciertos campos a la hora de generar el merger**, o que queremos **definir más de una forma de mergear objetos**. Para eso basta con agregar los parámetros a nuestra annotation e implementar la lógica con un `if` o *strategy* en el Processor.

La annotation quedaría así:

```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface Merger {
    String[] excludedFields() default "";
    MergeStrategy strategy() default MergeStrategy.FIRST_NOT_NULL;
}

enum MergeStrategy {
    FIRST_NOT_NULL,
    CONCAT,
    ...
}
```
Dejo como ejercicio para el lector implementar algo más sobre `@Merger` si quisiera, teniendo como base el Processor.

Incluso se podrían generar reglas por atributo definiendo otra annotation para los fields de una clase `@Merger` y procesando ambas en un Processor.

***

Gracias por leer! Podés contactarme por [Twitter](https://twitter.com/francobatta11) o [Linkedin](https://www.linkedin.com/in/francobatta/)

alt

*— Quisiera actualizar mi conexión a la red de 2...

Menos boilerplate en Java, o generación de código en tiempo de compilación con annotations

framework features

 is a container of frameworks and features organized into modules. These modules are grouped into:


...

Spring

Introduction to parallel computing

Parallel computing is a type of computation in which many calcula...

Parallel programming in the JVM

# 2001: A Space Odyssey review and summary 🌌

(WARNING: This review contains spoilers about the movie. In fact, I describe its progression almost entirely).

I consider this movie a masterpiece.
I'm not very fond of the sci-fi genre, but this movie cuts across its tags, delving into my mind as no other film has ever done before.
In order not to leave certain aspects of the film uncovered, I have divided the review in: my opinion, technical aspects, and description of the film itself. 

My opinion (forgive the possible scientific mistakes I may commit):
2001: a space odyssey has made me think in ways I never thought I ever could. Of course, it is very thought-provoking.
It graced me with endless thoughts about the future of mankind, about the existence or non-existence of a God, about the development of artificial intelligence, and so on and so forth...
But the main concern it placed on me is about the universe and its limits. Does the universe have limits? Are we just too naive, or does the concept of the immeasurable exist too?

Besides the never ending waves of thoughts I could helplessly write down here, 2001 is a movie of beauty and exploration. It is a movie about (maybe) the whole truth of the universe (if there is one).
The futuristic approach of it is almost perfect; one cannot find scientific mistakes; it is the movie to beat in terms of sci-fi.

It also shows similar behavior and nature, displayed on completely different types of beings: such as humans and computers. The fear of death is a great feeling, which is conveyed from mankind to computers flawlessly.

## Technical aspects
### Direction
Director Stanley Kubrick makes a wonderful job at setting the pace of the film. It is as slow as it could be, yet it couldn't have been better. What would you expect from a space movie? It has to show beauty and vastness.
There are a lot of interesting cuts, such as: the ellipsis between the bone and the satellite, the fast cuts prior to Poole's assassination, the slit scan used in the stargate sequence.
The overall atmosphere is astonishing; it demands a second view to spot more details on some scenes.

### Plot
It is very nice to see a movie forcing you to actually THINK. The plot is clearly portrayed, yet it is not served to you in a plate. This also leads to different theories about some parts of the film (mainly the ending), which makes the movie even more complex and rewarding.

### Visual effects
They are amazing. The use of practical visual effects here is more than remarkable, and sets the bar quite high for other contemporary movies. Heck, it even stands still upon some new-blockbuster movies (which also lack a lot of 2001's charm and story). The huge sets for each scene are more than convincing. The docking station set, for instance, cost about 750 grand at the time.
In the description of the movie I've mentioned some of them (i.e. the pen).

### Soundtrack
Also sprach zarathustra by Strauss is a wonderful vehicle, either to bring a sense of awesomeness in the movie, and to drop a hint about Nietzsche's ideas being used later for the film.
Atmospheres by Ligeti is my favorite track on the movie. Other great compositions include The Blue Danube by Strauss.

### Acting
Kubrick's movie may seem cold on many levels. But for me, the coldness of the characters is a matter of professionalism shown in the film. I highly dislike seeing amateur-ish attitudes on people who are trained for extreme conditioning (read: Bullock on Gravity).

#DESCRIPTION OF THE MOVIE
2001 opens with a pitch black screen, which lasts for about three minutes. While we stare at deep blackness, sounds and noises of unknown nature are heard.
I was a little bit creeped the first time I saw it, and was expecting a screamer at the end of the segment (little did I know). However it filled with a sense of vastness, and set the tone for the rest of the scenes.

Next, we are graced with a more familiar opening, which consists of the sun "rising above" planet Earth, with the Moon behind them (camera's pov). The tone poem used for this scene is "Also sprach zarathustra", composed by Richard Strauss (which is not a haphazard choice).
This intro is majestic and shows a little of what's coming in terms of visual effects.

The director's name and movie title are displayed at this point.

We are now presented with the first chapter of the movie, titled "The dawn of man". Beautiful, still landscapes are shown until we encounter the first characters in the film: apes.

This group of apes we see share their territory with tapirs. Tapirs come from Southeast Asia; so, taking a wild guess, the film's first chapter is set there.
A tiger attacks an ape from above, resulting in its death. The rest of the apes run amok.
Next thing we see is another group of monkeys, who want to conquer the pond the other group is drinking water from. The two groups proceed to scream wildly -in order to intimidate each other- and the group who wanted to take over the pond leaves.

Once the scene ends, a tiger is seen among the corpse of a zebra. Director Stanley Kubrick clearly wants to make a point about "the survival of the fittest" here.

At nightfall we see the apes, crowded behind some rocks, with a scared look on their faces.

The next day, when the first ape wakes up, it fiercely wakes up the rest. Here, they go crazy for the second time, but now because of the sight of the black monolith.
They are bewildered by the strange presence. After admiring the monolith, the apes begin to touch the tall slab. The monolith's top part gets aligned with the sun.
This scene is thought-provoking and confusing. It also marks the first appearance of the mighty monolith.

Later, an ape is looking at a skeleton and awkwardly grabs a bone. The primitive being uses the bone to smash the rest of the bones in a violent hitting motion.
This event is a very direct approach to evolution. The apes had discovered the sense of tools and weapons.

The monkeys are now eating meat -it means they are conquering the food chain- i.e. tapirs.

Another day passes (maybe more time) and a second fight for the pond arises. This time, though, a group of apes has bones in their hands, which they use as weapons.
One monkey gets savagely beat up.
In the midst of primitive madness, a monkey tosses a bone up in the air.
The camera pans to the bone raising and falling.
Director Stanley Kubrick makes a fast cut to a bone-shaped artificial satellite in space: 8 million years of evolution placed on a VERY powerful ellipsis, which lasts roughly ten seconds.

At this point the movie shows the beauty present in space, with "The Blue Danube" waltz as background music. The practical visual effects here are remarkable and awe-inspiring for a movie released in 1968.

After some lengthy takes, we get to see a huge rotating docking station, which looks as realistic as it gets. 

We see the interior of a Pan-Am commercial spaceship. At this point, one of the human main characters appears.
At the back of each seat there is a FLAT screen showing movie footage. In the hallway there is a pen floating in mid air, so an air stewardess proceeds to fight through zero gravity (with her grip shoes) in order to retrieve the wayward flying pen (another IMPRESSIVE practical effect, which only consisted of a pen taped to a sheet of glass).

The spaceship proceeds to dock at the docking station ever so slowly.

Upon docking, the first main character, (at least in terms of appearance on the big screen) whose name is Dr. Heywood Floyd, uses a voiceprint identification system (which is supported by a rather flat TV screen) in order to proceed to the space station.

As a side note, I'd like to recall the noticeable amount of product placement on details. I think this idea was a huge gamble at the time, since companies like Pan-Am are no longer operating.

Dr. Floyd proceeds to a telephone cabin, in order to place a videocall. This is beyond innovating, since videocalling technology wasn't really available until the late 80's, and wasn't cheap either (here the call cost 1,70$).
I'd like to mention a line in the conversation between Dr. Heywood Floyd and his daughter (played by Vivian Kubrick!): the daughter wants a telephone for her upcoming birthday, and Floyd grinningly says "We've got lots of telephones already!". Quite accurate.

After finishing the call, Dr. Floyd meets a bunch of soviet doctors. This scene, maybe, tried to tell us how the space race may have never ended. One of the soviet people inquiries Heywood about a US space base not receiving calls and not allowing foreign spaceships to dock. That was the base the american professional was heading to.

Finally, Heywood Floyd heads for his flight to the moon. Here there are some scenes depicting space travel, with some neat zero gravity details like walking, or food trays reacting accordingly to it.
Kubrick shows landing as an extremely graceful and slow process.

Next up Floyd gives a brief speech about the absolute necessity of hermetic silence when it comes to the activities surrounding the US base, for revealing them would cause a great social shock.

Now with a creepier classical piece, Dr. Heywood Floyd heads to the strange artifact deliberately buried on the moon, in order to elaborate some reports.

Once they arrive, they head to the unknown object. With a great share of suspense, the astronauts decide to get near the monolith.
As they are taking pictures of it, Floyd touches the perfectly flat black surface.
When the group of astronauts get together to take a picture, a strange high-pitched noise begins to sound. Once again, the top of the monolith aligns with the Sun.

Now begins chapter 2: Jupiter Mission (18 months later).

A fairly large spaceship is seen gliding across space. One of the characters is seen jogging inside it. One compartment of the spaceship, which holds 3 hibernating astronauts, has an odd spherical shape.
The two active human characters on the spacecraft are able to see a BBC broadcast through a device that uncannily resembles today's tablet PC's. The broadcast consists of an interview to the astronauts and to the sixth member of the crew: computer HAL 9000.
I don't want to highlight the entire interview (although I would eagerly do so), but here's two key quotes about it:
HAL: I am putting myself to the fullest possible use, which is all I think that any conscious entity can ever hope to do.
HAL: The 9000 series is the most reliable computer ever made. No 9000 computer has ever made a mistake (...). We are all (...) foolproof and incapable of error.

After the interview and some misc scenes (albeit important, i.e. the chess scene with an intentional mistake by HAL), Hal decides to ask Bowman whether he was having second thoughts about the mission.
He then proceeds to warn Dave about a fault in the AE-35 unit.

Dave Bowman proceeds to repair the faulty unit in a beautifully crafted space scene. The way in which Dave is exposed to the void and vastness of space is incredibly demonstrated.

Back at the spacecraft, Poole and Bowman decide to examine the apparently faulty unit. They find out that the unit is in perfect state, and thus, that Hal has made a mistake.

Bowman quickly realizes something is wrong and tries to talk with his deputy Frank Poole. They finally talk inside a pod, where Hal wouldn't hear them. But little did they know, Hal could read their lips.

Later, Poole goes outside of the spaceship to place the non-faulty unit back.
Three brilliant fast cuts of Hal's red eye, and Poole is floating aimlessly in space, his oxygen tank wire cut.
Bowman attempts to rescue Poole, and gets his corpse eventually. In the meanwhile, Hal kills the hibernated men on purpose.

Bowman affords to get back to Discovery's pod bay. Except he has to command Hal to open the pod bay doors.
Here, Hal is totally sincere and tells Dave about his own flaws and fears of being killed.
The evil computer denies permission for Bowman to enter, and so he has to now find another way in (through the emergency airlock).
In a heroic, yet scientifically accurate way, Dave gets to enter Discovery through the airlock without his helmet.

Mad as a cow, Dave proceeds to literally disconnect (kill) Hal. This scene is pivotal in the movie, and gets to show the emotional bond between a human and a programmed entity (as Dave asks Hal to sing Daisy Daisy).

Hal feels his "mind" going; he has certain fear of the unknown. He is afraid and wants to live, just as any other human being.
David feels panicked as he is now officially the most lonely person on the universe. He may also feel discomfort from the idea of murdering someone.

Suddenly, as Dave enters Jupiter's space, a prerecorded briefing is played. It explains the authentic purpose of the entire mission.

Chapter 3: Jupiter and Beyond (pretty much sums it up).
Dave reaches out for the monolith in a pod, and watches it align with other planets. He is speechless... as he enters into a sort of stargate, or trip toward his transcendence on time and space perhaps.

The rest is all beautiful (unknown) imagery along with a seamless score. I found this part very powerful, for it sheds light into the -for now- hidden parts of the visible universe.
There is one take which really impressed me, and never ceases to do so even on my fifth viewing of the film. The sense of redemption and clarity it brought on me was unparalleled. It contains this image:

![alt](https://photos.collectednotes.com/photos/598/64697f41-b400-4d63-afc8-833a50d7d4e5)
*A place where the pod exits from. It's like a source in a vector field*


After taking a glance at the universe itself, the pod begins to descend into some strange world, maybe inhabited.
Toward the end we see Bowman age and decay (in an orchestrated way), thus evolving into a new being.

This new being is, apparently, of epic proportions, and has seen it all.

END OF MOVIE DESCRIPTION.

Thanks for reading!


(WARNING: This review contains spoilers about the movie. In fact, I describe its progression almost e...

2001: A Space Odyssey review and summary 🌌

Cheat Sheet (TODO)
Recap on functions and pattern matching
Case classes

Sc...

Functional Program Design in Scala ​course notes

# Browsers are part of your product

If you're on a developer team that's building a web app, you may use 

* [Babel](https://babeljs.io/) to ensure the web app can target a broad range of clients
* Bundlers like [webpack](https://webpack.js.org/) to include CSS vendor prefixes, modules, dependencies, static files, etc.

All of this has a perceived effect of increased developer productivity, but ultimately it is a business decision:
> frontend tooling => dev productivity => added value => better UX for customers => **↑ revenue ($) && ↓ churn rate**

But what happens when, despite all of this, the browser implements the same standards differently?

### HTML standard vs. implementations

Earlier while I was working on a React frontend web app, I encountered a simple `form` having a `fieldset disabled` child:

```react
const someCondition = ...
return (
  <form>
    <fieldset disabled={someCondition}>
      ...
    </fieldset>
  </form>
)
```
The `fieldset` had a bunch of `a` and `input` tags, which were `disabled` depending on `someCondition`

I was asked to change `someCondition` based on new requirements, which was really straightforward

I finished and began testing locally, and I noticed the form was behaving quite strange: some stuff meant to be disabled were still enabled

I checked the code many more times, but no errors were to be found...

An hour later, I called a coworker who had written some of the production code to see what was going wrong, and after some minutes, he told me:

> *Oh, you're using Firefox! Let's switch to Chrome and see if it works...*

And it worked. Turns out the original coder had intended to use `a` when he needed something to be ***enabled*** under a ***disabled*** *fieldset*, because Chrome wouldn't disable them in contrast to `button` or `input`

The assumption here, at the very worst, is that *every customer visiting here is using Chrome*, which [isn't so bold as it may seem](https://gs.statcounter.com/), but it bugged me quite a bit...

### Was it a hack or a correct use of the HTML spec?
I googled a bit to learn about [disabled fieldsets](https://html.spec.whatwg.org/multipage/form-elements.html#the-fieldset-element), and it turns out `disable` [prevents child **form controls'** events](https://html.spec.whatwg.org/multipage/form-elements.html#attr-fieldset-disabled) from propagating outside the `fieldset`

It also turns out **`a` isn't a form control element**, and it is (kind of?) left to implementation if its elements should be ignored

Some people even [opened issues](https://github.com/twbs/bootstrap/issues/30774) and [posted](https://makandracards.com/makandra/47961-firefox-cancels-any-javascript-events-at-a-fieldset-disabled) regarding this, even though there are [no known issues](https://caniuse.com/fieldset-disabled)

IMO this should be tweaked by Firefox so that it complies with the spec in a stricter way

### Conclusion, proof of concept
If a target browser has a bug, or implements HTML in a different way than others, then that **becomes part of your product** and is part of the frontend team decision making process...

I made a **[proof of concept](https://github.com/francobatta/browser-dependent)** of this, and I'll be adding any browser bugs/different implementations I find

You're invited to contribute too!

If you're on a developer team that's building a web app, you may use 


Babel to ensure the web app can targe...

Browsers are part of your product

Cheat sheet

Based on this cheatsheet and tour of Scala
Evaluation rules (eager...

Functional programming principles in Scala (notes)

# A case against Java or bad OOP
In this note I'll cover the most frustrating things I've encountered while developing with Java, and to a very lesser extent, **OOP** and **DDD** in general. Keep in mind this article is heavily subjective, born from experience, and not fact-based.

Besides, I'll try my best to include a potential solution to each problem I describe: maybe **using OOP**, or maybe *ditching* OOP in favor of some other construct.

We all know Java isn't a cutting-edge language, and I like to think its backwards compatibility is (somewhat) related to its verbosity.

So, without any further ado, let's begin!
## Domain ≠ data
One (mostly OOP) approach to software development them is called [DDD](https://martinfowler.com/bliki/DomainDrivenDesign.html), or better known as domain-driven design.
DDD classifies objects as

- Entities (state + behavior)
- Value Objects (state)
- Service Objects (behavior)

and separates an application in the following layers:

- Presentation
- Application
- Model
- Persistency or DAO (see impedance mismatch below)

When using DDD, encapsulation and isolation are first-class citizens. One of DDD's advantages is that modeling difficult interactions between business concerns (model layer) is made easy using a [Domain Service](https://emacsway.github.io/en/service-layer/#domain-service).

This is fine in some cases, but is really isn't how most applications are later used.
 Applications are built around *use cases* (or whatever other jargon is being used at the time). While separating an application in layers is a sound idea, one must always keep track of the actual use cases.
___
Let's plan a mock application, with the following requirements:

1. It has a domain model: `Students` --> `Subjects` --> `Grades`
1. It must be publicly exposed through a [JSON](https://www.json.org/json-en.html) REST API
1. A student should be able to see his/her grades on his/her respective subjects, upon making an API call

The developer truth here is that **1 cannot remain unaware of 2**. This simple 3 class domain can't be modeled and left behind, because it will have to be later coupled and adapted to comply with the JSON standard. Convenient decoupling becomes tech debt.
Decoupling JSON from a domain becomes **increasingly difficult and painful** as the domain grows. You'll need to write a special service for this task (probaby using a custom framework like [Gson](https://github.com/google/gson)), add [DI](https://en.wikipedia.org/wiki/Dependency_injection), and custom JSON converter classes also have to be mantained by the developers. What about validation?

Non-domain requirements are as important as the domain itself, and the domain should be modeled according to all the requirements.

##### A solution using a JSON-friendly language
If we modeled the domain using, for instance, Javascript, the problem of adapting the domain into JSON would disappear completely. Why?

Because **JSON is** (mostly) **a subset of Javascript objects**, conversion is trivial. The domain now responds to the actual *use cases*, and many problems are avoided. Validation can be handled from the outside using a JSON [validator](https://www.npmjs.com/package/jsonschema).

For an interesting rant about Java and JSON, see [this](https://www.jillesvangurp.com/blog/2011-04-02-on-java-json-and-complexity.html).

##  Impedance [mismatch](https://en.wikipedia.org/wiki/Object-relational_impedance_mismatch)
As if the above problem wasn't enough, imagine a new requirement:
> Persist the domain in a relational database of your choice 

We'll have to add an ORM to our project, and use DAO or Repository classes to access the database. Because we have decoupled everything, this is actually going to be a problem.
The term 'impedance mismatch' refers to this exact problem:

- Objects behave like graphs and their relations are almost always one-way. Tables are algebraic constructs and their relations are almost always two-way
- Objects are mostly embeddable, while tables seek normalization
- Creating [**a DAO class for each class**](https://www.baeldung.com/java-dao-pattern) is actually duplicating the domain into a 'domain-class-but-you-can-use-it-for-a-database' class
- In some cases you'll have to modify the domain for an ORM to even work correctly (interfaces and enums come to mind)
- Inheritance strategies often result in persisting all subclasses as a single table, which kind of defeats the original purpose (SQL dislikes hierarchy because of unnecesary `JOIN`s)
- Concerns like transactions are managed on an application level rather than inside the RDBMS

[Read more](https://en.wikipedia.org/wiki/Object-relational_impedance_mismatch)
##### Solution 1: active record pattern
> An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.
- [Martin Fowler](https://www.martinfowler.com/eaaCatalog/activeRecord.html)

Unsurprisingly, one of the proposed solutions is to couple the domain directly with the database logic. [Ruby on Rails](https://guides.rubyonrails.org/active_record_querying.html) provides this much needed interface.
##### Solution 2: use noSQL
Let's ignore the requirement and try something else: avoid SQL altogether. Now (excluding the novel newSQL) we are left to choose between an array of database engines, each having a different approach or use case.

The [most used](https://db-engines.com/en/ranking) noSQL engine, and appropiate for this use case, is **MongoDB**. MongoDB stores data in JSON-like documents, and features embedding as a first-class citizen.

This leaves us to ponder the **domain ≠ data** problem once again.
## Object-oriented, or 'class' oriented?
Java is a general-purpose language, and that's alright. Its *general-purposeness* makes it okay for 'enterprise' solutions and teams which don't have a specific knack for a construct or way of coding.

But really now, saying Java is object-oriented is a stretch. You can't define well-known objects using `obj`!

- Take any *Service* or *Repository* class and you'll find them quicker to implement using functions. And what about making them static?
 - If an object has to be created (expensive operation!) only to have it called once and immediately have the GC dispose of it, that object creation could have been a function call.
 - If you have a *static* class call with no internal state (input params at most), why is it a class?
- If I had a penny each time I saw a class made up of a constructor and a *call* method, I'd be drowned in pennies.
- I think **Spring**, wherein some of those concerns are largely automated through annotations, is telling us this exact thing.

Don't take my word for it, but I bet not everything in our project is a stateful, method-rich entity. Sometimes classes are overkill and add little to no value.

Let's see a quick example of an `URLBuilder` class, which formats an URL based on some parameters:
##### Implementation in Java

```java
class URLBuilder {
    private StringBuilder folder, param;
    private String connType, host;

    void setConnectionType(String conn) {
        connType = conn;
    }

    URLBuilder(){
        folder = new StringBuilder();
        param = new StringBuilder();
    }

    URLBuilder(String host) {
        this();
        this.host = host;
    }

    void addSubfolder(String tfolder) {
        folder.append("/");
        folder.append(tfolder);
    }

    void addParameter(String parameter, String value) {
        param.append(parameter);
        param.append("=");
        param.append(value);
    }

    String getURL() throws URISyntaxException, MalformedURLException {
        URI uri = new URI(connType, host, folder.toString(),
                param.toString(), null);
        return uri.toURL().toString();
    }
}
...
URLBuilder urlb = new URLBuilder("www.example.com");
urlb.setConnectionType("http");
urlb.addSubfolder("somesub");
urlb.addParameter("param", "unknown");
String url = urlb.getURL(); // finally gets URL
```
Example simplified from [this](https://stackoverflow.com/questions/19538431/is-there-a-right-way-to-build-a-url) stackoverflow post.

##### Now, let's see Scala in action

```scala
def urlBuilder(ssl: Boolean, domainName: String): (String, String) => String = {
  val schema = if (ssl) "https://" else "http://"
  (endpoint: String, query: String) => s"$schema$domainName/$endpoint?$query"
}
...
def getURL = urlBuilder(ssl=true, domainName)
val url = getURL('myEndpoint', 'myVal=3') // gets URL
```
Taken from [Scala tour](https://docs.scala-lang.org/tour/higher-order-functions.html).
For a real world (albeit more complex) Java implementation, refer to Apache's [URIBuilder](https://github.com/apache/httpcomponents-core/blob/master/httpcore5/src/main/java/org/apache/hc/core5/net/URIBuilder.java).
## NullPointerException
Also known as the billion dollar mistake. Did you know in 2020, 97% of all program halts were traced back to `NullPointerException`?
Yeah, don't believe everything you read on the internet I know, but sometimes it really feels like that.

`null` checking is a tedious task, and Java is no stranger to it. Java likes `null` so much it even has its own [design pattern](https://sourcemaking.com/design_patterns/null_object)!

This pattern consists of creating classes with empty logic (yay, more classes!) which encompass the possible `null` state of its parent class. All of this is done to prevent ad-hoc `obj != null` checks, which are even worse.

I don't think we even need an example of why modeling a no-op is cumbersome. Instead, let's look at some modern solutions:
##### Borrowing from FP, Java 8+ introduced an [Optional API](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Optional.html)
```java
String nullName = null;
String name = Optional.ofNullable(nullName).orElseGet(() -> "john"); // john
...
Optional<String> opt = Optional.of("a string");
opt.ifPresent(str -> System.out.println(str.length()));
```
Even though it is not a 'purist-worthy' implementation, it's better than plain `null` checking!
##### Kotlin chooses to [outright ignore](https://kotlinlang.org/docs/reference/null-safety.html) `null`
```kotlin
var a: String = "abc" // regular initialization -> non-null by default
a = null // compilation error
...
val a = "Kotlin"
val b: String? = null
println(b?.length) // actually returns null
println(a?.length) // unnecessary safe call
```
## Patterns are actual antipatterns
> I tried to solve a problem with Java. I now have a ProblemFactory

![Patterns](https://media-exp1.licdn.com/dms/image/C4E22AQEhDOGAeEATGQ/feedshare-shrink_1280/0?e=1594857600&v=beta&t=z-2zegnQpTX_Oc34pSHBWEOHCZlFiPBrDDGhNYhG4ZE)
#### The [Visitor](https://refactoring.guru/design-patterns/visitor) (anti?) pattern
The Visitor's intent is to circumvent the lack of [multimethod](https://en.wikipedia.org/wiki/Multiple_dispatch) support in static type-checked languages. Let's see an [example](https://refactoring.guru/design-patterns/visitor-double-dispatch):

```java
interface Graphic
    void draw()

class Shape implements Graphic
    field id
    void draw()
    // ...

class Dot extends Shape
    field x, y
    void draw()
    // ...

class Circle extends Dot
    field radius
    void draw()
    // ...
```
We have a bunch of shapes, which know how to `draw()` themselves. Now let's imagine we add an `Exporter` which exports based on the shape they're 'passed': let's see how it behaves.

```java
class Exporter
    void export(s: Shape)
        print("Exporting shape")
    void export(d: Dot)
        print("Exporting dot")
    void export(c: Circle)
        print("Exporting circle")
...
class App
    void export(shape: Shape)
        Exporter exporter = new Exporter()
        exporter.export(shape);

app.export(new Circle());
"Exporting shape"

```
Wait, what? We passed a `Circle` but a `Shape` was exported instead.
Here's the thing: the compiler doesn't know which implementation of `draw()` to call because of static binding, and can't evaluate the type passed at runtime.

The proposed OOP solution is the Visitor pattern, which effectively tells each type to accept a *visitor*, and once accepted tell it to visit ***this type***.
The `Exporter` would act as a visitor, *visiting* each type and being called therein.

```java
class Circle extends Dot
    method accept(v: Visitor)
        v.visit(this)
```
What you're actually doing is a glorified, messy switch. First of all, I'd try to change my design to eliminate the need for double dispatch. If you still have to use it, the *Java* solution I suggest using is to have [pattern matching on the instance type](https://www.baeldung.com/java-pattern-matching-instanceof) thanks to Java 14:

```java
if (shape instanceof Circle c) {
    exporter.export(c)
} else if(shape instanceof Dot d) {
    exporter.export(d)
...
}
```
An alternative solution I've coded in Javascript using an object and "matching" through keys as types:

```javascript
class Shape {
    draw(){
        return 'drawing shape'
    };
}
class Dot extends Shape {
    draw(){
        return 'drawing dot'
    }
}
class Rectangle extends Shape {
    draw(){
        return 'drawing rectangle'
    }
  }
...
class Exporter {
    constructor() {
        this.types = {
            [Shape.name]: 'like a shape!',
            [Rectangle.name]: 'like a rectangle!',
            [Dot.name]: 'like a dot!'
        }
      }
    export(shape){
        console.log(shape.draw() + ' and exporting ' + this.types[shape.constructor.name])
    }
}
...
r = new Rectangle()
e = new Exporter()
e.export(r)
'drawing rectangle and exporting like a rectangle!'
```
#### Reinventing the [Decorator](https://refactoring.guru/design-patterns/decorator) pattern
The decorator pattern isn't actually bad in and of itself. It prevents [combinatorial explosion](https://en.wikipedia.org/wiki/Combinatorial_explosion) from happening due to a high number of 'combinable' requirements.
I actually think it is quite ingenuous, but its structure isn't trivial: sometimes it can be kind of verbose.
![Decorator pattern structure](https://refactoring.guru/images/patterns/diagrams/decorator/structure.png)
Is there a simpler way of implementing a Decorator? Let's see below with examples!
___
###### A pizza menu
Here, Derek Banas posts [his +100 Java SLOC](http://www.newthinktank.com/2012/09/decorator-design-pattern-tutorial/) for a pizza shop that sells pizzas with the following options:

- Each pizza has a base, which he calls `Planpizza`
- You may add `Mozzarella` for $0.5
- You may add `TomatoSauce` for $0.35

There are 4 possible pizzas here, but it's easy to see this number growing fast for each new topping added.

Using [currying](https://en.wikipedia.org/wiki/Currying), I was able to implement this Decorator as higher-order functions:

```javascript
const seed = (pizza) => pizza // identity
const dough = ['dough', 4.0] // base pizza

const mozCheese = otherIngredient => pizza => otherIngredient([pizza[0] + ', moz cheese', pizza[1] + 0.5])
const tomatoSauce = otherIngredient => pizza => otherIngredient([pizza[0] + ', tomato sauce', pizza[1] + 0.35])
// one could refactor the ingredients and make an ingredient generator
let pizzaNoToppings = dough
let tomatoPizza = tomatoSauce(seed)(dough)
let cheesePizza = mozCheese(seed)(dough)
let pizzaWithTomatoAndCheese = mozCheese(tomatoSauce(seed))(dough)

console.log(pizzaNoToppings) // [ 'dough', 4 ]
console.log(tomatoPizza) // [ 'dough, tomato sauce', 4.35 ]
console.log(cheesePizza) // [ 'dough, moz cheese', 4.5 ]
console.log(pizzaWithTomatoAndCheese) // [ 'dough, moz cheese, tomato sauce', 4.85 ]
```
Each ingredient is a higher-order function which takes another ingredient and applies it *later*, that's why we need to define a **seed** operator.
Surely, a more creative programmer may choose to *fold* with an operator, or implement a monad perhaps?
___
###### Generalized 'decorator' to verify lists
I've quickly coded a 'custom list  instantiator' which allows to verify a list based on a set of rules.

```javascript
// conditions :: [[String, Boolean]]
const listChecker = conditions => list => {
	const [errorMessage, _fn] = conditions.find(([_error, fn]) => fn(list)) || []
    if(errorMessage)
        throw new Error(errorMessage)
    return list
}

const cappedToFiveNumbers = listChecker([
  ["List has more than five elements", (l) => l.length > 5],
  ["List has non-number members", (l) => l.some(isNaN)]
])

let myList = cappedToFiveNumbers([1, 2, 3, 4, 5]) // [1, 2, 3, 4, 5]
let anotherList = cappedToFiveNumbers([1, 2, 3, 4, 5, 6]) // Error: List has more than five elements
let yetAnotherList = cappedToFiveNumbers(['a', 2]) // List has non-number members
```
To make this resistant to array mutability, I'd suggest a [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) (listening to changes), or creating a `customArray` ES6 class.
___
## Bottom line
Remember **there is no silver bullet**! Plus, the JVM is still a widely used and stable platform!

I, personally, think the best way to look at programming concepts is to see them as tools. Having a diverse toolbox prevents me from doing everything the same and probably inefficient way.

I would love to see better or different solutions.
Don't hesitate to contact me!
> My [LinkedIn](https://www.linkedin.com/in/francobatta/)

In this note I'll cover the most frustrating things I've encountered while developing with Java, and to a very les...

A case against Java or bad OOP

Software engineer. I love learning!

twitter.com/francobatta11

Franco Battaglia