Karl Heinz Marbaise on foojay.io - Friends of OpenJDK

Foojay Podcast #73: JCon Report, Part 2 – Evolutions in the Java language and runtime

Mon, 16 Jun 2025 07:42:00 +0000

In the second part of our JCON interviews, recorded at the conference in May, we focuses on general evolutions within the Java world and how they influence how we write code and develop applications. We take a look back at the history of Java, discuss new features in the latest release, how Java evolves with OpenJDK projects and JEPS, how Java is used in education, and much more…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Foojay Podcast #50: JCON Report, Part 2 - Maven, Software Security, Code Quality

Mon, 27 May 2024 08:07:54 +0000

This is part 2 of the interviews we recorded at the JCON conference earlier this month in Germany. In this episode, you get two main topics: Maven and Code Quality.

In the first part, you’ll hear Karl Heinz Marbaise and Steve Poole discuss the Maven project, the repository, Sonaytype, and the security impact of dependencies.

But next to security, we developers are also responsible for creating readable and maintainable code. Miro Wengner, Marit van Dijk, and Hinse ter Schuur dive into this topic, in the second part!

Spring Boot: Strategy Design Pattern - Convenience and Limitation

Fri, 30 Oct 2020 09:22:41 +0000

You might have already used the strategy pattern in relationship with Spring Boot where it is very convenient to use.

You simply define an interface for example (I use the prefixing I only in these examples for clarity):

public interface IOneStrategy {
 void executeTheThing();
}

Define some implementations like this:

@Service("FIRST")
public class OneStrategyFirst implements IOneStrategy {

 @Override
 public void executeTheThing() {
 System.out.println("OneStrategyFirst.executeTheThing");
 }
}

Now you can simply implement a service which will execute the appropriate strategy based on the given name which looks similar like this:

Stream.concat vs. New ArrayList Performance

Thu, 27 Aug 2020 05:34:58 +0000

During a code review, I suggested some code improvements related to JDK8+ streams. The original code looked very similar to the following:

List<Element> result = content.getFancyStuffs().stream()
 .flatMap(item -> {
 List<Element> objects = new ArrayList<>();
 objects.add(item.getElement());
 objects.addAll(item.getElements());
 return objects.stream();
 })
 .collect(toList());

Some more details here — the getFancyStuffs() returns a list of FancyStuff elements. The FancyStuff class contains two getters where getElement() returns a single Element whereas the getElements() returns (guess what?) a list of Elements.