Java: The Brave Companion in the World of Enterprise Software Solutions!

Enterprise solutions are designed to address the multifaceted requirements of businesses and organisations. Compared to solutions designed for consumer use, enterprise solutions typically have a longer development lifecycle and require a higher level of investment, and it is not only the development cycle, enterprise software tends to have a longer lifespan than consumer-facing solutions. The lifespan of enterprise software can vary considerably, dependent on several factors, including the complexity of the solution, the specific requirements of the organisation in question, and the pace of technological advancement. This is partly due to the higher level of investment required, the greater degree of integration with existing systems, and the need for a longer return on investment. Probably a significant amount of development teams will be involved in the software development life cycle (SDLC) of such systems. It can be reasonably assumed that a considerable number of these systems will undergo phases of reengineering, refactoring, or redesign during this period. The process is influenced by the fact that technology is an ever-evolving field, and the tools and solutions that are currently in use may become obsolete in the near future. The notion that a design solution will remain effective indefinitely is no longer a valid assumption. Consequently, the objective is to develop solutions that can be repeatedly deployed to address evolving issues, becoming progressively more sophisticated, elegant, and intelligent over time. Choosing the right set of tools or platform is a critical decision that will have a profound impact on every level of an organisation. The JVM is one of the most robust, dependable, well-maintained, secure and stable platforms for enterprise solutions globally.

A number of scientific disciplines have illuminated the complex mechanisms underlying the evolution, adaptation, and healing of biological systems, enabling organisms to not only survive but also to flourish, with life spans that greatly exceed those of humans. These solutions from a distant past demonstrate the value of celebrating, understanding, and appreciating the past as a foundation for future progress. It is a challenging task to advance rapidly and not to be tempted by the hubris of complete disruption to move forward. It is essential to strive for strategic improvement and change, with a cautious understanding of potential consequences and a commitment to building something better in their place.
It is not enough for us, as professionals engaged in the development of systems and structures, to merely create solutions that enhance the quality of human life. Rather, we should focus on designing for the well-being of the whole environment. Resources are finite! In this era of rapid change, it’s vital that our solutions are constantly up to date with the significant changes taking place in our world.

We have a duty and a responsibility to deliver and maintain applications with higher levels of usability and sustainability. We should ask big questions such as: what are the long-term implications of our decisions?
Designing long-lasting systems requires a thoughtful approach that incorporates golden principles and powerful tools.
The Java development team has adopted a strategy that integrates proven principles, thereby facilitating the evolution of the Java platform and the creation of innovative features. Furthermore, the team has adapted and delivered new features that enable developers to address present challenges, establish a robust foundation for the future, and provide a long-lasting platform that allows critical applications with a long lifespan to be in production today and in the future.
Maintaining and evolving the JVM and the Java language often requires the implementation of breakthrough features that significantly improve performance or security. The key is to communicate these changes effectively and ensure that users understand the trade-offs involved in adopting new versions. By doing so, the Java team can foster a culture that embraces change rather than resists it, encouraging organizations to try new features and take advantage of the improvements in performance, security, or footprint.
The Java programming language has undergone significant changes before September 2017, but the introduction of a regular release cadence encourages developers to adopt new practices and tools. By releasing a version every six months, developers have access to new features and improvements more frequently. By committing to a predictable schedule, Java has mitigated the risks associated with long periods of stagnation, enabling teams to innovate continuously.
In my opinion the most remarkable features present on each LTS version released since Java 8 are as follows:

Java 8: The Functional Push

• Lambda expressions,  method references, and the Stream API brought a functional programming paradigm to Java, making code more concise, expressive, and often faster. Parallel processing with streams opened doors to efficient data manipulation, especially for large datasets.  Stream API, which allows for efficient processing of sequences of elements, enabling parallel processing and improved performance. [Performance Enhancements & Modern Language Features] JEP 126: Lambda Expressions; JEP 335: Method References; JEP 107: Enhanced for Loop

