Less waste, more joy, and a lot more green: How Quarkus makes Java better

Holly Cummins Øredev November 6, 2024 less waste, more joy,
and a lot more green how quarkus makes java better

@holly-cummins.bsky.social what #RedHat

quarkus applications start fast quarkus + graalvm 0.014 Seconds quarkus
+ open jdk 0.75 Seconds traditional cloud-native stack 4.3 Seconds https://quarkus.io/blog/runtime-performance/ rest application

quarkus + GraalVM 13 MB quarkus + OpenJDK 74 MB
traditional Cloud-Native Stack 140 MB rest application https://quarkus.io/blog/runtime-performance/ quarkus improves memory utilization

@holly_cummins machine quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus
quarkus quarkus quarkus quarkus quarkus quarkus container orchestration machine traditional cloud-native java stack traditional cloud-native java stack traditional cloud-native java stack traditional cloud-native java stack quarkus applications have high deployment density. quarkus native, but quarkus on jvm is also way smaller than traditional java

@holly_cummins traditional cloud-native java stack traditional cloud-native java stack traditional
cloud-native java stack traditional cloud-native java stack node.js node.js node.js node.js node.js node.js node.js go go machine go go go go go go go go go go go go go go go go go go go quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus quarkus … and not just when comparing to other java frameworks container orchestration machine machine machine https:/ /developers.redhat.com/blog/2017/03/14/java-inside-docker/

let’s talk about throughput. https://www.redhat.com/en/resources/mi-quarkus-lab-validation-idc-analyst-paper 48 concurrent connections traditional cloud
native stack 3555 req/s

let’s talk about throughput. quarkus native 3212 req/s https://www.redhat.com/en/resources/mi-quarkus-lab-validation-idc-analyst-paper 48
concurrent connections traditional cloud native stack 3555 req/s

let’s talk about throughput. quarkus native 3212 req/s https://www.redhat.com/en/resources/mi-quarkus-lab-validation-idc-analyst-paper a
trade-off of throughput against footprint 48 concurrent connections traditional cloud native stack 3555 req/s

@holly-cummins.bsky.social native compilation trade-offs quarkus native 3212 req/s https://www.redhat.com/en/resources/mi-quarkus-lab-validation-idc-analyst-paper 48
concurrent connections traditional cloud native stack 3555 req/s throughput startup time + footprint

but … traditional cloud native stack 3555 req/s quarkus native
3212 req/s https://www.redhat.com/en/resources/mi-quarkus-lab-validation-idc-analyst-paper a trade-off of throughput against footprint 48 concurrent connections

but … traditional cloud native stack 3555 req/s quarkus on
jvm 6389 req/s quarkus native 3212 req/s https://www.redhat.com/en/resources/mi-quarkus-lab-validation-idc-analyst-paper a trade-off of throughput against footprint 48 concurrent connections

but … traditional cloud native stack 3555 req/s quarkus on
jvm 6389 req/s quarkus native 3212 req/s https://www.redhat.com/en/resources/mi-quarkus-lab-validation-idc-analyst-paper no trade-off, just better :) a trade-off of throughput against footprint 48 concurrent connections

@holly-cummins.bsky.social we beat the trade-off. throughput startup time + footprint

@holly-cummins.bsky.social we beat the trade-off. throughput startup time + footprint
it’s a double-win.

@holly_cummins #RedHat developer joy

@holly_cummins #RedHat developer joy -auto-provision services

@holly_cummins #RedHat developer joy -auto-provision services -live coding

@holly_cummins #RedHat developer joy -auto-provision services -live coding -continuous (fast!)
testing

@holly_cummins #RedHat developer joy -auto-provision services -live coding -continuous (fast!)
testing -less boilerplate

@holly-cummins.bsky.social how #RedHat

@holly-cummins.bsky.social

@holly-cummins.bsky.social profile shave shave profile shave profile shave profile shave
profile

@holly-cummins.bsky.social profile shave shave profile shave profile shave profile shave
profile shave profile

