Java 12 String API Updates
Take a look at the latest additions to String API in Java 12.
You will see how to utilize the handy transform(Function) and indent(int) methods.
Moreover String now extends java.lang.constant.Constable which is intended for values that are constants that can be represented in the constant pool.
#java #java12
https://4comprehension.com/java-12-string-api-updates/

Java 12 Released with Experimental Switch Expressions and Shenandoah GC
With the new release comes a number of new and noteworthy features and refinements. Specifically, Java 12 includes a new language feature called Switch Expressions (as a preview feature), a new low-pause garbage collector called Shenandoah (experimental), and improvements to the default G1 garbage collector.
#java #java12
https://www.infoq.com/news/2019/03/java12-released

One Method to Rule Them All: Map.merge()
It is a rare case to read an article explaining a single method in JDK, but this one does it pretty well, it’s about Map.merge(). This is probably the most versatile operation in the key-value universe. But it's also rather obscure and rarely used.
#java #junior #middle
https://dzone.com/articles/one-method-to-rule-them-all-mapmerge

Scrum - The Most Popular Agile Methodology (Refcard)
Scrum is a framework that allows people to productively and creatively deliver products of the highest possible value. This refcard explores the details of Scrum, including theory, values, roles, and events. It also includes a sample of a popular approach to deliver Integrated Increments in a scaled environment.
#management #scrum #junior #middle #senior
https://dzone.com/refcardz/scrum

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