• The new Date and Time API provided a standardized, reliable, and well-designed approach to date and time handling, crucial for building consistent and predictable systems. The Optional class tackled the age-old problem of null pointers, fostering cleaner code and reducing potential errors. JEP 150: Date & Time API
• Improved security features, including updates to the Java Cryptography Architecture (JCA) and enhancements to the Java Secure Socket Extension (JSSE). [Enhanced Security] JEP 114: TLS Server Name Indication (SNI) Extension; JEP 115: AEAD CipherSuites; JEP 121: Stronger Algorithms for Password-Based Encryption ;JEP 123: Configurable Secure Random-Number Generation; JEP 124: Enhance the Certificate Revocation-Checking API;JEP 131: PKCS#11 Crypto Provider for 64-bit Windows; JEP 166: Overhaul JKS-JCEKS-PKCS12 Keystores

Java 11: Modernization and Efficiency

• The HTTP client API provided a streamlined and modern way to interact with Web services. JEP 321: HTTP Client API
• The removal of obsolete modules like Java EE and CORBA streamlined the JDK, making it more efficient and less prone to compatibility issues. JEP 320: Remove the Java EE and CORBA Modules
• The Java Flight Recorder (JFR) captures a wide range of events from the JVM, including memory usage, CPU activity, thread states, and garbage collection events. This comprehensive data collection helps developers diagnose issues and optimize application performance. JEP 328: Flight Recorder
•  Garbage Collector (GC) improvements were added, including the introduction of the Z Garbage Collector, which optimizes memory management and reduces pause times. ZGC is designed to handle large heaps (up to several terabytes) while maintaining low pause times, typically under 10 milliseconds. This makes it suitable for applications requiring high responsiveness. [Performance Enhancements] JEP 333: ZGC: A Scalable Low-Latency Garbage Collector
• Added var keyword for local variable type inference, this feature enhances code readability, especially in cases where the type is obvious from the context, such as with collections or complex types.  [Modern Language Features] JEP 286: Local-Variable Type Inference

Java 17: Enhancing Security and Performance

• Sealed classes provided a powerful tool for controlling inheritance and controlled class hierarchies. This improves code clarity and reduces the potential for errors. JEP 409: Sealed Classes
• Pattern matching, facilitates the streamlining of type checking and casting operations, thereby enhancing the clarity and readability of the code in question. This feature enables the user to ascertain whether an object is an instance of a particular class and, if so, to cast it to that class in a single operation. This obviates the necessity for a distinct cast, thereby diminishing the amount of superfluous code. [Modern Language Features] JEP 406: Pattern Matching for switch
• The new MacOS rendering pipeline improves the performance of Java applications on a popular platform. JEP 382: New macOS Rendering Pipeline
• Foreign Function & Memory API was introduced as part of the ongoing effort to improve Java’s interoperability with native code and memory. This API allows Java programs to safely and efficiently access foreign memory outside of the Java heap, enabling better integration with native libraries and systems. JEP 412: Foreign Function & Memory API (Incubator) and JEP 454: Foreign Function & Memory API (final)
• Continued performance improvements with enhancements to the JIT compiler and optimisations in the Java Virtual Machine (JVM), resulting in faster execution times. [Performance Enhancements] JEP 317: Experimental Java-Based JIT Compiler. Introduced in Java 9; JEP 295: Ahead-of-Time Compilation. Introduced in Java 9; JEP 410: Remove the Experimental AOT and JIT Compiler. Introduced in Java 17; JEP 421: Deprecate the Applet API. Introduced in Java 9; JEP 418: Vector API (Incubator). Introduced in Java 16.
• Enhanced security with features such as Deprecate the Security Manager for Removal which provides better control over the use of native code, and improvements to the TLS protocol. [Enhanced Security]. JEP 411: Deprecate the Security Manager for Removal. Introduced in Java 17; JEP 844: TLS 1.3 Support. Introduced in Java 11; JEP 825: TLS 1.3 in the Java SE Platform. Introduced in Java 17.

Java 21: The current Java LTS