@holly-cummins.bsky.social performance is a series of puzzles

@holly-cummins.bsky.social “OAAS: obsession as a service” - Francesco Nigro, obsessive
performance engineer

@holly-cummins.bsky.social why don’t java apps do well on techempower benchmark?
example performance puzzle

@holly-cummins.bsky.social sometimes, the root cause is not obvious

@holly-cummins.bsky.social clue 1

@holly-cummins.bsky.social we ran hyperparameter optimisation clue 1

@holly-cummins.bsky.social we ran hyperparameter optimisation clue 1 it suggested this:

@holly-cummins.bsky.social we ran hyperparameter optimisation -XX:TieredStopAtLevel=1 clue 1 it suggested
this:

@holly-cummins.bsky.social we ran hyperparameter optimisation -XX:TieredStopAtLevel=1 clue 1 it suggested
this: disables C2 compiler

@holly-cummins.bsky.social we ran hyperparameter optimisation -XX:TieredStopAtLevel=1 well-known for making long-running
apps slower clue 1 it suggested this: disables C2 compiler

small number of cores Netty http handling clue 2

lots of cores Netty http handling clue 2

what’s going on here? lots of cores example: type pollution
clue 2

@holly-cummins.bsky.social to find out, Francesco Nigro and Andrew Haley read
20,000 lines of ASM ASM clue 3

@holly-cummins.bsky.social cache pollution diagnosis

@holly-cummins.bsky.social “type pollution” diagnosis

@holly_cummins if (a instanceof Thing) problematic pattern:

@holly_cummins if (a instanceof Thing) problematic pattern: !!

@holly_cummins if (a instanceof Thing) problematic pattern: affects : !!

@holly_cummins if (a instanceof Thing) – Quarkus core – Netty
– Hibernate ORM – Hibernate Reactive – Vert.x – Smallrye Mutiny – Smallrye Common – Vert.x Web – Infinispan – Camel – Drools – Optaplanner – Java Class Library problematic pattern: affects : !!

@holly_cummins if (a instanceof Thing) – Quarkus core – Netty
– Hibernate ORM – Hibernate Reactive – Vert.x – Smallrye Mutiny – Smallrye Common – Vert.x Web – Infinispan – Camel – Drools – Optaplanner – Java Class Library problematic pattern: affects : !! – Java Class Library!

@holly-cummins.bsky.social avoiding the problematic pattern sped quarkus up a lot
(in many-core case)

@holly-cummins.bsky.social #RedHat private static int extractSize(Object it) { if (it
instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } else if (it.getClass().isArray()) { return Array.getLength(it); } else if (it instanceof Integer) { return ((Integer) it); } return 10; } slow on many-core systems

instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } else if (it.getClass().isArray()) { return Array.getLength(it); } else if (it instanceof Integer) { return ((Integer) it); } return 10; } // Note that we intentionally use "instanceof" to test interfaces as the last resort in order to mitigate the "type pollution” // See https://github.com/RedHatPerf/type-pollution-agent for more information if (it instanceof AbstractCollection) { return ((AbstractCollection<?>) it).size(); } else if (it instanceof AbstractMap) { return ((AbstractMap<?, ?>) it).size(); } else if (it instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } return 10; } slow on many-core systems 30% more throughput

instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } else if (it.getClass().isArray()) { return Array.getLength(it); } else if (it instanceof Integer) { return ((Integer) it); } return 10; } // Note that we intentionally use "instanceof" to test interfaces as the last resort in order to mitigate the "type pollution” // See https://github.com/RedHatPerf/type-pollution-agent for more information if (it instanceof AbstractCollection) { return ((AbstractCollection<?>) it).size(); } else if (it instanceof AbstractMap) { return ((AbstractMap<?, ?>) it).size(); } else if (it instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } return 10; } but …

instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } else if (it.getClass().isArray()) { return Array.getLength(it); } else if (it instanceof Integer) { return ((Integer) it); } return 10; } // Note that we intentionally use "instanceof" to test interfaces as the last resort in order to mitigate the "type pollution” // See https://github.com/RedHatPerf/type-pollution-agent for more information if (it instanceof AbstractCollection) { return ((AbstractCollection<?>) it).size(); } else if (it instanceof AbstractMap) { return ((AbstractMap<?, ?>) it).size(); } else if (it instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } return 10; } not a fan of the fix but …

instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } else if (it.getClass().isArray()) { return Array.getLength(it); } else if (it instanceof Integer) { return ((Integer) it); } return 10; } // Note that we intentionally use "instanceof" to test interfaces as the last resort in order to mitigate the "type pollution” // See https://github.com/RedHatPerf/type-pollution-agent for more information if (it instanceof AbstractCollection) { return ((AbstractCollection<?>) it).size(); } else if (it instanceof AbstractMap) { return ((AbstractMap<?, ?>) it).size(); } else if (it instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } return 10; } not a fan of the fix non-idiomatic but …

instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } else if (it.getClass().isArray()) { return Array.getLength(it); } else if (it instanceof Integer) { return ((Integer) it); } return 10; } // Note that we intentionally use "instanceof" to test interfaces as the last resort in order to mitigate the "type pollution” // See https://github.com/RedHatPerf/type-pollution-agent for more information if (it instanceof AbstractCollection) { return ((AbstractCollection<?>) it).size(); } else if (it instanceof AbstractMap) { return ((AbstractMap<?, ?>) it).size(); } else if (it instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } return 10; } not a fan of the fix non-idiomatic difficult to maintain but …

instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } else if (it.getClass().isArray()) { return Array.getLength(it); } else if (it instanceof Integer) { return ((Integer) it); } return 10; } // Note that we intentionally use "instanceof" to test interfaces as the last resort in order to mitigate the "type pollution” // See https://github.com/RedHatPerf/type-pollution-agent for more information if (it instanceof AbstractCollection) { return ((AbstractCollection<?>) it).size(); } else if (it instanceof AbstractMap) { return ((AbstractMap<?, ?>) it).size(); } else if (it instanceof Collection) { return ((Collection<?>) it).size(); } else if (it instanceof Map) { return ((Map<?, ?>) it).size(); } return 10; } not a fan of the fix non-idiomatic difficult to maintain machine efficiency my team’s efficiency but …

@holly-cummins.bsky.social sometimes, you need to un-connect the dots

@holly-cummins.bsky.social African wild ass sometimes, you need to un-connect the
dots

@holly-cummins.bsky.social sometimes, you need to un-connect the dots

@holly-cummins.bsky.social #RedHat challenge assumptions

@holly-cummins.bsky.social #RedHat string comparison: who says you have to read
strings left-to-right? challenge assumptions

@holly-cummins.bsky.social #RedHat string comparison: who says you have to read
strings left-to-right? QUARKUS_REPEATED_PREFIX_FOO QUARKUS_REPEATED_PREFIX_BAR challenge assumptions

@holly-cummins.bsky.social #RedHat challenge outdated architectural ssumptions

@holly_cummins Don’t be dynamic.

@holly_cummins Don’t be dynamic. (Wait, what??)

@holly-cummins.bsky.social #RedHat old Java frameworks were optimised for …

@holly-cummins.bsky.social #RedHat long-lived processes old Java frameworks were optimised for
…

@holly-cummins.bsky.social #RedHat long-lived processes annual (!) deployments old Java frameworks
were optimised for …

@holly-cummins.bsky.social #RedHat long-lived processes annual (!) deployments late-binding old Java
frameworks were optimised for …

@holly-cummins.bsky.social #RedHat long-lived processes annual (!) deployments late-binding re-configurable without
restart old Java frameworks were optimised for …

@holly-cummins.bsky.social #RedHat application frameworks were optimised for dynamism

@holly-cummins.bsky.social #RedHat application frameworks were optimised for dynamism dynamism has
a cost

@holly-cummins.bsky.social #RedHat load code onto a server then

