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
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.
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.
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.
Developing with GitHub Copilot can feel like having a colleague with decades of experience, most all of it on outdated Java 8. While Copilot is quick to suggest solutions, it's slow to pick up new language features, libraries and frameworks. So how do you then ensure consistent code quality and reliability with this increased productivity?
In this talk, we’ll look at automated corrections applied to any code, whether your own, your colleague’s, or from AI assistants. Prevent repeating outdated patterns in new codebases, with tooling built around OpenRewrite, an open-source deterministic refactoring engine born at Netflix in 2016. Discover new ways of working from automated suggestions on your pull requests by coupling the precision of OpenRewrite’s rules-based system with the power of AI. This combination allows you to pick up new features and frameworks while you work.
Stop outdated training data from keeping you stuck in the past. Learn how to incorporate automated refactoring and remediations that improve your code into your workflow.
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.
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!
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.
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