• String templates introduced a modern way to create strings with embedded expressions, making code more readable and maintainable. Virtual threads (Preview) promised to simplify concurrent programming by providing lightweight threads, potentially leading to significant performance improvements. JEP 430: String Templates (Preview) Introduced in JDK 21; JEP 459: String Templates (Second Preview) Introduced in JDK 22; JEP 425: Virtual Threads (Preview) Introduced in Java 19; JEP 436: Virtual Threads (Second Preview). Introduced in  Java 20. JEP 444: Virtual Threads. Introduced in Java 21
• Sequenced collections offered new data structures that preserved element order, providing more options for building well-behaved and predictable systems. Pattern matching for switch (Preview) and scoped values (Preview) further enhanced code clarity and data management, paving the way for cleaner and more robust applications. JEP 431: Sequenced Collections. Introduced in Java 21; JEP 406: Initial introduction of pattern matching for switch. Introduced in Java 17; JEP 420: Pattern Matching for switch Second preview . Introduced in Java 18; JEP 427:  Third preview. Introduced in Java 19; JEP 433: Fourth preview. Introduced in Java 20; JEP 441: Finalized in JDK 21; JEP 429: Scoped Values (Incubator) Introduced in Java 20; JEP 446: Scoped Values (Preview) Introduced in Java 21; JEP 464: Scoped Values (Second Preview) Introduced in Java 22; JEP 481: Scoped Values (Third Preview) Introduced in Java 23; JEP 487: Scoped Values (Fourth Preview) Introduced in Java 24;
• Virtual Threads. This feature represents a further enhancement of the support for virtual threads, which facilitates concurrent programming by enabling developers to write code that can handle multiple tasks concurrently, without the inherent complexity of traditional thread management. JEP 425: Virtual Threads ( Preview). Introduced in Java 19; JEP 436: Virtual Threads (Second Preview). Introduced in Java 20; JEP 444: Virtual Threads. Introduced in Java 21;

Java 23 ( No LTS)

• Primitive Pattern Matching – JEP 455: Primitive Types in Patterns, instanceof, and switch (Preview)
  This feature facilitates enhanced pattern matching by enabling developers to utilise primitive types in all pattern contexts. This results in a more straightforward and secure code when working with patterns.
• The incorporation of Markdown support within JavaDoc – JEP 467: Markdown Documentation Comments. Java 23 introduces support for Markdown in JavaDoc comments, thereby facilitating the production of more readable and easier-to-write documentation. This enables developers to utilise Markdown syntax for formatting, thereby enhancing the overall documentation experience.
• The Class-File API – JEP 466: Class-File API (Second Preview). The new Class-File API standardises access to Java class files, thereby facilitating the reading, modification and creation of class files at the programmatic level. This is particularly beneficial for tools and libraries that require the manipulation of bytecode.
• Scoped Values – JEP 481: Scoped Values (Third Preview). Building on the scoped values introduced in earlier versions, this JEP refines the application programming interface (API) for sharing immutable data across methods and threads, thereby promoting more effective data management practices in concurrent applications

In this article, I’m excited to give you an overview of the enterprise software landscape and showcase why the evolution of the Java platform makes the JVM such a powerful and useful technology. It looks at the key considerations and advancements that have shaped the development and longevity of enterprise-level solutions. There are five main things to take away from this article:

• Enterprise solutions have a longer development lifecycle, higher investment, and longer lifespan compared to consumer solutions. This often requires reengineering and adaptation to evolving technology, which is a fantastic opportunity for developers to really add value and make a real long-term impact.
• The Java Virtual Machine (JVM) is a robust and secure platform for enterprise solutions. It’s a great foundation to build powerful, reliable software on.
• Java has undergone significant improvements with each Long-Term Support (LTS) release, introducing features like functional programming, security enhancements, performance optimisations, and modern language features;
• The Java team has adopted an impressive strategy of integrating proven principles and delivering new features to address current challenges and establish a robust foundation for the future;
• The regular release cadence encourages developers to continuously adopt new practices and tools, mitigating the risks of long periods of stagnation.

 

---

Ixchel Ruiz

Karakun AG – Basel, Switzerland