@holly-cummins.bsky.social #RedHat load code onto a server then public static
void main(String... args) { int exitCode = new CommandLine(new ModuleBuildDurationReport()).execute(args ); System.exit(exitCode); }

@holly-cummins.bsky.social #RedHat load code onto a server then

@holly-cummins.bsky.social #RedHat cloud apps are immutable now

@holly-cummins.bsky.social #RedHat cloud apps are immutable now CI

@holly-cummins.bsky.social #RedHat cloud apps are immutable now CI public static
void main(String... args) { int exitCode = new CommandLine(new ModuleBuildDurationReport()).execute(args ); System.exit(exitCode); }

@holly-cummins.bsky.social #RedHat cloud apps are immutable now CI

@holly-cummins.bsky.social #RedHat a highly dynamic runtime in a container is
pointless

@holly_cummins Java dynamism

@holly_cummins Java dynamism build time

@holly_cummins Java dynamism build time runtime

@holly_cummins Java dynamism packaging (maven, gradle…) build time runtime

@holly_cummins Java dynamism build time runtime

@holly_cummins Java dynamism </> build time runtime load and parse
• config files • properties • yaml • xml • etc.

@holly_cummins Java dynamism </> build time runtime

@holly_cummins Java dynamism @ @ </> build time runtime •
classpath scanning and annotation discovery • attempt to load class to enable/disable features

@holly_cummins Java dynamism @ @ </> build time runtime

@holly_cummins Java dynamism @ @ </> build time runtime build
a metamodel of the world

@holly_cummins Java dynamism @ @ </> build time runtime

@holly_cummins Java dynamism @ @ </> build time runtime start
• thread pools • I/O • etc.

@holly_cummins Java dynamism @ @ </> build time runtime ready
to do work!

@holly_cummins what if we start the application more than once?
@ @ </>

@ @ </> @ @ </>

@ @ </> @ @ </> @ @ </>

@ @ </> @ @ </> @ @ </> @ @ </>

@ @ </> @ @ </> @ @ </> @ @ </> so much work gets redone every time

@holly-cummins.bsky.social Hibernate speed example: JTA auto-wiring

@holly-cummins.bsky.social Hibernate speed example: JTA auto-wiring Class.forName(“LikelyJTAImplementation”);

@holly-cummins.bsky.social Hibernate speed example: JTA auto-wiring Class.forName(“LikelyJTAImplementation”); Class.forName(“APossibleJTAImplementation”);

@holly-cummins.bsky.social Hibernate speed example: JTA auto-wiring Class.forName(“LikelyJTAImplementation”); Class.forName(“APossibleJTAImplementation”); Class.forName(“AnotherJTAImplementation”);

@holly-cummins.bsky.social Hibernate speed example: JTA auto-wiring Class.forName(“LikelyJTAImplementation”); Class.forName(“APossibleJTAImplementation”); Class.forName(“AnotherJTAImplementation”); …

@holly-cummins.bsky.social Hibernate speed example: JTA auto-wiring Class.forName(“LikelyJTAImplementation”); Class.forName(“APossibleJTAImplementation”); Class.forName(“AnotherJTAImplementation”); Class.forName(“NicheJTAImplementation”);
…

Class.forName(“VeryNicheJTAImplementation”); …

Class.forName(“VeryNicheJTAImplementation”); … ~129 auto-wiring attempts

Class.forName(“VeryNicheJTAImplementation”); … ~129 auto-wiring attempts every single start.

@holly-cummins.bsky.social it’s not just JTA this happens for lots of
internal service bindings

@holly-cummins.bsky.social JVM footprint example: Hibernate

@holly-cummins.bsky.social JVM spends time loading classes for specific databases JVM
class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database footprint example: Hibernate

class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database class for unused database turns out they’re never used footprint example: Hibernate

turns out they’re never used JIT spends time unloading classes footprint example: Hibernate

@holly-cummins.bsky.social Hibernate example: ~500 classes which are only useful if
you're running an Oracle database loaded and then unloaded

@holly-cummins.bsky.social Hibernate example: ~500 classes which are only useful if
you're running an Oracle database loaded and then unloaded every single start.

