Beware of Computation in static {} Initializer
It’s a quite common practice to prepare immutable data during class initialization and save the results in static final fields. In fact, this is exactly what static initializers are designed for.
However you should be careful using it as it can cause significant performance degradation in new JDK versions as shown in this article.
#java #bug #performance #middle #senior
https://pangin.pro/posts/computation-in-static-initializer

Immutable Data Structures in Java
As part of some coding interviews, the topic of immutability sometimes comes up. There seems to be a bit of a misunderstanding on the concept of immutability, where developers often believe that having a ‘final’ reference is enough to make an object immutable. This blogpost dives a bit deeper in immutable references and immutable data structures. Take a look!
#java #immutability #kotlin #scala #junior #middle
https://www.jworks.io/immutable-data-structures-in-java/

Memory Footprint of the JVM
The JVM can be a complex beast. Thankfully, much of that complexity is under the hood, and we as application developers and deployers often don’t have to worry about it too much. With the rise of container-based deployment strategies, one area of complexity that needs some attention is the JVM’s memory footprint. In this post you can see the two kinds of memory, the differences between them, native memory areas, JVM sizing and what does this all mean for Spring, so be sure to check it out!
#jvm #performance #memory #spring #middle #senior
https://spring.io/blog/2019/03/11/memory-footprint-of-the-jvm

The Open-Closed Principle at an Architectural Level
If you are familiar with the SOLID principles for class design in OOP and if you have ever wondered if you can use them, for example the Open-Closed Principle, when designing the architecture of a system. The Open-Closed Principle, with microservices? Madness! Well, maybe not. Let's dive into it and check it out.
#architecture #middle #senior
https://dzone.com/articles/the-open-closed-principle-at-an-architectural-leve

An Illustrated Guide to Kubernetes Networking
You’ve been running a bunch of services on a Kubernetes cluster and reaping the benefits. Or at least, you’re planning to. Even though there are a bunch of tools available to setup and manage a cluster, you’ve still wondered how it all works under the hood. And where do you look if it breaks? There are a lot of moving parts, and knowing how they all fit in and work together is a must, if you want to be ready for failures read this article!
#kubernetes #containers #middle #senior
https://morioh.com/p/ecb38c8342ba/an-illustrated-guide-to-kubernetes-networking

7 Questions to Ask Yourself about Your Code
Here in this article you can find seven questions that we as developers should ask ourselves each time we commit code. Quality software depends on many factors, but developers are one of the most important ones. Bad software is too often our fault, and by asking ourselves the right questions, we can contribute to good software as well.
#junior
https://techblog.bozho.net/7-questions-to-ask-yourself-about-your-code/

Java Garbage Collection Basics
Here in this article, you can learn the basics you need to know about automatic garbage collection in Java. In just two steps - Marking and Deleting - you will learn the process of deallocating memory handled automatically by the garbage collector.
#java #jc #jvm #junuor
https://dzone.com/articles/java-garbage-collection-2

Migrating from Lombok to Kotlin
As a Java developer, one of the most heard complaints about working Java is the verbosity of the language. One of the main areas where this verbosity really shows up is in the area of data classes.
Since this is such a common issue, several solutions have been created, Lombok being to the most well known. In this guide you will see how to seamlessly go from using Lombok to Kotlin instead. Check it out!
#java #lombok #kotlin
https://www.jworks.io/migrating-from-lombok-to-kotlin/

Var and Language Design in Java
Another great article by our colleague Peter Verhas.
The var predefined type introduced in Java 10 lets you declare local variables without specifying the variable type when you assign a value to it. In the following article, you will learn everything you need to know about var in Java as well as what to expect in the future.
#java #middle
https://dzone.com/articles/var-and-language-design-in-java

A Beginner’s Guide to Java Programming Nightmares
New developers make beginner’s mistakes. A way out of these technological nightmares depends on how well you can follow your own coding processes. Here are explored some of the most common Java mistakes and their solutions with a tour of the horrors of the author’s own early code.
#java #junior #middle
https://jaxenter.com/java-programming-nightmares-156749.html

