Java Tech News

2021-10-21 12:00:12 GraalVM 21.3 version has been released
#graalvm
New features of GraalVM 21.3 release:
• Java 17 LTS support
• Compiler optimizations such as: strip mining optimization, enhanced automated vectorization, infeasible path correlation optimization
• New tool: proftool — provides machine-level details about the execution to aid with JIT performance analysis
• Native Image optimizations of memory consumption, build time and the size of native executable
• Improved the usability and precision of the built-in CPU sampler tool
• New Enterprise container images and a new set of Community container images
• And many other Truffle-related updated.
https://medium.com/graalvm/graalvm-21-3-is-here-java-17-native-image-performance-updates-and-more-ac4cbafcfc05 Open / Comment

2021-10-20 12:00:16 Who uses RTSJ?
#rtsj
RTSJ was firstly implemented by TimeSys. This implementation (i.e., a RTSJ-compliant VM and a RTSJ reference implementation) supports all versions of Linux. Later, Aicas GmbH provided a different RTSJ implementation in their JamaicaVM, supporting a wide range of real-time operating systems, such as Linux, VxWorks and QNX. In addition, there are also other virtual machines which are compliant with RTSJ, e.g., jRate, OVM and Aero JVM.

Among these VMs, JamaicaVM provides hard real-time guarantees and is the mostly adopted VM for executing RTSJ applications. Currently, JamaicaVM supports RTSJ V1.0.2 and is working towards RTSJ 2.0 implementation based on Java 8.
https://eprints.whiterose.ac.uk/159681/1/TECS_From_Java_to_Real_Time_Java_A_Model_Driven_Methodology.pdf Open / Comment

2021-10-20 00:00:05 Real-time specification for Java (RTSJ)
#rtsj
When the Java Community was formed, the very first effort was the specification for real-time Java, JSR 1. It was started in 1998. The second version of RTSJ 2.0 is still under review for over than 7 years! The frist version of the spec was completed in about 8 years...

The specification provides additional APIs and more precision in JVM and library behaviors in the following areas:
• Threads
• Scheduling
• Memory Management
• Synchronization
• Time
• Clocks and Timers
• Asynchrony
• System/Options

The RTSJ is an essential refinement of Java semantics and libraries for safety-critical applications plus additional APIs to support realtime and embedded programming. These systems are used to protect humans from injury or danger. Safety-critical systems must go through exhaustive testing and a line-by-line code review before certification.
https://www.aicas.com/download/rtsj/rtsj_80.pdf Open / Comment

2021-10-19 12:00:07 Facts about String
#lang #jvm
All string literals in Java programs are represented with java.lang.String class.
• A String represents a string in the UTF-16 format.
• String concatenation operator is implemented by a compiler. For example, latest javac compiler will use java.lang.invoke.StringConcatFactory when sees + sign.
• charAt(int) is always O(1) even with random access
• Before JEP 254 strings with Latin-1 characters had unused 1 byte of storage, hence half of the space taken by a single char was unused.
• Compact Strings appeared with JEP 254 and brought coder field and backed char[] value store has been changed to byte[] value. It allows to reduce string memory footprint for Latin1 characters.
• You can't modify String class with Reflection API because it's protected by strong encapsulation of modules (provided by Java 9). The whole java.lang module was encapsulated by default. Open / Comment

2021-10-18 12:00:20 Class Loaders
#runtime #jvm
Every Class object contains a reference to the ClassLoader that defined it. In addition to loading classes, a class loader is also responsible for locating resources (e.g. properties, images, .class files). When a class loader finds a class by URL, it needs to link it. Linking is the process of taking a binary form of a class or interface type and combining it into the run-time state of the JVM, so that it can be executed.

The Java SE Platform API historically specified two class loaders:
• Bootstrap class loader — the logical classloader that has responsibility for loading the classes (and resources) that are found in the boot-classpath - typically the core Java platform classes (/jre/lib). Usually it's implemented in native code.
• System class loader — the default delegation parent for new class loaders and, typically, the class loader used to load and start the application. This one loads your application's classes and libraries's classes from the classpath.

208 viewsVladislav Chernogorov, 09:00

Open / Comment