@holly-cummins.bsky.social the true cost of loaded classes isn’t just memory
+ start time

+ start time method dispatching:

@holly-cummins.bsky.social interface the true cost of loaded classes isn’t just
memory + start time method dispatching:

@holly-cummins.bsky.social unused implementation the one we want interface unused implementation
unused implementation the true cost of loaded classes isn’t just memory + start time method dispatching:

@holly-cummins.bsky.social unused implementation the one we want interface megamorphic call
slow dispatching unused implementation unused implementation the true cost of loaded classes isn’t just memory + start time method dispatching:

+ start time the one we want interface

+ start time the one we want monomorphic call fast dispatching interface

@holly-cummins.bsky.social how do we fix all this?

@holly_cummins @ @ </> build time runtime what if we
initialize at build time?

@holly_cummins @ @ </> build time runtime start • thread
pools • I/O • etc. what if we initialize at build time?

@holly_cummins @ @ </> build time runtime ready to do
work! start • thread pools • I/O • etc. what if we initialize at build time?

@holly_cummins @ @ </> repeated starts are now efficient

@holly_cummins @ @ </> repeated starts are now efficient less
wasted work

@holly_cummins the quarkus way enables native compilation native (graalvm) @
@ </> jvm build time

@holly-cummins.bsky.social doing more up-front

@holly-cummins.bsky.social doing more up-front - speeds up start

@holly-cummins.bsky.social doing more up-front - speeds up start - shrinks
memory footprint

@holly-cummins.bsky.social doing more up-front - speeds up start - shrinks
memory footprint - improves throughput (!)

@holly-cummins.bsky.social implementation corollary: libraries must participate in the build process,
not just the runtime process

@holly-cummins.bsky.social implementation corollary: libraries must participate in the build process,
not just the runtime process you need an extensible build process

@holly_cummins have the right plug-points, so the whole ecosystem can
become faster

@holly-cummins.bsky.social build steps + build items extensible builds

@holly-cummins.bsky.social build steps + build items extensible builds any extension
can make

@holly_cummins #Quarkus #RedHat

@holly_cummins #Quarkus #RedHat build steps

@holly_cummins #Quarkus #RedHat build items

@holly_cummins #Quarkus #RedHat framework automatically determines correct execution order and
injects parameters

@holly_cummins #Quarkus #RedHat build items are communication mechanism between build
steps framework automatically determines correct execution order and injects parameters

@holly_cummins isn’t long compilation kind of terrible for developers? @
@ </>

@holly_cummins isn’t long compilation kind of terrible for developers? not
if you have live coding :) @ @ </>

@holly_cummins framework works out required level of reload live coding

@holly_cummins file reload live coding

@holly_cummins file reload live coding SASS changes detected, will rebuild:
[META-INF/ resources/public/stylesheets/live.scss] Files changed but restart not needed - notified extensions in: 0.043s

@holly_cummins file reload JVM agent reload live coding

@holly_cummins file reload JVM agent reload live coding Application restart
not required, replacing classes via instrumentation Live reload performed via instrumentation, no restart needed, total time: 0.180s

@holly_cummins full restart file reload JVM agent reload live coding

@holly_cummins full restart file reload JVM agent reload live coding
Restarting quarkus due to changes in Application$RenardeRequest.class, Application.class, Application$ApplicationGlobals.class, Application$Templates.class. Live reload total time: 1.415s

@holly_cummins full restart file reload JVM agent reload not noticeable
(quarkus starts fast) live coding Restarting quarkus due to changes in Application$RenardeRequest.class, Application.class, Application$ApplicationGlobals.class, Application$Templates.class. Live reload total time: 1.415s

@holly_cummins fast start enables live coding

@holly-cummins.bsky.social how to make people efficient

@holly-cummins.bsky.social how to make people efficient - make it hard
to get wrong

to get wrong - strong typing

to get wrong - strong typing - garbage collection

to get wrong - strong typing - garbage collection - give them a tight feedback loop

