In the article, the example with the switch works because it switches on the class of the instance.

When inline is used on a parameter, it instructs the compiler to inline the expression at the call site. If the expression is substantial, this creates considerable work for the JIT compiler.

Requesting inlining at the compiler level (as opposed to letting the JIT handle it) is risky unless you can guarantee that a later compiler phase will simplify the inlined code.

There's an important behavioral difference between Scala 2 and 3: in 2, @inline was merely a suggestion to the compiler, whereas in 3, the compiler unconditionally applies the inline keyword. Consequently, directly replacing @inline with inline when migrating from 2 to 3 is a mistake.

https://github.com/CRaC/

    record AppVersion(int major, int minor, int patch) implements Comparable {
      public static AppVersion of(String version) {
        var array = Arrays.copyOf(Arrays.stream(version.split("\\.")).mapToInt(Integer::parseInt).toArray(), 3);
        return new AppVersion(array[0], array[1], array[2]);
      }

      public int compareTo(AppVersion other) {
        return Comparator.comparingInt(AppVersion::major)
            .thenComparingInt(AppVersion::minor)
            .thenComparingInt(AppVersion::patch)
            .compare(this, other);
      }

      public String toString() {
        return "%d.%d.%d".formatted(major, minor, patch);
      }
    }

For me, this is where lies the design flaw, trying to support both inheritance and be immutability at the same time.

https://en.wikipedia.org/wiki/Alleged_Libyan_financing_in_th...

  https://quickstarts.snowflake.com/guide/getting-started-with-cortex-aisql/index.html

And the main page let you compare API versions https://javaalmanac.io/

It's 4 (mid) to 7 years (flagship) for Samsung.

https://www.androidauthority.com/samsung-android-updates-114...

For a long time, Java was like, every classes is a library, i do not think it's a failure of OOP, it's a failure of Java.

But I'm optimistic, I choose to see recent additions like records and pattern matching has a step in the right direction.

  static final Complex CONSTANT = new Complex(1, 2);

  static final StableValue STABLE_VALUE = StableValue.of();

  Complex getLazyConstant() {
    return STABLE_VALUE.orElseGet(() -> new Complex(1, 2))
  }

I think it's fair to call that semantics "implicit".

I've no idea if this fact still holds when the security manager will be removed.

see https://blogs.oracle.com/java/post/multilingual-engine-execu...

The jep does not explain how to prepare to new Java bytecodes and future enhancements. Am i suppose to only run with the latest version of Java if i want to use that library ?

This was trivial a long time ago. Now, all Java GCs move objects in memory.

So you have to use composition.

[1] https://en.wikipedia.org/wiki/History_of_Python

[1] https://javaalmanac.io/