Rafael Winterhalter
software consultant at Scienta in Oslo
Oslo, Norway
Actions
Rafael works as a software consultant in Oslo, Norway. He is a proponent of static typing and a JVM enthusiast with particular interest in code instrumentation, concurrency and functional programming. Rafael blogs about software development, regularly presents at conferences and was pronounced a JavaOne Rock Star. When coding outside of his work place, he contributes to a wide range of open source projects and often works on Byte Buddy, a library for simple runtime code generation for the Java virtual machine. For his work, Rafael received a Duke's Choice award and was elected a Java Champion.
Links
Awards
Area of Expertise
Topics
A software developer's guide to licenses and other legalities
In the fast-paced world of software development, it is critical for developers to have a clear understanding of the legal landscape surrounding the software that they develop. This presentation will look into the different branches of software licenses and open source. In this context, the presentation will discuss common terms of commercial agreements and what pitfalls to avoid. Finally, this presentation will look into the OpenJDK project and its formal organization. Attendees will gain a solid understanding of the legal and technical considerations of choosing licensed software, enabling them to make informed decisions about their projects.
A topology of Java memory leaks
While most bugs reveal their cause within their stack trace, Java’s OutOfMemoryError is less talkative and therefore regarded as being difficult to debug by a majority of developers. With the right techniques and tools, memory leaks in Java programs can however be tackled like any other programming error. This talks discusses Java’s memory model, categorizes different types of memory leaks that can occur in a Java program and presents debugging techniques for tracing down such errors. Java’s garbage collector is one of the more prominent features of the Java virtual machine. Unfortunately, the comfort of not having to worry about memory allocation makes us vulnerable to not recognizing memory leaks where they can occur in Java. As an unpleasant result, Java applications that leak memory are a rather common event even in production environments. This talk gives an overview of the different types of memory leaks that can occur in a Java application and presents debugging techniques for resolving memory leaks and for reducing a Java application's memory footprint. In the process, we will look into several examples of code that caused memory leaks in real world applications and libraries, where some of the examples might surprise even seasoned Java developers. I will further address the Hot Spot Virtual Machine’s memory model and the changes that were applied to it for its Java 8 release. Furthermore, we will have a closer look at lambda expressions and their considerable potential of introducing memory leaks when they are used incautiously.
An introduction to JVM performance
Writing software for a virtual machine enables developers to forget about machine code assembly, interrupts, and processor caches. This makes Java a convenient language, but all too many developers see the JVM as a black box and are often unsure of how to optimize their code for performance. This unfortunately adds credence to the myth that Java is always outperformed by native languages. This session takes a peek at the inner workings of Oracle’s HotSpot virtual machine, its just-in-time compiler, and the interplay with a computer’s hardware. From this, you will understand the more common optimizations a virtual machine applies, to be better equipped to improve and reason about a Java program’s performance and how to correctly measure runtime!
Bringing structural types to Java and Typescript
One of Java's most prominent features is its type system. While its strict typing is normally a useful aid in writing consistent programs, it can also lead to verbosity. This is especially the case when processing similar types that represent the same or similar data, something that is common in DTO layers, or when versioning data types, two problems that are also current at the Norwegian tax authority (Skatteetaten). This presentation showcases how the introduction of structural types avoids boilerplate in the Norwegian taxation process, without loosing any type safety.
Exploring the Java Class File API
The Java Class File API, currently a preview feature, marks a significant advancement in bytecode manipulation, offering a modern and streamlined approach for interacting with Java class files. This presentation provides an introduction to the Java Class File API, highlighting its key features and capabilities. We will compare it to ASM, the current de facto bytecode manipulation library, examining differences in design, usability, and performance. Additionally, we will analyze the potential impact of the Java Class File API on the Java ecosystem, including how it might influence the development of new tools, frameworks, and libraries, as well as its implications for existing ones that currently rely on ASM.
Making Java more dynamic
While Java’s strict type system is a great help for avoiding programming errors, it also takes away some of the flexibility that developers appreciate when using dynamic languages. By using runtime code generation, it is possible to bring back some of this flexibility back to the Java virtual machine. This talk introduces code generation in general and the library Byte Buddy that is often used for this purpose.
Java and OpenJDK: a beginner's guide
With its ninth version, the Java platform has shifted gear and introduced biyearly releases. This was quickly followed by a license change where Oracle, the steward of Java, now publishes a commercial and a non-commercial release of the OpenJDK while other vendors also took more space to promote their alternative builds. And in another flood of news, the Java EE specification was terminated and resolved into the Jakarta EE namespace.
A lot has been happening in the traditionally conservative Java ecosystem, to say the least, and many users are wondering if they can still rely on the platform. This talk offers orientation to those that wonder about the state of Java, explains the OpenJDK project including its builds and licensing and summarizes the changes that have been, that to expect and why the change of pace is good news to the community.
Event-sourcing microservices on the JVM
Event-sourced applications only apply changes to their state by processing a persisted sequence of event messages. Using this model, it is possible to fully trace and explain any change that ever occurred within a system and to recreate any past state that the system has ever held. These properties motivated the Norwegian tax authority, Skatteetaten, to reimplement its register for subjects to taxation using such an event model. This talk gives an outline on how event sourcing is realized while dealing with asynchrony and eventual consistency of message processing within a system of distributed services. In this context, challenges of performance are also discussed. This talk also introduces an Oracle-based event store that is implemented in Java and that was developed for use in this project.
The definitive guide to Java agents
Java agents and their instrumentation API offer developers the most powerful toolset to interact with a Java application. Using this API, it becomes possible to alter the code of running applications, for example to add monitoring or to inject security checks as it is done by many enterprise products for the Java ecosystem.
In this session, developers will learn how to program Java agents of their own that make use of the instrumentation API. Doing so, developers learn how the majority of tooling for the JVM is implemented and will learn about Byte Buddy, a high level code generation library that does not require any knowledge of Java byte code that is normally required for writing agents. In the process, developers will see how Java classes can be used as templates for implementing highly performant code changes that avoid the boilerplate of alternative solutions such as AspectJ or Javassist while still performing better than agents implemented in low-level libraries such as ASM.
The Java memory model made easy
At first glance, writing concurrent programs in Java seems like a straightforward task. But the devil is in the details. Fortunately, these details are strictly regulated by the Java memory model which, roughly speaking, decides what values a program can observe for a field at any given time. Without respecting the memory model, a Java program might behave erratically and yield bugs that only occur on some hardware platforms. This presentation summarizes the guarantees that are given by Java's memory model and teaches how to properly use volatile and final fields or synchronized code blocks. Instead of discussing the model in terms of memory model formalisms, this presentation builds on easy-to-follow Java code examples.
Tracing distributed (micro-)services: how APM for the JVM is working
With the ascent of distributed architecture, modern software increasingly unwinds into networks of micro(-service) components. While this approach to building software - if done correctly - can improve a system's maintainability and scalability, distributed applications also introduce challenges for operations. Where monolithic applications typically offered direct access to extensive monitoring dashbords, such easy overview is no longer available when a multitude of services is connected loosly on a network. But how to keep track of a system of such dynamic state? Distributed tracing is a method of connecting interaction of different services on a network. Collecting and processing such tracing information again allows for the observation of a distributed system in its entirety. This talk shares the presenter's insights gained by working on the JVM-support of distributed tracing for the APM tool Instana. Doing so, it introduces the landscape of distributed tracing on the JVM, discussing popular approaches such as Dapper, Zipkin or Brave/OpenTracing. In the process, it is discussed how byte code instrumentation can be used to capture systems without requiring a user to set up the software under observation. The presentation finishes with a discussion of typical problems of distributed tracing solutions and carefully examines the performance penalties APM tools entail.
Understanding Java byte code
Java, Scala, Groovy: in the end, all JVM languages compile down to the class file format and Java byte code. It is thanks to the flexibility of this intermediate instruction set that the JVM became a platform so rich in languages. And the ability to generate byte code at run time is a prerequisite for many popular libraries such as Spring or Hibernate. This talk gives an introduction to compiled Java code and discusses different libraries for generating classes at run time. At a first glance, Java byte code can appear to be some low level magic that is both hard to understand and effectively irrelevant to application developers. However, neither is true. With only little practice, Java byte code becomes easy to read and can give true insights into the functioning of a Java program. In this talk, we will cast light on compiled Java code and its interplay with the Java virtual machine. In the process, we will look into the evolution of byte code over the recent major releases with features such as dynamic method invocation which is the basis to Java 8 lambda expressions. Finally, we will learn about tools for the run time generation of Java classes and byte code. Among those tools, I will present Byte Buddy, a novel open source code generator which is an attempt to considerably simplify run time code generation in Java.
Exploring the JDK's class file API
A long row of tools and libraries for the JVM rely on processing class files and Java byte code to function. With the JDK's accelerated release cycle, this has created tedious upgrade requirements, as the class file format is changing with each release.
To synchronize byte code tooling with the release cycle, the JDK is about to introduce a class file API that handles the processing, and to compete with ASM, today's de-facto class file processor.
This presentation takes a look at the JDK's class file API, compares it to ASM, and gives a perspective on how the class file API might get adopted and how it might help to overcome today's upgrade requirements in the future.
Implementing a concurrent job queue using Java and SQL
Batch processing is a common concern of many Java applications and many frameworks and libraries offer functionality for it. In this presentation, a library that implements a concurrently executing job queue is introduced which is used at the Norwegian tax authority (Skatteetaten) and that was published on GitHub. (https://github.com/Skatteetaten/skatteprosessen-task)
This presentation discusses the details of implementing this task processor using Java's concurrency APIs and SQL to allow executing tasks concurrently from multiple threads and JVMs.
Rafael Winterhalter
software consultant at Scienta in Oslo
Oslo, Norway
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top