Building Smart Devices using Java on the RaspberryPi - An intro to Pi4J.

A Raspberry Pi is a full Linux PC with a small form factor and a low price of between 6 and 95€. And of course, you can run Java on it. The same kind of JVM applications you know, love, and use on heavy machines can also be used on the Raspberry Pi. "Write once, run everywhere"? Ah yes, that's the promise of Java! But this small board has some additional possibilities you will not find on that fancy server you are running somewhere in the cloud.

Do you need a touch-screen device to interact with your home automation or a machine? JavaFX, the new Raspberry Pi Zero 2 W (15€), and a touchscreen are the perfect and affordable combo to provide the perfect solution. Yes, with its low price but high specifications, Raspberry Pi is opening whole new worlds.

And on top of that, all Raspberry Pis have those 40 magical pins to connect an unlimited choice of electronic components. Measuring temperatures and distances, toggling LEDs and relays, controlling the content on a LED matrix or LCD display, playing the Star Wars tune on a buzzer,... the only limit is your imagination! In this talk, we'll take a look at the current state of Pi4J (www.pi4j.com) and dive into the code of a few of these example use-cases. Let's experiment with Java on a CrowPi - a Raspberry Pi-based laptop - to read values from sensors and control other electronic components, and show the values on a JavaFX dashboard.

Java is not only the server language running on heavy machines! You can do amazing stuff with it on a 15€ computer and gain new knowledge at the same time, like controlling electronic components and different communication protocols.

Optimizing Java Startup and Warmup: Exploring the Power of CRaC on Embedded

Coordinated Restore at Checkpoint (CRaC) is an innovative JDK project designed to significantly reduce the startup time of Java applications. By capturing a fully warmed-up snapshot of a Java process, CRaC enables the launch of one or more JVMs from this checkpoint, resulting in faster time to the first transaction and improved overall code execution speed. Several projects, including Quarkus, Micronaut, and Spring, have recognized the potential of CRaC and are actively working on incorporating it into their frameworks to achieve lightning-fast application startup times, which will have a significant impact on how we run our applications on powerful (cloud) servers.

But CRaC is actually the final step after multiple client projects by Azul in the automotive and IoT industry! Infotainment systems for cars, gateways in electronic systems, and other use-cases require ultra-fast startup of their applications running on embedded ARM32 and ARM64 systems.

So, together, let's explore CRaC's applicability on embedded devices, focusing specifically on the Raspberry Pi, which also uses an ARM processor. It's the ideal and inexpensive playground for experimenting with CRaC to discover its impact on Java application performance. While testing and documenting this process, I learned much about how Java starts an application, compiles the code, and needs time to "warm up." It also gave me insight into how the OpenJDK project is organized and what information you can find in its sources.

Brace yourself for some exciting findings because, as it turns out, using CRaC on embedded devices like Raspberry Pi makes a remarkable difference in optimizing Java application performance!

The CRaC project promises to speed up the start of Java applications by using checkpoints. But what is happening under the hood? What files are being created? Can we use this on embedded Linux systems like Raspberry Pi? Join us on this journey to unlock the secrets of Java startup optimization!

Unlocking the Potential of Bits and Bytes: Reducing Data Footprint for Cost and Eco-Efficiency

In the age of unlimited storage space, we forget to consider the financial and ecological costs. Transmitting and storing data in XML, JSON, or (if you want to hurt people) YAML makes data human-readable, which is great for debugging and testing but is a very inefficient, heavy, and expensive way of handling data. There is a lot we can learn from projects where electronic components are involved. The protocols used in the communication with displays, sensors, and LED strips are all based on the magic ones and zeros.

Many years ago, I switched jobs from web development to a company building electronic devices for the rail industry. Suddenly I needed to understand the power of the smallest data unit we can use in software: bits. Yes, pure ones and zeros! We all know that #FF0000 will make the text red on a web page. But I never realized that the hex value #CB would mean that a train has two toilets, of which the first one is broken, and the second is wheel-chair friendly and occupied. All that info is presented with "1100 1011" in one byte!

In this presentation, we will dive deep into the bits of our computer and experiment together. Let's find out why our alarm clock wakes us up at 06:15 with #007D066D and reveal the meaning behind #3C42A581A599423C, a smiley face. With the use of Spring, Vaadin, and Pi4J on a Raspberry Pi - and some help of the "conference-wifi-gods" - we'll all together discover the magic behind bits and bytes. As a result, we may help our FinOps and EcoOps colleagues to make a positive impact.

As developers, we often overlook the financial and ecological consequences of generating, transferring, and storing massive amounts of data. Let's discover the power of the smallest unit of data: bits!

Join the Friends Of OpenJDK

Foojay.io is a community effort. Almost 200 authors contributed content in the last few years. Each day one or more articles are posted about Java, Kotlin, the JVM, developer tools, etc. But it's also a knowledge base of the various Java releases, changes between versions, command line options for each version, podcasts, event calendars, certification, and so much more.

In this short session, we want to show the various aspects of Foojay and invite all Java developers and users to join.

Foojay.io has been around for several years, and you’re welcome to join in and participate too! Let's spread the love for the OpenJDK and get more people involved in Foojay.

What I Learned About OpenJDK as a Docs Writer

As a teenager, a Commodore 64 and DIY solder kits ignited my passion for computers and electronics. But for some obscure reason, I chose an unexpected path by attending film school. I graduated when video and television moved from analog to digital, and the first connected computers began shaping the foundation of the internet we know today. My journey eventually led me to web and software development, where I discovered Java nearly 15 years ago. Since then, Java has been my primary programming language.

In the summer of 2022, my life took an exciting turn when I joined Azul as a technical writer. Suddenly, I found myself surrounded by people who had been working on Java since the early start and even contributed to some of the core libraries. A whole new world opened for me! I learned more about the OpenJDK project's internals than I ever imagined when I was using Java as a developer...

How many Garbage Collectors do you know in Java? Did you know your Java program needs a warm-up time? Are you familiar with the various stages of the JIT compiler? The ongoing debate between JIT and AOT compilation? And how tools like CRaC, ReadyNow, and Falcon can help you to run your code faster?

Let me take you on a journey through OpenJDK-land, and what I learned about how Java starts an application, compiles the code, and needs time to reach its maximum performance. This expedition will also give you an insight into how the OpenJDK project is organized and what information you can find in its sources.

Brace yourself for some exciting findings because, as it turns out, experimenting with Java on the Raspberry Pi also taught me new things about optimizing Java application performance!