Definitive Guide To Java 12
Java 12 will be released in a few days and here’s everything you need to know about it. Be it switch expressions, the teeing collector, improved start time thanks to the default CDS archive, or better memory usage due to garbage collection improvements – you will see each feature presented as well as migration options.
#java #java12 #middle #senior
https://blog.codefx.org/java/java-12-guide/

Designing Event Driven Services
This is an amazing series of articles on how to deal with consistency in distributed systems, the right way. Don’t miss it.
Part 1: The Data Dichotomy: Rethinking the Way We Treat Data and Services
Part 2: Build Services on a Backbone of Events
Part 3: Using Apache Kafka for Service Architectures
Part 4: Chain Services with Exactly Once Guarantees
Part 5: Messaging as the Single Source of Truth
Part 6: Leveraging the Power of a Database Unbundled
Part 7: Building a Microservices Ecosystem with Kafka Streams and KSQL
#java #architecture #senior

How to Install Multiple Versions of Java on the Same Machine
SDKMan! is a tool for managing parallel versions of multiple Software Development Kits on most Unix-based systems. It provides a convenient Command Line Interface (CLI) and API for installing, switching, removing, and listing Candidates
https://dzone.com/articles/how-to-install-multiple-versions-of-java-on-the-sa
#sdkman #java

JEP Draft: Add Detailed Message to NullPointerException Describing What is Null
Programming errors like NullPointerExceptions would rarely go to production, however, they might be really hard to troubleshoot as by default they don't contain a message.
Take a look at this new JEP trying to address this limitation available for years in the JDK.
https://openjdk.java.net/jeps/8220715
#jep #java

Java 12: Mapping with Switch Expressions
Java 12 comes with “preview” support for “Switch Expressions”. In this article, you will be looking at the new feature and how it can be used in conjunction with some common Stream operations. Jump in to learn how you can make your code even better with Streams and Switch Expressions!
https://www.javacodegeeks.com/2019/03/java-12-mapping-with-switch-expressions.html
#java #java12 #middle #senior

Microservices Anti-Patterns
In this post, a developer talks about the microservices antipatterns that he's seen while working with clients of all sizes.
https://dzone.com/articles/microservices-anti-patterns
#microservices #architecture #senior

Can instanceof make Unmodifiable Collections faster?
In a battle-hardened code base, all normal bugs were fixed - those that remain are usually quite bizarre. This is a story of one such bug and how it uncovered a less than optimal implementation in the JDK itself.
#bug #java
https://www.opsian.com/blog/can-instanceof-make-unmodifiable-collections-faster/

First Look at JDK 13
Things are moving fast in JDK 13 development! This time around, we review two JEPs that are proposed to target JDK 13 as well as two new JEP candidates, including an extension of the switch statement, first introduced in JEP 325. Let’s dig in!
#java #java13 #news
https://jaxenter.com/keeping-track-of-jdk-13-155201.html

Java: New Developments and Features
Oracle's latest long-term release, Java 11, has been out for several months, Java 12 has just hit the scene, licensing has changed, and MicroProfile is growing. As Java continues to move faster, DZone is committed to educating their readers about the most important new features, why you should move beyond Java 8, how developers are using Java, and more in this article!
#java #news #magazine #dzone
https://dzone.com/guides/java-new-developments-and-features

20 Examples of Using Java’s CompletableFuture
Java 8's CompletableFuture is a versatile tool to have. Here are 20 examples of how you can use it in your code for the best effect. Be sure to check them out!
#java #java8 #middle #senior
https://dzone.com/articles/20-examples-of-using-javas-completablefuture

Continuous Profiling in Production: What, Why and How
Richard Warburton and Sadiq Jaffer talk about the ins and outs of profiling in a production system, the different techniques and approaches that help understand what’s really happening with a system. This helps solve new performance problems, regressions and undertake capacity planning exercises.
#tools #profiling #middle #senior
https://www.infoq.com/presentations/cotinuous-profiling-production