Tim te Beek

Tim te Beek

Staff software engineer at Moderne

Nijmegen, The Netherlands


Tim te Beek is a staff software engineer at Moderne, which automates software refactoring at scale. He has extensive experience contributing to and presenting on Open Source software within the Java ecosystem. Previously he worked as a consultant specializing in migration engineering and developer productivity.

Area of Expertise

  • Information & Communications Technology


  • java
  • Architecture
  • microservices
  • refactoring

Fundamentals of Migration Engineering with OpenRewrite

How adaptable is your technology stack to changes in business requirements, technological advancements, and the availability of new and better tools (and avoiding vendor lock-in!)?

When you can more easily secure, upgrade, move, or modernize your code, that means you can adapt quickly and efficiently to changes in technology and markets. That’s what Migration Engineering is all about, which we’ll be exploring in this workshop.

We’ll discuss and demonstrate how to write custom recipes using OpenRewrite, an open source auto-refactoring tool, to study and analyze your code before planning migration and modernization efforts—and then automate code changes for your teams.

You’ll also learn how to write recipes that will automate code search and transformation actions that are custom to your organization.

This is a comprehensive look at all kinds of recipe development. You will come away fully equipped to plan and exercise large scale code transformations in your organization.

From boy scouting to redrawing the landscape

The boy scouting rule encourages folks to leave a campsite a little better than you found it, through small clean ups. When applied to code, developers similarly apply small localized improvements as they work on a feature. But what if there’s an overwhelming amount of technical debt to clean up, and small changes only mean you’re falling further behind?

In this talk we’ll look at automation to really make a dent in your tech debt backlog, through safe code transformations based on OpenRewrite. Next we’ll scale up these automated fixes through the Moderne Platform, and show how you can stop issues from creeping back in. Finally we’ll show how you can compose and define your own rules to extend the open source framework that is OpenRewrite.

Automated software refactoring with OpenRewrite and Generative AI

Couple the precision of a rules-based system with the power of AI. A generative AI procedure samples source code to identify defects and uses OpenRewrite to fix them.

Transforming code with OpenRewrite and Refaster

Any project has its share of code quality issues. And if you think you don't, just wait a while, as existing code patterns and libraries quickly become the old way of doing things. You need to constantly modernize your codebase to keep up, and we’re here to explore tooling that helps you do so.

From a shared passion for code quality, Rick & Tim each arrived at different solutions. Rick is involved with Error Prone Support at Picnic, while Tim works on OpenRewrite at Moderne. Both allow you to manipulate your code to keep things maintainable, but when to use which tool?

In this workshop we’ll explore the relative merits of each tool, as we strive to get rid of common code quality issues affecting codebases. We’ll dive into how you define the changes to make, how to run these code changes, and how to gradually change code and culture across an organization. Walk away with directly applicable fixes, and the toolset and skills to write your own code transformations.

Weeding your micro service landscape

New microservices often start from reference templates of other microservices. But when those copies drift apart, your landscape grows wild and becomes difficult to maintain. Code changes that are not well thought out can lead to hard-to-find bugs and inconsistencies. Then, when new versions or vulnerabilities come out, applying necessary changes becomes difficult and time-consuming. How do you now whip your landscape back into shape?

We’ll explore automation to help your services quickly conform to higher standards again. We’ll apply and update build tool wrappers, modernize your test suites, clear out unused feature flags, upgrade Java versions and frameworks, standardize pipelines, and adopt new libraries and language features. For this, we’ll look at OpenRewrite and the Moderne Platform and CLI, for reliable automated code changes.

Come learn how to phase out old patterns, bugs and failed experiments with speed and horizontal scale. Gain insight into where you stand today, and focus on where you want to go tomorrow.

Maintaining Maven at scale

Twenty years of history, over ninety repositories, maintained by volunteers, yet depended on by an entire ecosystem. That’s the Apache Maven project. This project sure has interesting challenges when it comes to development, and making the best use of volunteers’ time. New features and fixes might take priority over less glamorous clean up, yet all are needed to keep the project maintainable for the future.

In this talk we will look at how we apply improvements to Apache Maven at scale. No one in their right mind would volunteer to make these changes by hand. But by using OpenRewrite and the Moderne platform, we can both leverage existing improvement recipes, as well as develop custom recipes for Apache Maven. We will outline some of the challenges, what’s already been done, what’s coming up next, and how you can help.

Walk away with a little more appreciation for Apache Maven, a look behind the scenes of how it’s continuously improving, and how you can contribute, whether that’d be for Apache Maven, or any other community with similar challenges.

Spring Boot 3 is here; where are you?

Are you stuck upgrading to Spring Boot 3? Did breaking changes break your spirit? Migrate in mere minutes with OpenRewrite. We’ll explore recipes to get you to Spring Boot 3.1, picking up Java 17+, JUnit Jupiter and Jakarta along the way. Don’t put off upgrading any longer; enjoy the benefits today!

In this workshop we’ll explore tooling to migrate to Spring Boot 3.1 and beyond, centered around OpenRewrite. And we’re not just changing version numbers; we’re actually changing code to adopt breaking changes. And with expert guidance on hand you can be sure to be off to a flying start.

Topics for this workshop include OpenRewrite itself, existing migration recipes, writing additional recipes, and the different options to run them. Leave confident that you can deliver this migration on your own!

Major migrations made easy

Conferences love to show you the latest and greatest framework versions and language features. But those new technologies can feel a world away back at work. And it can be hard to justify the time spent to upgrade something that’s not broken, such as JUnit 4.

What if you could migrate in mere minutes? With OpenRewrite you can! A collection of fine grained recipes combine to achieve large scale migrations of frameworks and tools related to the JVM. And since it uses a lossless semantic tree, refactorings are guaranteed safe.

Upgrade Spring, Micronaut and Quarkus. Adopt JUnit 5; switch to AssertJ. Replace Log4j with Logback. Fix Sonar and Checkstyle violations. A world of quick and easy migrations awaits!

I've presented "Major migrations made easy" in 2022 at Devoxx France, Spring I/O, Voxxed Days Luxembourgh, Devoxx Poland, Devoxx Morocco, Devoxx Belgium & BaselOne.
Spring I/O: https://www.youtube.com/watch?v=d8xU24x7Jqo (45 mins)
Devoxx Belgium: https://www.youtube.com/watch?v=7fslFKkCkxg (30 mins)

Target audience would be developers familiar with Java or related technologies, with new language support ongoing.

Modernize your money-maker

Most every company has that one product. The project that’s consistently brought in revenue over many years. But it’s also the one that shows its age, and might not be enjoyable to work with. Sure, the runtime says Java 8 or above, but it feels like something from a different era. And rarely do you find the time or energy to do something about it.

In this talk we will iteratively modernize such an application, mostly through automation with OpenRewrite. We will go through various aspects such as modernizing tests, performing upgrades, fixing code quality issues, and resolving security findings. We will also introduce nudges to gradually improve the code quality and architecture, such that your project will improve over time.

Walk away with an iterative plan you can replicate, no matter if your project is five or fifteen years old, to rediscover the joy in working with your project.

Tim te Beek

Staff software engineer at Moderne

Nijmegen, The Netherlands


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