Category Archives: Conferences

[javaone 2025] know your java

Posted on by
Reply

Speaker: Venkat Subramaniam

See the table of contents for more posts

Exercise 0 – warm up

  • How many years have you been doing Java

Exercise 1 – Collection’s remove

  • An ArrayList containing 1, 2, 3 becomes 1, 3 when call remove(1)
  • If you change to Collection<Integer> numbers = new ArrayList<>, what happens.
  • It is [2,3] because uses method on Collection, not on the ArrayList
  • “Code always does what you type and not what you mean”

Exercise 2: type inference

  • Exercise 1 but with var numbers = new ArrayList<>()
  • now it is [1,3] because var uses type on right which is ArrayList
  • Just because you like type inference doesn’t mean use it all the time. Determine when right thing to do

Exercise 3: Arrays.asList()

  • Arrays.asList(1, 2, 3)
  • Which of add/set are printed and what is in list?
  • add throws exception, set works so it is [1,2, 2]
  • Lesson: quit using asList. Use List.of instead

Exercise 4: forEach

  • .forEach(name -> upper.add(name))
  • worked until made one change
  • side effects is the problem (change was probably making it parallel)
  • forgot “it works on my machine”. better is “it failed on my machine”. Want it to fail on your machine instead of in prod
  • The lambda is not pure. A pure function is idempotent. Returns same result for same input regardless of how many times it is called.
  • A pure function does not emphasize anything outside it. It is ok to mutate; it’s like changing clothes. Just don’t do so in public; aka as a side effect
  • A pure function does not depending on anything outside that may possibly change.

Exercise 5: stream

  • int[] factor= new int[]1,2,3};
  • stream = numbers.stream().map(n -> n * factor[0]);
  • factor[0] = 0;
  • stream.forEach(System.out::println)
  • 000 because lazy evaluation

My take

This was cool. It wasn’t Venkat’s usual style. It was more interactive. He had a QR code to a Google form for each exercise so the audience could reply. That’s a great technique. If I ever have to present remotely about certifications, I’m going to copy it! It was interesting seeing the Google form results A lot of mixed results

[javaone 2025] A New Model for Java Object Initialization

Posted on by
Reply

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

Posted on by
Reply

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.