Java 10 introduces JShell, which allows developers to quickly try out Java code snippets and operations without needing to compile full programs or write test classes. It provides an interactive interface for testing code. Java 10 also includes local variable type inference with "var", which allows declaring variables without specifying the type as long as the type is clear from the initialization value. This simplifies code. Other new features include parallel full garbage collection and application class data sharing to improve performance, but most new features are under the hood improvements rather than things developers directly use in programming.

1. Java 10 - Key Note
The purpose of this article is not just to discuss key features of java 10 instead we’ll go over the circumstances where it’ll be
useful and quickly try our hands out. Believe me it’s a great time-saver.
As a programmer by interest, I’ve tried hands over different programming languages and noticed that, if java lacks something
then it is a tool or an interface to try out code snippet or keywords quickly (“on-the-go”).
I think many among the readers of this blog have had pain of writing test classes to try out the logic that goes as part of your
source code. There might also be a situation where a developer wants to verify some sort of string, primitive variable
operations, accessing native/OS provisioned metrics, APIs encapsulated in java util package and so on and so forth, whereas
a few other languages like Python, Javascript, Go, C++ etc., have an interface or console to try out such little snippets quickly.
Hence introducing JShell for you.
Please go ahead and install Java 10 JDK so that we can get started while you can quickly run some code on your machine.
(NOTE: Beware that after installation Java10 will be your default java. Make sure to backup existing setup and rollback your
settings after this exercise)
Many good features were introduced in Java 9 but unfortunately it hasn’t seen the light of the day for much long. So, we can
say that it’s declared outdated by the community. As I mentioned before JShell was one of significant features introduced in
Java 9 and also available with Java 10 which is declared LTS version may be until March 2025.
JShell
I call it “Java OTG (On-The-Go)” coz it’s like an interface that you’ll use when you really want to quickly try it out.
Assuming Java 9 or 9+ JDK installed on your computer, the easiest way to fire JShell is to just type jshell on command-
prompt/terminal.
For everything that you try on jshell if you want an interactive message feedback or log or an acknowledgement, set verbose
mode for current session.

2. Variable declaration:
Variable and Data operation:
If the result of an operation is not assigned to a user declared variable then, the value is associated to an internal variable,
Before going further digging into more options I would suggest checkout help command. As a caution, type ‘/’ before help
Typing help without ‘/’ you will end up creating a null reference for variable intro.
As explained in feedback, intro is declared to be of type help. But since there is not type help created the variable intro is
created but cannot be used as it has to type reference.
Now to give a life to the variable “intro”. Let’s create a class help.

3. But still intro is null. Why? Because we haven’t allocated an object, variable or a memory reference to variable intro.
Moral of the story, jshell commands should be used preceding with a forward slash ‘/’ or else you might end up creating a
variable with null reference which has no significance and obviously IMHO a bad practice.
Local Variable Type Inference
This is curios topic because from now on for all those programmers who have the feeling why java is strict with variable
initialization unlike other functional programming languages like python. After lambda, supplier, consumer and streams now
java has introduced us with var type inference. So, what is it??
In the earlier versions to declare a variable we had to define appropriate type and assign/initialize/access it. With java 10
while declaring local variables all you got to do is just say “var”.
Correct Usage:
Incorrect Usage:
What if I assign a different type value after initial assignment. In this case the assignment will fail to compile.

4. Other important characteristics here:
1. var is NOT a key word rather it’s a reserved type. Like int, float, etc., this is mainly because to provide backwards
compatibility for code generated before java 10.
2. You cannot leave var uninitialized. Ex. var abc;
3. Cannot assign var to null. Ex. var abc = null
4. Cannot use var to declare class member variable.
5. Cannot be used in method argument definition
One potential area where Local Type Inference has significant role is when we are “programming to interfaces”.
For example, in case of facade design pattern or even factory design patterns, we pretty much know what the return object
is supposed to be. Hence there is no real need to explicitly declare define local variable that will eventually be assigned with
return object.
Another benefit I see here, it encourages developers to follow better and meaningful naming conventions when declaring
methods and method documentation.
Example usage of var -
1. Loop statements - For, while, do-whiles

5. 2. In Branch constructs. Note the declared type of consumer and consumerAccountId
Continued …

6. Other Features
There are a few other features introduced in Java 10 but we won’t be directly interacting with them on our day-to-day
#programminglife.
Hence, I would prefer to list them all but describe only those which are interesting yet critical in the order I think would be
useful for developers. And then leave it up to you guys to discover more.
Thread-Local Handshakes
I suggest please don’t mistake this with ThreadLocal and InheritedThreadLocal concepts that we extensively use in
multithreading. In fact, this is mostly related VM safe point and handshaking of individual or a bunch of threads
Parallel Full GC for GC1
• GC1 – Garbage Collector First is a redesigned garbage collection mechanism introduced in Java 7
• Since then it has been upgraded and updated to make it more performant in Java 9
• In simple words, instead of performing Mark and Sweep on complete Young Generation and Old Generation heap
individually, GC1 divides heap into small chunks of Old, Eden, Survivor and Unassigned heap spaces.
• Once this virtual division is made, then GC1 will perform “Initial Mark” by pausing application execution when GC is
initialized for creating reference to young objects created in heap,
• Performs “Concurrent Mark” while application is executing to check status and usage of references from Initial Mark.
• Then performs “Final Mark” and “Evacuation” by suspending the application.
• The whole process is known as “Concurrent Mark and Sweep”
• Java 10 has now made it possible to execute the whole process is parallel
• Aggregate most of GC source-code which is scattered across HotSpot VM into a single/common interface that
be easily called from variety of join-points in HotSpot VM
Application Class Data sharing
o Class Data sharing introduced in Java 5 allows to maintain a memory map of executable at runtime.
o CDS helps to bootstrap class loader hence improving performance but for system classes only.
o Application CDS extends CDS
o Application CDS opens door for built-in platform class loader, built-in system class loader and customer class loader to
load archived class ex., my-usefull-microservice-app.jar.
o To quickly try out Application CDS feature follow the steps below
§ Let’s quickly create a simple spring boot app using Spring Initializer à https://start.spring.io/
§ Give it a name à my-microservice
§ “cd” into the application root directory

7. § Create a list of class that to be archived
java -Xshare:off -XX:+UseAppCDS -XX:DumpLoadedClassList=my-microservice.lst -cp my-microservice.jar
my-microservice
input is “.jar”
output is “.lst”
§ Create a shared/sharable archive from the list of classes dump in “.lst” file
java -Xshare:dump -XX:+UseAppCDS -XX:SharedClassListFile=my-microservice.lst -
XX:SharedArchiveFile=my-microservice.jsa -cp my-microservice.jar
input is “.lst”
output is “.jsa”
§ Now we’ll start the executable spring-boot application from the archive that we have just now created
java -Xshare:on -XX:+UseAppCDS -XX:SharedArchiveFile=my-microservice.jsa -cp my-microservice.jar
my-microservice
• Experimental Java based JIT compiler
• BCP47 Unicode support
• Heap allocation for external memory location
• Default Root certificates now comes with Java 10
• Time-Based version. For ex. java 10.0.2 2018-07-17 or java version "10.0.2" 2018-07-17
• Convergence of JDK forest repositories into single repository interface.
With this I’m leaving it over to you to read more, explore and share if this triggers the curious techie inside you!
Thank you so much for reading! We’ll meet again… Until then keep exploring! Bye.