Sessions
Level Up Your Java Streams with Gatherers
Since Java 8, the Stream API has been a valuable tool for Java developers. However, our hunt for better solutions has often left us wanting more. Until now, we could only use the standard provided intermediate operations on streams, like map, filter, and flatMap. Enter Java’s Stream Gatherers, which allow for adding custom intermediate operations to our streams.
In this session you’ll learn what Gatherers are, where they shine, and how you can implement your own. By the end of the session, you’ll be fully equipped to use this powerful feature in your day-to-day work.
Presented at
Never a Null Moment with JSpecify
Since the beginning of Java we’re used to dealing with NullPointerExceptions.
We tried to prevent null references using project conventions and sprinkling (a lot of) annotations throughout our codebases.
But even with all this tedious work we still run into “null moments”, unexpected NullPointerExceptions showing up at runtime.
One of the reasons this problem has been hard to solve is that Java never had a standard well-defined way to express nullness. Different annotation libraries and tools exist, with slightly different semantics. As a result, annotations often act more as hints than as guarantees.
JSpecify aims to change this.
It’s a collaborative effort by major Java ecosystem stakeholders to define clear, consistent nullness semantics.
With JSpecify, you can set default nullness per package via the @NullMarked annotation, making your intent explicit.
Because of this precision, JSpecify offers a solid foundation to provide null-safety in your libraries and applications.
You don’t need to annotate everything or rewrite existing code to get started. In this session you will learn what makes JSpecify different from other attempts. You’ll also discover how you can start applying JSpecify incrementally in your own production code right away.
Presented at
It takes more than LGTM to do a proper Code Review
A lot of us do code reviews (aka pull requests) on a daily basis. Some people like them, some people don’t. Asking for a code review and getting the feedback could cause uneasy feelings. Providing the feedback on a code review could be challenging too. What to look for and how to provide the feedback. Doing code reviews could take a lot of time. So the big question is: how do we get most out of our code reviews?
In this talk we will look into why we do code reviews and how to get the most value out of these reviews. We’ll cover best practices and do’s and don’ts about code reviews.
Presented at
Mikado and the Art of Refactoring
Do you know this feeling? Still struggling with a big refactoring… you promised your team that it would be finished within a day. But that was two days ago. You cannot just revert, because you already invested a lot of time. You have to go forward. But… the project is not compiling at all.
If this sounds frightening familiar, this session is for you. In this session you will learn how you could avoid this situation by using the Mikado method. This method is about taking small steps, but it also guides the direction for those steps. You will see that by applying some simple rules you can enjoy refactoring, without the fear of getting stuck.
Presented at
Practical Security in a DevOps World
Currently, in the fast changing world we do not release once a year but twice a day. With a traditional security team that needs to check each release this will be a problem. We all know that security is important, since we don’t want our application to be in the news because of a hack. A security department which acts as a tollgate can help in keeping applications secure, but conflicts with the flexibility we would like to have. This talk will provide you with some key takeaways on how you as a Developer can both release fast and often and be secure at the same time.