2021-10-18 00:00:08 What is Biased Locking and why it became deprecated?
#lock #concurrency #jep
Biased Locking — an optimization in the VM that leaves an object as logically locked by a given thread even after the thread has released the lock. The idea was to optimize common situation when a thread reacquires the lock — then reacquisition can be achieved at very low cost, which saved about two compare-and-swap atomic operations. The downside was in the expensive revocation operation when another thread decides to acquire the lock.

JEP 374 has been released in Java 15 following deprecation and disabling of biased locking. Applications that benefit from this optimization are now considered legacy and will never migrate to newer versions. Newer applications generally use the non-synchronized collections (e.g., HashMap and ArrayList) or concurrent collections from Java 5. Biased locking introduced a lot of complex code into JDK and HotSpot and it is going to be refactored in newer versions.
https://openjdk.java.net/jeps/374 Open / Comment

2021-10-17 12:00:15 Difference between JPA, Hibernate and Spring Data JPA
#jpa #spring #hibernate #orm
Prior JPA release any enterprise Java developers used lightweight persistent objects provided by either persistence frameworks (such as Hibernate) or DAO (data access objects). Due to a popularity of ORM frameworks and complicated dependencies between different relational databases, OpenJDK decided to implement a common programming interface (JPA).

JPA (Java Persistent Context) specification appeared in 2006 to unify the Java Data Objects (JDO) APIs. The most of the features were brought by JDO, Hibernate and TopLink. Today, every ORM framework for RDB implements JPA, including Hibernate.

Spring Data JPA is an implementation of the Repository abstraction that is a key building block of domain-driven design. It transparently supports all available JPA implementations using EntityManager under the hood.
https://www.wikiwand.com/en/Jakarta_Persistence Open / Comment

2021-10-16 00:00:06 What it's like to be a Google Developer Expert?
#gde #gcp #community
GDE — is a Google Developer Expert, a person who does not work at Google, and who is recognized for his activity and expertise on a Google technology.

GDE selection process:
• GDE person should be consistently contributing to the open-source communities somehow related to Google Stack.
• You need to be nominated by a Google employee for a Google Open Source Peer Bonus award.
• So, after being proposed by a Googler, there is a GDE selection process:
1. You create a profile in a dedicated platform, with all details about your google-related contributions for review
2. Interview with a member of the GDE community
3. Interview with a Google employee

GDE benefits:
• Recognition!
• Having various event opportunities: GDG, DevFest, blogging, mentoring, etc.
• Insiders in the related Google dev community.

https://www.loicmathieu.fr/wordpress/en/informatique/je-suis-google-developer-expert-gde-sur-les-technologies-google-cloud-platform-gcp/ Open / Comment

2021-10-15 00:00:17 Spring Integration — a Friend of Enterprise Integration Solutions
#spring #integration #messaging
The main idea behind Spring Integration framework — is loosely decoupling between components of an enterprise solutions. This model can be implemented with a simple producer-consumer messaging channel, where this channel is responsible for managing inbound and outbound data loads. In short, you this framework allows developer to create a simple mechanism of data transformation using reactive approach. Here's an example of a simple IntegrationFlow:
@Bean
public IntegrationFlow myFlow() {
return IntegrationFlows.from("input")
.filter("World"::equals)
.transform("Hello "::concat)
.handle(System.out::println)
.get();
}
This approach would be suitable for business system with different kind of service communication: email, SOAP, RESTful web services, sockets, ftp, etc.
https://docs.spring.io/spring-integration/reference/html/overview.html#overview Open / Comment

2021-10-14 00:00:00 Apache Kafka — an event streaming platform
#kafka #streaming #events
Kafka implements event streaming concept — when an event source (producer) like DB, sensors, mobile devices, cloud services produces ANY type of events and send them in real-time to a consumer. Conceptually, Kafka is a log-oriented store for events, each holding a singular key/value pair. The store is commonly partitioned, and the partition for an event is typically chosen based on the key's value (computed by a hash function).

Kafka is a distributed system consisting of servers and clients. Servers provide pre-built brokers for various systems to export, for example, logs, metrics and other telemetry from your app to the database of your choice. Clients allow you to write distributed applications and microservices that read, write, and process streams of events in parallel. Clients are shipped with community-developed libraries written in Go, Python, Java, C/C++ and many other as well as REST APIs.
https://kafka.apache.org/ Open / Comment