to get wrong - strong typing - garbage collection - give them a tight feedback loop - for manual testing - for automated testing

to get wrong - strong typing - garbage collection - give them a tight feedback loop - for manual testing - for automated testing - allow less typing

to get wrong - strong typing - garbage collection - give them a tight feedback loop - for manual testing - for automated testing - allow less typing thank you, Java - strong typing - garbage collection

to get wrong - strong typing - garbage collection - give them a tight feedback loop - for manual testing - for automated testing - allow less typing thank you, Java - strong typing - garbage collection we just covered this

@holly_cummins index, index, index (and let your ecosystem use the
index)

@holly-cummins.bsky.social most frameworks need to…

@holly-cummins.bsky.social most frameworks need to… -find all classes + interfaces
+ methods + fields annotated with @a

+ methods + fields annotated with @a -find all classes implementing or extending b

+ methods + fields annotated with @a -find all classes implementing or extending b java doesn’t help us nothing in the reflection package does this

@holly-cummins.bsky.social jandex

@holly-cummins.bsky.social jandex “offline reflection”

@holly-cummins.bsky.social we have an index now what?

@holly-cummins.bsky.social challenge assumptions.

@holly-cummins.bsky.social challenge assumptions. what if developers didn’t have to …
?

@holly-cummins.bsky.social #RedHat package com.example; import org.jboss.logging.Logger; public class Thing {
private static final Logger log = Logger.getLogger(Thing.class); public void doSomething() { log.info("It works!"); } } example: logging

@holly-cummins.bsky.social #RedHat package com.example; import org.jboss.logging.Logger; public class Thing {
private static final Logger log = Logger.getLogger(Thing.class); public void doSomething() { log.info("It works!"); } } example: logging import io.quarkus.logging.Log; Log

@holly_cummins

@holly_cummins don’t make humans tell the computer what the computer
already knows

@holly-cummins.bsky.social “but isn’t that dynamism expensive?”

@holly-cummins.bsky.social no. “but isn’t that dynamism expensive?”

@holly-cummins.bsky.social no. - use Jandex to find use-sites of the
Log class “but isn’t that dynamism expensive?”

Log class - inject a static logger field $logger “but isn’t that dynamism expensive?”

Log class - inject a static logger field $logger - replace all calls of Log.method with calls to $logger.method “but isn’t that dynamism expensive?”

Log class - inject a static logger field $logger - replace all calls of Log.method with calls to $logger.method … all at build time “but isn’t that dynamism expensive?”

@holly-cummins.bsky.social logging: compiled version public class MyService { // injected
private static final Logger $logger = Logger.getLogger(Thing.class) public void doSomething() { $logger.info(“It works!”); } }

@holly-cummins.bsky.social what if… you could inherit boilerplate Hibernate queries from
a superclass, instead of having to write them all? example: hibernate

@holly-cummins.bsky.social #RedHat @ApplicationScoped public class GreetingRepository { public Entity findByName(int
name) { return find("name", name).firstResult(); } void persist(Entity entity) {} void delete(Entity entity) {} Entity findById(Id id) {} List<Entity> list(String query, Sort sort, Object... params) { return null; } Stream<Entity> stream(String query, Object... params) { return null; } long count() { return 0; } long count(String query, Object... params) { return 0; } } example: hibernate with panache

@holly-cummins.bsky.social #RedHat example: hibernate with panache @ApplicationScoped public class GreetingRepository
implements PanacheRepository<Greeting> { public Entity findByName(int name) { return find("name", name).firstResult(); } }

@holly-cummins.bsky.social #RedHat DAO example: hibernate with panache @ApplicationScoped public class
GreetingRepository implements PanacheRepository<Greeting> { public Entity findByName(int name) { return find("name", name).firstResult(); } } repository pattern

@holly-cummins.bsky.social #RedHat example: hibernate with panache

@holly-cummins.bsky.social #RedHat example: hibernate with panache active record pattern @Entity
public class Greeting extends PanacheEntity { public String name; public LocalDate issued; @Version public int version; public static List<Greeting> getTodaysGreetings() { return list("date", LocalDate.now()); } }

