Every programming language provides ways to express our ideas and then translates them into reality. This thread will explore ten #Java programming features used frequently by developers in their day-to-day programming jobs.
Collections are used to store, sort, search, and iterate objects. It provides a few basic interfaces, such as List, Set, Map, and their implementations. The traditional way of creating Collections may look verbose. Therefore, #Java 9 introduced a few very concise factory methods.
#Java 10 introduced type inference for local variables, which is super convenient for developers.
The traditional switch statement has been in Java from the beginning, which resembled C and C++. It was ok, but as the language evolved, it hasn't offered us any improvement. #Java 14 introduced a new way of looking at this switch statement, and it offers much more rich features.
Although records are relatively new features in Java, released in #Java 16, many developers find it super helpful to create immutable objects.
public record Point(int x, int y) {
}
We often get null from a method instead of a value with the specified type. An invoker cannot know this upfront unless it invokes it. It’s a violation of the contract. #Optional is the rescue.
Every developer is confused with date-time calculation to some degree. This was mainly due to not having a good Java API to deal with dates and times in #Java for a long time. #Java 8 brings an excellent API set in java.time that solves all the date time-related issues.
Every developer hates the NullPointerException. It becomes challenging when StackTrace doesn’t provide helpful information it. From #Java 14 and onward, we get more details in the StackTrace, which is super convenient.
#Java 8 brings CompletableFuture. We can easily accomplish three rest calls in three different cores using it. It gives us a way for multiple independent units of a program to be executed independently.
Lambda Expression is probably the most powerful feature in the #Java language. It reshaped the way we write code.
And the Stream API.
"Lambda Expressions are the gateway drug to #Java 8, but Streams are the real addiction.
- Venkat Subramaniam.
We all want to move on and migrate our code to the latest JDK to have more concise, clear, and improved idioms. However, there is a cost to this. It takes time, and often we are afraid of it.
Perhaps we shouldn't be afraid anymore.
🧵👇👇👇
Migrating code manually is a tedious process, but what if we could query the code the way we do it on the database and then apply the changes?
👇👇👇
It looks like we can with some of the available tools. e.g. ClassGraph, JavaParser, OpenRewrite and many more. 👇👇👇
#Java 19 introduces virtual threads to the Java platform for the first time; this is the primary deliverable of OpenJDK's Project Loom.
This thread is all about it:
🧵
⬇️⬇️⬇️
Java is made of threads. When we run a Java program, its main method is invoked as the first call frame of the main thread created by the Java launcher. It gives us many things: sequential control flow, local variables, exception handling, single-step debugging, and profiling. ⬇️
It makes our lives easier by providing exception handling with informative stack traces and serviceability tools that let us observe what's happening in each thread, providing remote debugging, and creating an illusion of sequentiality that makes our code easier to reason.
⬇️
#Java 19 is a major release, IMO. It includes several game-changing features that will alter the Java landscape. Many features intrigue my interest, but there are five in particular that I can't wait to try out. Let's break those down and talk about them separately.
🧵
⬇️⬇️⬇️
Under the umbrella of Project Loom, JEP 425 introduces virtual threads, which aim to dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications on the Java platform. ⬇️
Structured Concurrency allows you to treat multiple tasks running on different threads as an atomic operation, making multithreaded programming easier. As a result, error handling and cancellation will be simplified, reliability will increase, and observability will be boosted.⬇️
Quick recap: #JavaEE was renamed #Jakarta EE; it transitioned from JCP to Eclipse foundation. It opened the door to open governess, open compatibly testing (open TCK), and of course, open-source.
70-80% of java applications use JakartaEE APIs one way or another. e.g. Tomcat, Hibernate, ActiveMQ, Jetty, CXF, Jersey, RESTEasy, Quarkus, Microprofile, Spring. Dig a little deeper, and you will find @JakartaEE APIs.
#Java has been and continues to be the most popular language over the last two decades. After many discussions with Java developers, I have concluded the following seven key reasons why Java developers still love Java after all these years.
1. Community:
In every major city, you will find a Java user group that helps developers achieve the required skills, voluntarily and for free, who help distribute resources and solutions, increase networking, and expand #Java knowledge globally. dev.java/community/jugs/.
2. Language and Platform
An expressive and easy-to-read language helps new developers quickly get used to the existing codebase. #Java is an open-source programming platform with great documentation support. It's a platform that houses and enables a wide range of other languages.