Greach 2019

This week I could attend another fantastic Greach Conference, an international conference that in previous years was focused on the Apache Groovy language and ecosystem (Grails, Gradle, etc.) but this year has expanded the scope to other technologies related to the JVM like Micronaut, GraalVM, Spring Boot, Kotlin, Android, …

Greach is a non-profitable event held in Madrid since 2011 (I think I’ve missed only one edition). This year for the first time the organizers were Sergio del Amo y José Miguel Rodríguez, with some help from colleagues and a lot of sponsors.

TLDR; The conference was, as expected, great both in content and speakers. It’s a must for me, specially being held here in Madrid. This is still a Groovy lovers conference, but this year Micronaut was omnipresent. Some speakers also put the focus on GraalVM and Kotlin as technologies to follow closely. I will.

Let me summarize some of the talks I attended:

Talks

JVM Frameworks Keynote, by Andrés Almiray (@aalmiray)

Andrés gave an interesting overview of the JVM Frameworks ecosystem, starting with some history. He reminded us all when Struts was the king of the hill, and how it surrendered to Rails, Grails, etc. The microservices appeared and the frameworks evolved as well. Spring Boot has been the dominant player for a while but everything changed last year with the appearance of Micronaut. Others are following the same approach, like RedHat with Quarkus.

A perfect kick-off for a conference centered on frameworks.

Andrés Almiray with a microservices frameworks taxonomy

Micronaut State of the Union, by Graeme Rocher (@graemerocher)

Graeme gave an overview of the features and roadmap for Micronaut. He highlighted several times that it is perfect for Microservices and serverless functions, but not only for them as it’s also suitable for bigger applications. The goal of Graeme and his team is to break the correlation between lines of code and startup time and resources consumption. He also emphasized their fight against reflection and the consequent reflective data caches, essential in other frameworks like Spring Boot, that have several inconveniences in performance and start up time.

He also explained why Micronaut behaves amazingly good with GraalVM, but clarified that they are mainly focused on the performance with the standard JVM that most people still use. He ended with an interesting live demo about the Bean Introspection API, released with the last 1.1 version.

Graeme Rocher explaining Java's problems for Frameworks

Boosting your applications with distributed caches/datagrids, by Katia Aresti (@karesti)

Katia explained how Infinispan works as a cache or data grid, both as a library or as a external service, and how to configure it in distributed systems. With examples using Harry Potter (sometimes confusing) analogies she also explained concepts like redundant replication or consistent hashing. She finished with a demo using Infinispan, Eclipse Vert.X and Quarkus.

Reactive for the Impatient, by Mary Grygleski (@mgrygles)

Mary explained what reactive programming is and gave an overview of the the current Java options for this. She spent most of the time with the theoretical basics and terminology to finish with a quick overview of the main alternatives. I’d have preferred more details or examples in the last part, as I am already familiar with the basic concepts, but the talk was overall useful and interesting.

GraalVM with Groovy & Kotlin, by Alberto de Ávila (@alberto_deavila)

Alberto explained how to use GraalVM, the architecture basics (the GraalVM compiler, the Truffle API, etc.), and how to use Groovy and Kotlin with it. It was an interesting and well documented analysis, focusing on the current limitations and the potential benefits. It’s quite promising despite GraalVM is still far from being production ready.

Alberto de Ávila explains the GraalVM Architecture

Accelerating CI, by Felipe Fernández (@felipefzdz)

Felipe’s talk was quite interesting. As a Gradle Enterprise developer he explained basic and advanced recommendations in order to achieve a faster and more reliable CI. He explained how to parallelize workers, how to design an effective pipeline structure and how to avoid maintenance waste in general. He ended with a couple of very good recommendations: measure everything and treat your CI as code, always.

Grails State of the Union, by Graeme Rocher (@graemerocher)

Another interesting status review of Grails by Graeme. This time it was focused on how Grails is already benefiting from Micronaut, and how to take advantage of those benefits using Grails. He encouraged all the Grails plugin developers to migrate them to Micronaut so they can be used not only from Grails but also in other use cases.

Graeme Rocher explains the differences between Micronaut and Grails

What’s new in Asciidoctor, by Schalk Cronjé (@ysb33r)

My first choice on Saturday morning was to learn all the new things that Asciidoctor is introducing. Schalk explained clearly lots of new features, making everything much more simple and intuitive. Curiously, Schalk released during the conference version 2.0.0 of the Asciidoctor Gradle plugin, written entirely in Groovy.

I’m not using Asciidoctor enough lately and I regret it, as it’s fantastic.

What’s new in Gradle 5?, by Andrés Almiray (@aalmiray)

Andrés summarized all the new things that are coming with Gradle 5.0, highlighting Kotlin DSL 1.0 integration for those who are ready to use it. Gradle 5.0 will have better dependency management and several build performance improvements related to composite builds, build cache management and build scans. He even demoed some of the features, I specially liked how the Gradle build scans functionality looks like.

Creating Micronaut Configurations, by Iván López (@ilopmar)

This year Iván was not organizing the conference, he even had time to attend lots of talks, but he delivered as usual one of the most useful talks. He reviewed how Micronaut configurations work and explained in detail how to create a new one. There are several different options to extend the framework via configurations and looks quite easy.

(Automated) Security Testing in a DevOps world, by Kevin Wittek (@kiview)

This was one of the most interesting talks of the conference, at least for me. Kevin explained very clearly how to evolve from the traditional development pipeline to a more DevOps oriented one. Apart from some general recommendations he described all the possible security checks and validations that can be done, when and how to do them. He also created awareness about the lack of an open source reliable catalog of known vulnerabilities.

Kevin Wittek with a Linus Torvalds quote

Micronaut performance, by Miguel Ángel García Gómez (@MiguelAngelGG82)

Miguel Ángel showed a comparison he made in terms of performance between the main microservice-oriented frameworks that we have now in the market: Micronaut, Spring Boot and Vert.x. He added a fourth option (Micronaut running on GraalVM) although he confessed that he could not measure everything properly with it due to the lack of compatibility between GraalVM and Prometheus.

He showed the audience the results of his benchmark. The overall winner is apparently Micronaut+GraalVM despite the uncertainty related to the lack of good measurements. Among the other three options, some of them are better in some tests, but none of them is clearly better. Perhaps with larger and/or more challenging benchmarks the degradation in any option(s) could make the difference.

It’s a bird, it’s a plane, no it’s SDKMAN!, by Marco Vermeulen (@marc0der)

Marco, creator of this awesome SDK manager tool, explained the current status of SDKMAN and the next features. He also explained the architecture behind the project, and the main challenges it faces. He also made some very interesting comments about the initial decision to write it in bash to have only curl and zip as dependencies, and how he is now considering a rewrite in a different language.

How I Automated My Barn with Arduino, Raspberry Pi, Kafka, Docker, Kubernetes, Mongo and the Cloud, by Todd Sharp (@recursivecodes)

My Greach conference ended with an interesting talk by Todd Sharp. He explained how he managed to create a complex combination of technologies to learn about them and also about some features of the Oracle Cloud offering. He lives in a small town and has a barn with a pig and some chickens, so he wanted to automatize as much as possible the repetitive tasks related to the barn. He started with some sensors and now he is in the way to not only read but also perform some actions like fill a water bowl, open/close the doors or detect predators in the surroundings.

He was very funny and, although the demo didn’t perfectly work and made him lose some time, he could explain the complexness of what he built and the technologies he learned in the process.

Todd Sharp explains the architecture of his barn automation project

And that’s all. See you in Greach 2020 !!