[javaone 2025] Fallacies of Software Development

Speaker: Nathaniel Schutta

See the table of contents for more posts


Note: This is not a live blog. I took notes during the session and posted this after as I was expecting a phone call. Also, I missed the last 10 minutes for said phone call.

  • Architect as a service 
  • We like to reinvent the wheel
  • We take for granted people know what we know. Ex. New people haven’t heard of Gang of Four book
  • Answer to many things is it depends 
  • Often seems insignificant in the moment. Find out later matters. Patterns help with this 
  • Software has similarities. Got tired of putting a front end on a database   Will always be doing app modernization 
  • Learn from parents mistakes   Save time. 
  • Higher bandwidth conversation when use words like facade
  • Humans have patterns too
  • NIH. Not invented here. Not my idea 
  • Think can build better than off the shelf. Usually not true but sometimes is   Focus on differentiator.  Politics. Turf war. Jealous/budget
  • Meta work is more interesting than the work 
  • Some people need spotlight. Arsonist firefighter  not a zero sum gene. Goal is to make better software. 
  • Some people missed sharing and golden rule in kindergarten 
  • Value if created something. People valued resale at 63% if built ikea item 
  • Dangerous “that’s how we’ve always done it”. Counter with asking if has to be that way 
  • Status quo is free. What does it cost. Opportunity cost?
  • Are customers proud of hand rolled project 
  • Wouldn’t get on a plane if no maintenance in last year. 
  • Great presenter. Visuals. Quotes. Few words per slide 
  • Sunk. Cost fallacy. I had pizza for lunch. Might as well have an entire cake for dinner 
  • Ok to ask why something is. New hires will notice. Others used to seeing it 

My take

I’ve seen him speak before and he is excellent. Good visuals/few words on a slide/excellent pace and storytelling

[javaone 2025] A New Model for Java Object Initialization

Speaker: Dan Smith

See the table of contents for more posts


General

  • Dictionary says initializing is to set something to a starting position/value/configuration
  • Dangerous things happen if don’t satisfy invariants
  • Initialize – local variables, fields, arrays, classes, class instances, specific objects, components, modules, frameworks, systems

Variables

  • Well behaved variable always initialized before used
  • If final, only one initialization
  • Local variables checked at compile time
  • Whether the default value is an initial value depends on programmer intent
  • Final fields are good because must be initialized/can’t be mutated. However don’t prevent reading before initialization. (via constructor calling a method)

Class initialization state

  • Uninitialized – init hasn’t started yet, class can’t be used
  • Larval – init code running in specific thread; other threads block. Can see default values or final values changing. Can see accidental state
  • Initialized – init completed, class can be used
  • Erroneous – init threw exception. Class may never be used

Instance initialization

  • Some code runs early in construction like passing things to another constructor
  • Other code runs later like instance initializers or constructor bodies

JEP 492 – Flexible constructor bodies

  • Allows more code to run in early phase.
  • Can have lines of code before this/super call
  • Larval state now split into early and late larval
  • Early larval – constructor code is running up the hierarchy
  • Late larval – nrolling down the hierarchy. starting from when Object superclass initialized
  • In early larval, can’t use this or invoke instance methods
  • In late larval, be careful. this can be shared; field may change value, final fields may change
  • Instance initializers considered early larval
  • Array creation expressions produced an initialized array. Programmers don’t see a larval state.

Why change?

  • Initialization bugs are subtle and hard to see
  • Value classes must initialize fields before sharing larval object so JVM can freely make copies
  • Allows null checked variables to ensure cannot be null so can’t have a default value

Future

  • Want to change the timing so field initializers and implicit super() run in early phase.

My take

It was like getting a pick behind the scenes. I also learned that larval is a state. (said in Q&A that concept exists now for classes but doesn’t use term. And for instances the concept is there but don’t use the term state) The beginning was slow and I was worried I would be bored. But it got better

[javaone 2025] sneak peak at the stable values API

Speaker: Per Minborg

See the table of contents for more posts


Like Schrödinger’s Cat, find out if immutable when look

General

  • StableValue – class in JDK
  • JEP 502 – stable values. Maybe preview in Java 25
  • Deferred Shallow Immutability.
  • Significant performance gains
  • Codes like lazy initialization; performs like a constant

Motivation

  • Why create object up front (ex: static) if might not need it
  • Singleton pattern needs synchronization to be correct, Showed double checked locking singleton initialization. Easy to get wrong. For example, if you don’t use volatile, can read partially initialized field.
  • With array, volatile doesn’t help becasuse elements aren’t volatile so need method handle to make volatile
  • These solutions are a bunch off code even if you get them right.

StableValue

  • Generic class. Create as empty: private final StableValue<Logger> logger = StableValue.of()
  • Use logger.orElseSet(() -> Logger.create(X.class) – API guarantees this lambda will be only called once
  • StableValue guaranteed to not change value
  • Better to use Supplier: static final Supplier<X> SUPPLIER = StableValue.supplier(X::new) and then just call SUPPLIER.get()
  • StableValue.list(SIZE, _ -> new X()) – immutable list
  • IntFunction<X> FUNC = StableValue.intFunction(size, _ -> new X()) – creates multiple singletons. Pass index to get that singleton to use.
  • Function<Integer, Double> F = StableValue.function(Set.of(1, 2, 3), i -> i*2))
  • StableValue.map(Set.of(1, 2, 3), i -> i*2))
  • List<Integer> LIST = StableValue.list(SIZE, x -> y)

Notes

  • Fibonacci sequence is no longer exponential. Figures out values as need them. Way faster
  • Why called stable and not lazy – because lazy is only one of the properties
  • Don’t have to make static, but faster if do
  • Stable value for record is much faster than for class because guaranteed to be immutable

StableContainer

  • StableContainer COMPONENTS = StableContainer.of(providers…) – this isn’t in the JEP so not sure if this is a local interface

Deferred Immutability

  • Mutable – non final
  • Stable (Stablevalue) – can update anywhere. if two threads updated, the winner sets the value and then becomes constant
  • Immutable – final – can only update in constructor/class initializer

My take

Nice to get a preview into the future. This was not an API I had heard of. Maybe because it isn’t even in preview yet.