Developer Voices

If You Want Better Code, Do It For Me (with Jonathan Schneider)

Feb 14, 2024

Jonathan Schneider, one of the authors of OpenRewrite, discusses the power of automated code-rewriting tools and how they work. Topics include engineering challenges at Netflix, rewriting Terraform, and implementing an internal compiler. They also touch on the decision-making process for using libraries and language support for Gleam and WebAssembly.

01:02:48

Creator website

Episode guests

Jonathan Schneider

AI Summary

AI Chapters

Episode notes

Podcast summary created with Snipd AI

Quick takeaways

Refactoring tools, linters, code formatters, and code searchers are fundamental and useful tools for software developers regardless of the programming language they use.

The process of parsing code involves writing regular expressions to create a logical representation called an abstract syntax tree (AST), which is then used for refactoring, searching, critiquing, or pretty printing the code.

OpenRewrite enables code transformations on large code bases by leveraging lossless semantic trees (LSTs), making it scalable for processing hundreds of millions of lines of code and offering features beyond refactoring like code linting and search.

Deep dives

The power of refactoring tools

Refactoring tools, linters, code formatters, and code searchers are fundamental and useful tools for software developers regardless of the programming language they use.

Introduction

2min

Engineering Tools and Challenges at Netflix

6min

Writing a Java syntax tree rewriter

15min

Rewriting Terraform and the Challenges of Building a Parser Grammar

5min

Printing the Abstract Syntax Tree

2min

Implementing an Internal Compiler

19min

Challenges of Using Libraries and Code Transformation Tools

8min

The Decision-Making Process and Language Support

6min

A lot of programming is split into the mechanical work of writing what you know, and the creative work of figuring out what you don’t know. Wouldn’t it be nice to automate the mechanical stuff away?

Well the good news is we’re already automating a lot of it. Every time you run a refactoring tool or a pretty-printer, you’re handing boring work off to the computer. But how does that magic work, and how can we do more of it?

This week we’re joined by one of the authors of OpenRewrite—Jonathan Schneider—to learn how automated code-rewriting tools really work. From the basic approach to the hairy corner cases, to the reality of keeping developers happy with the subjective side of the results.

It takes a lot of work to automate work away - this week we’ll learn how the work gets done for us too.

–

OpenRewrite: https://docs.openrewrite.org/

Supported Languages: https://docs.openrewrite.org/recipes

Moderne: https://www.moderne.io/

Gradle Lint: https://github.com/nebula-plugins/gradle-lint-plugin

Chicory (Native JVM WASM): https://github.com/dylibso/chicory

Call Java from Haskell: https://github.com/tweag/inline-java#readme

Call Haskell from Java: https://github.com/nh2/call-haskell-from-anything

Kris on Mastodon: http://mastodon.social/@krisajenkins

Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/

Kris on Twitter: https://twitter.com/krisajenkins