adoptium VS amber-docs

Used the recommended JRT https://adoptium.net/

Wandered through the https://github.com/hneemann/Digital site and saw past issues with JRT but no obvious solution.

I have a couple hundred GALs of same or similar model number of new old stock

Oracle Java is shit use https://adoptium.net/ or another one

Some options for those who prefer to avoid the Oracle minefield:

https://adoptium.net

https://aws.amazon.com/corretto

https://www.azul.com/downloads

https://bell-sw.com/pages/downloads

Sadly, no-one has managed to package it yet, but we should get something in the next couple of days. Since 21 is an "LTS" release, major Linux distributions will provide a runtime pretty soon. Ubuntu backports them to old releases too.

https://adoptium.net/ This link?

I'm using this one on MultiMC. https://adoptium.net/

some of these will take care of java for you, others are more manual. if you need java, I recommend https://adoptium.net/

You can totally use VSCode. It's Java support is quite good (it really uses Eclipse under the hood basically). You can compile Java code by hand if you install the Java Development Kit. You can also use a build tool to help you. Maven is the most used one. It has a bit of a learning curve but makes using libraries a lot easier.

Record patterns are one step on the path to general pattern matching utility. The bigger building block is general deconstructors. I recommend reading Functional Transformation of Immutable Objects by Brian Goetz. The idea of "withers" shown there requires deconstructors:

https://github.com/openjdk/amber-docs/blob/master/eg-drafts/...

This is the vague plan.

You may be joking but...

Here is the much more detailed version: https://github.com/openjdk/amber-docs/blob/master/eg-drafts/reconstruction-records-and-classes.md

This kind of pattern matching is discussed in the design notes: https://github.com/openjdk/amber-docs/blob/master/site/design-notes/patterns/pattern-match-object-model.md

True, but that only pushes the question of value down the line.

I'm curious about lenses because Java did have a serious problem that required a solution: working with "simple" data correctly was difficult. The chosen solution was ADTs, so we did buy into that. But the approach being explored for transforming records (https://github.com/openjdk/amber-docs/blob/master/eg-drafts/...) only works one level at a time rather than for an entire path. So I wonder how valuable it would be to have a solution for paths. If the answer is that it's mostly valuable for an approach we haven't bought into yet, then we might not need to consider it just yet.

Just a heads up, something like that spread operator is actually coming sooner or later to java: https://github.com/openjdk/amber-docs/blob/master/eg-drafts/...

Pattern matching (for records) is already a preview feature.