@holly-cummins.bsky.social why was this even hard? public class PanacheEntity {
public static <Entity extends PanacheEntity> List<Entity> listAll() { // but… how do we know which entity to query? throw new UnobtainiumException(); } }

public static <Entity extends PanacheEntity> List<Entity> listAll() { // but… how do we know which entity to query? throw new UnobtainiumException(); } } signature can be generic

public static <Entity extends PanacheEntity> List<Entity> listAll() { // but… how do we know which entity to query? throw new UnobtainiumException(); } } implementation cannot be generic signature can be generic

@holly-cummins.bsky.social here’s what we do @Entity public class Order extends
PanacheEntity { // … original class // injected in the bytecode // we add a Order.listAll method public static List<Order> listAll() { return DbOperations.listAll(Order.class); } }

@holly-cummins.bsky.social machine efficiency unlocked human efficiency we broke the tradeoff

@holly_cummins #RedHat but magic

@holly_cummins #RedHat magic should always be optional + debuggable

@holly-cummins.bsky.social why #RedHat

@holly-cummins.bsky.social happiness is the most important thing

@holly-cummins.bsky.social happiness is the most important thing developer

@holly-cummins.bsky.social lower resource usage saves money

@holly-cummins.bsky.social lower resource usage saves money smaller memory footprint

@holly-cummins.bsky.social lower resource usage saves money smaller memory footprint less
cpu usage

@holly_cummins #RedHat does being faster and lighter mean quarkus is
greener?

@holly_cummins #RedHat waste is killing the planet

@holly_cummins #RedHat e-waste is killing the planet

@holly_cummins #RedHat energy waste is killing the planet

@holly_cummins #RedHat inefficient software is killing the planet

@holly-cummins.bsky.social sustainability saving planet doing stuff we want to do

@holly-cummins.bsky.social the vrroooom model gives hope but …

@holly-cummins.bsky.social invented by Dr. Vroom (really!)

@holly-cummins.bsky.social naming is the hardest problem in computer science invented
by Dr. Vroom (really!)

@holly-cummins.bsky.social naming is the hardest problem in computer science

@holly-cummins.bsky.social my vrroooom model

@holly-cummins.bsky.social #RedHat

@holly-cummins.bsky.social #RedHat these two columns are almost the same

@holly-cummins.bsky.social #RedHat Energy 1 10 100 Time 1 10 100
energy efficiency across programming languages Python Rust Java Go

@holly-cummins.bsky.social #RedHat Energy 1 10 100 Time 1 10 100
the trend line is more or less straight energy efficiency across programming languages Python Rust Java Go

@holly-cummins.bsky.social #RedHat vrrrooom model: speed is a useful proxy for
energy efficiency

@holly_cummins #RedHat capacity Source: John O’Hara Setup: • REST +
CRUD • large heap • RAPL energy measurement Assumptions: • US energy mix climate impact at low load (single instance) lower is better

CRUD • large heap • RAPL energy measurement Assumptions: • US energy mix climate impact at low load (single instance) line length shows max throughput lower is better

CRUD • large heap • RAPL energy measurement Assumptions: • US energy mix climate impact at low load (single instance) quarkus on JVM has the lowest carbon … because it has the highest throughput line length shows max throughput lower is better

@holly_cummins #RedHat saving planet coding how we wanna code we
beat the tradeoff

@holly_cummins #RedHat tl;dpa (too long didn’t pay attention) deployment density
lower cloud bill frictionless development experience Medium Nano auto-provision services live coding continuous testing don’t make people tell the computer what the computer already knows greener reducing waste indexes moving work so it hurts less only doing work once

slides Holly Cummins Red Hat https://hollycummins.com/quarkus-joy-oredev @holly-cummins.bsky.social

Less waste, more joy, and a lot more green: How...

Less waste, more joy, and a lot more green: How Quarkus makes Java better

More Decks by Holly Cummins

Other Decks in Programming

Featured

Transcript