With about 450 Proposals, 1800 attendees, 70 speakers and 50+ sessions, J-Fall 2023 organized by the NLJUG was one to remember. Celebrating the 20th anniversary, with people from all over the world, we took a moment to appreciate the great community that is available to us as Java developers.
With that being said, here are some of my takeaways from the sessions I attended this edition. Missed out? Don’t you worry, the recordings will be available on their youtube channel.
The Art of Software Development
Sander Mak had the opening keynote “The Art of Software Development”. He stated that the term software “engineer” is not really the correct way to describe our profession. Sure, some concepts are based on (computer) science such as algorithms with their Big O notation that we might need remember for job interviews. However most of the time we are solving real problems by creating an abstraction of reality. Much like a painter, an artist, who paints the world as he sees it.
“Programming is an extremely creative profession. It’s logic based creativity.” - John Romero, id Software
By understanding the importance of the creative processes that we use to solve problems, we should strive to eliminate as much clutter as we can in order to enhance our thinking process. One way to do this is by finding a style that fits your team and project. Use automated tools to standardize code styles, make agreements on best practices, adhere to them and dare to challenge existing ones.
I also noted down the following:
If we want a new feature, can we take something away instead and if not, can we remove something in return?
Removing complexity is something we (or at least I) seem to forget sometimes. We like to add stuff and make things bigger and better, but what about losing some of the complexity and cognitive load once in a while? From what I’ve seen so far this seems underrated and ofter seems scarrier than it is.
Moving Java Forward Together
Following Sander, Sharat Chander talked about “Moving Java Forward Together” by highlighting the importance of the Java Community and emphasizing the power of working together. In order to become a better software developer we can not only rely on our own experience and knowledge. By being a mentor and by finding a mentor within the community, your company or your team we do not only grow as a person and software developer but we can create long-lasting friendships.
Going AOT: Everything you need to know about GraalVM for Java applications
In her talk about AOT with GraalVM, Alina Yurenko showed us how we can use GraalVM to create a native image of our application. GraalVM has been taking our cloud game to the next level, but what I appreciated most about this talk is that we got an honest comparison of the different options we have. Sometimes we don’t need AOT as JIT could out perform AOT if our application runs long enough. The JVM will start optimizing the code and will be able to handle higher throughput.
So it begs the question, does our use case really need AOT, or will JIT with JVM optimization be a better choice? Perhaps we need some sort of hybrid option such as AOT with Profile-Guided Optimizations which enables us to collect profiling data in advance to create a pre-optimized image?
I would say give it a go, check your benchmarks and of course check your requirements!
Optimizing Java Startup and Warmup: Exploring the Power of CRaC on Embedded
While we are on the subject of quick startup times, Frank Delporte told us about what CRaC is and how embedded systems can benefit from it (e.g. quicker startups for your infotainment system in your car). It kind of follows the same pattern as AOT with profiles but with some interesting twists.
CRaC allows us to save a checkpoint of a running application, much like saving your progress in a video game. This can be done as an external operation (e.g. via the command line), but it is also possible to create it programmatically. Your application will have to handle certain logic before and after the checkpoint such as closing and restoring connections, but the runtime optimizations and even your heap will be saved and after restarting it will be available again as if nothing ever happened. This also means quick startup times.
It got me into a fun and interesting discussing with a colleague, where could we use this? Could we take a snapshot after running our integration test suite to including the optimizations of most process flows? This snapshot could then be used for our application on other environments. Your could even go as far and deploy your application for different customers pre-optimized and ready to go.
This would however only work if we could save without keeping the data, as it would be problematic if the in-memory data is leaked into a production environment or to another customer instance.
What about restoring a process which crashed due to an external timeout? No need to write progress to a file or database but continue with your heap as if nothing happened.
I would like to see some more implementations and examples of Java on CRaC while it matures, only time will tell…
Final words
All in all, I enjoying going to JFall once more. I’m looking forward to apply some of the insights and ideas I’ve gotten from the sessions and I’m exited to see the progress on our road to quicker start up times and better performance.
(Un)fortunately there were too many great sessions to attend, but I believe these are some of the subjects that are worth sharing. Let me know what you think, and I hope to see you there next year - you don’t want to miss it!
As some people dared to say: JFall is the best one day conference in Europe.
