Generative AI on millions of lines of code; a recipe for success?

Generative AI can be a powerful force multiplier for developers, but it also comes with limitations. Developers are expected to co-create with AI, and check the generated output, or risk hallucinations running wild. This can aid development at a local machine, but what happens when you try to apply these tools on a massive scale?

At Moderne we've explored Generative AI for our users, as stewards for OpenRewrite and the Moderne Platform, to automate code changes as scale. In this talk we'll take you through our lessons learned as we tried our hand at AI, to tell you what worked, and what failed, such that you can learn from our experiences. It will be an honest look back, and brief look ahead on our process, to show you how our customers can now reliably leverage AI for code modernization.

Write your custom OpenRewrite recipes

OpenRewrite allows you to automate the maintenance on your code. A large collection of existing recipes allows you to upgrade, improve and secure your applications. But what if you want something beyond what’s already available out of the box?

In this live demo we’ll explore writing custom OpenRewrite recipes. That might be small additions to existing migration recipes, or larger efforts to adopt breaking changes. Walk away knowing exactly how to upgrade that internal library or framework, or how to contribute recipes that everyone can then use.

There can be only one!

Java developers are spoiled for choice: competing standards are vying to be the one true way you log, test, query, inject dependencies or handle web requests. But with choice also comes a proliferation of half thought out experiments, new or outdated ways to do things, and an increasing pressure to make sense of it all. What was a valid choice a decade ago, could now be the reason you’re called up in the middle of the night to patch a vulnerability. What if there were an easier way? A way to consolidate on your one true tech stack? And migrate with ease when preferences shift?

In this talk we’ll look at how you can achieve tech stack consolidation, by evaluating the options available to you, choosing the one true way to fit your process, and phase out any alternatives that came before. We’ll look at automation through OpenRewrite, which offers you an easy way to move between competing standards with automated migration recipes. Gone are the days of being stuck with choices made a decade ago. Today’s the day you choose your own path forward. Vendors: take note! Your users might be gone tomorrow.

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.

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.

Expected 'true' was 'false'

Plenty of libraries allow you to write tests, but not all of them are equal. When tests pass you'll hardly see any differences. But when tests fail, your choice of a library can help or hinder troubleshooting.

In this talk we'll explore AssertJ, and the fluent assertions API it provides. We'll contrast this to alternatives like JUnit and Hamcrest, and show how subtle differences improve the experience.

We will also look at optimizing your usage of AssertJ, to get more meaningful error messages. Finally, a quick OpenRewrite recipe helps apply all these best practices at once.

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.

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.