Languages on Backend Engineering Strategy Tools

JVM Languages

Wed, 03 Jun 2026 00:00:00 +0000

JVM-hosted languages beyond Java. Each trades something to gain something, and each found a niche where the trade made sense.

Java was enough. It still is. The honest reason to know Groovy, Scala, and Kotlin is not that they are better — it is that the ecosystem puts them in front of you whether you choose them or not. Build tools, CI pipelines, and frameworks make that decision for you.

A practical tell: if the Java code you are reading starts to feel syntactically off — closures where you did not expect them, type inference that seems too aggressive, operators that should not be there — you are probably looking at Groovy, Scala, or Kotlin. Worth knowing enough to recognise each and get things done.

Also worth noting: Java itself has been catching up fast. Virtual threads, records, sealed classes, pattern matching, a faster release cadence — the gap between “Java” and “a more modern JVM language” has narrowed considerably. The case for leaving Java for something else on the JVM is weaker now than it was five years ago.

Groovy

Dynamic, optionally typed JVM language with a syntax that is a superset of Java. Groovy code is often valid Java. The dynamic parts — closures, metaprogramming, GStrings — are what made it popular as a scripting and DSL language.

Where you find it today:

Gradle build scripts: the Groovy DSL is the original Gradle scripting language (now being replaced by Kotlin DSL)
Jenkins pipelines: Groovy is the language of Jenkinsfile declarative and scripted pipelines
Spock framework: expressive BDD-style testing for JVM projects

Groovy’s peak was the early Gradle/Jenkins era. Kotlin has taken over most of the “better Java scripting” use cases. Still found widely in CI/CD tooling — if you work with Jenkins or older Gradle builds, you will write Groovy.

Groovy shows up in Gradle builds and Jenkins pipelines. Know enough to read and modify it; not a reason to seek it out.

Scala

Statically typed functional + OOP hybrid on the JVM. Strong type system, pattern matching, immutable data by default. Compiles to JVM bytecode and interops with Java libraries.

Where you find it today:

Apache Spark: the dominant big data / data engineering platform is written in Scala and has a native Scala API
Akka: actor model concurrency framework
Play Framework: web framework, less common now
SBT: build tool, build definition is Scala code

Scala has a reputation for complexity and a steep learning curve. The community split between Scala 2 and Scala 3 (Dotty) added friction. If you are working with Spark, you will encounter Scala. If you are not, the reasons to choose it over Kotlin or Java are narrower than they used to be. Another case where Java catching up makes the trade less obvious.

Kotlin

JetBrains’ answer to Java’s verbosity. Statically typed, concise, null-safe by design. Full Java interop — Kotlin and Java can call each other in the same project. Official Android development language since 2017.

Where you find it today:

Android development (the default)
Spring Boot (first-class support since Spring 5)
Gradle Kotlin DSL (replacing Groovy as the recommended build script language)
Ktor — Kotlin-native web framework from JetBrains

Kotlin is what you reach for when you want Java but less of it. Coroutines handle async cleanly. The Kotlin DSL in Gradle gives type safety that the Groovy DSL could not.

Kotlin is the cleanest of the JVM alternatives — but again, Java has been closing the gap. Worth knowing if the project is already Kotlin; not a compelling reason to switch from Java.

Jython

Python running on the JVM. Jython implements the Python language but executes on the JVM, meaning Python code can import and use Java classes directly.

Worth knowing it exists. In practice: Jython implements Python 2 (Python 3 support was never completed), which limits its relevance post-2020. Main use case was embedding Python scripting in Java applications. A few enterprise tools and test frameworks still use it.

If you need Python-JVM interop today, consider alternatives: GraalVM’s polyglot API, or just making an HTTP boundary between a Python service and the JVM service.

Rust

Wed, 03 Jun 2026 00:00:00 +0000

Systems language with memory safety guarantees without a garbage collector. The ownership and borrow checker model enforces at compile time what other languages leave to the runtime or the programmer.

The pitch: C/C++ performance and control, without the entire class of memory safety bugs that makes systems programming treacherous. In practice the borrow checker is the learning curve, it rejects code that would be valid in any other language until you understand why it is wrong.

Where Rust is winning

CLI tooling: a significant share of modern CLI tools are written in Rust. ripgrep, fd, bat, exa/eza, zoxide, tokei. Startup time and binary distribution (single static binary) are the wins.

WebAssembly: Rust compiles to WASM with first-class tooling (wasm-pack, wasm-bindgen). Running near-native code in the browser or at the edge.

Embedded / systems: where C used to be the only option. The safety guarantees matter more, not less, when there is no OS underneath.

Cloud infrastructure tooling: parts of the ecosystem are being rewritten in Rust. Firecracker (AWS Lambda’s VMM), parts of the Linux kernel, Cloudflare Workers runtime.

Tooling

Cargo: the build system and package manager. Handles dependencies, building, testing, and publishing. One of the better-designed package managers in any ecosystem.

rustup: toolchain manager. Manages Rust versions and targets (cross-compilation).

clippy: linter. Catches more than the compiler, opinionated in useful ways.

rustfmt: formatter. Like gofmt, one style, no debate.

IDE: VS Code with rust-analyzer extension, or IntelliJ/CLion with the Rust plugin.

The learning curve

The borrow checker is a genuine obstacle. Rust enforces at compile time:

Exactly one owner of any value
Any number of immutable references OR one mutable reference — not both
References cannot outlive the value they point to

This is unfamiliar to anyone coming from languages with a GC. The compiler error messages are unusually helpful, but expect to spend real time understanding ownership before writing idiomatic Rust.

Resources

The Rust Book: the standard introduction, free online
Rustlings: small exercises for learning by doing
crates.io: the package registry
Blessed.rs: curated crate recommendations by category

The trend pattern

Language adoption tends to follow ecosystem trends rather than purely technical merit. I started with Java. Then OpenStack brought Python into infrastructure work. Then Kubernetes arrived and its ecosystem was written in Go — so Go became the language of the cloud-native world by proximity as much as by choice.

Rust looks like the next turn of that cycle. The “rewrite it in Rust” trend is real and growing — CLI tooling, parts of the Linux kernel, browser engines, cloud infrastructure. If the pattern holds, the ecosystem will pull Rust into more places where it becomes the pragmatic choice rather than the deliberate one.

Haven’t given it a serious attempt yet. Worth doing — not because Rust is clearly the right tool for the things currently being built, but because being ahead of the ecosystem trend rather than behind it is how you end up with useful experience when the moment arrives. The tooling is good, the learning resources are good, and the borrow checker will teach you something about memory regardless of whether you end up writing Rust in production.

Bash

Mon, 01 Jan 2024 00:00:00 +0000

Bash is unavoidable in DevOps work — CI/CD pipelines, container entrypoints, system init scripts, and quick automation all end up as shell scripts eventually. Knowing how to write it well saves a lot of pain.

Tooling

Linting: ShellCheck: catches common mistakes and anti-patterns. Run it in CI, or install the IDE plugin. Most of what it flags is genuinely wrong.

IDE: Any editor works. ShellCheck integrations exist for VS Code, IntelliJ, Vim, and most others.

Good habits

Set these at the top of every non-trivial script:

#!/usr/bin/env bash
set -euo pipefail

-e — exit on error
-u — error on unset variables
-o pipefail: catch errors in pipes, not just the last command

Use shellcheck before committing. Most Bash bugs it catches are subtle and only surface under specific conditions in production.

When to reach for Python instead

When the script grows beyond ~50 lines, needs associative arrays, JSON parsing, or HTTP calls — switch to Python. Bash is great glue; it’s a poor application language.

Resources

Go

Mon, 01 Jan 2024 00:00:00 +0000

Go is my go-to language for backend services, CLI tools, and DevOps tooling. The standard library covers most of what you need, the compiler is fast, and the concurrency model (goroutines + channels) makes it well suited for infrastructure-adjacent work.

Tooling

IDE: GoLand: JetBrains’ Go-specific IDE. Solid refactoring, built-in debugger, good test runner integration.

Formatting: gofmt / goimports: no debates about style, just run it.

Linting: golangci-lint: meta-linter that runs a configurable set of linters in one pass. Worth wiring into CI.

Testing

Testing is built into the standard library — go test ./... is all you need to get started. Table-driven tests are the idiomatic pattern for covering multiple cases cleanly.

func TestAdd(t *testing.T) {
 cases := []struct{ a, b, want int }{
 {1, 2, 3},
 {0, 0, 0},
 }
 for _, c := range cases {
 if got := Add(c.a, c.b); got != c.want {
 t.Errorf("Add(%d, %d) = %d, want %d", c.a, c.b, got, c.want)
 }
 }
}

Resources

Java

Mon, 01 Jan 2024 00:00:00 +0000

Java is my primary language for backend services. Mature ecosystem, strong tooling, and frameworks like Spring Boot and Quarkus make it productive for building production-grade APIs and microservices.

Tooling

IDE: IntelliJ IDEA — the standard for Java development. Excellent refactoring, code analysis, and framework support (Spring, Quarkus, Jakarta EE). The free Community edition covers most needs; Ultimate adds Spring-specific tooling and database tools.

Build: Gradle or Maven — Gradle is the least bad option; keep the build file focused on compile, test, and package only. See Build Systems for the full take.

Frameworks

Spring Boot — the dominant choice for enterprise Java. Convention over configuration, huge ecosystem, production-ready out of the box.

Quarkus — optimized for containers and GraalVM native compilation. Noticeably faster startup and lower memory footprint than Spring Boot. Worth considering for microservices running in Kubernetes.

Testing with JUnit

JUnit 5 is the standard testing framework. Combine with Mockito for mocking and AssertJ for readable assertions.

@Test
void shouldReturnGreeting() {
 var service = new GreetingService();
 assertThat(service.greet("Manfred")).isEqualTo("Hello, Manfred");
}

Spring Boot’s @SpringBootTest and @WebMvcTest slice annotations make integration testing straightforward without spinning up a full application context.

Resources

Python

Mon, 01 Jan 2024 00:00:00 +0000

Python is my scripting and automation language of choice. I reach for it when Bash starts getting unwieldy — data processing, API interactions, infrastructure automation scripts, and one-off tooling.

2024 note: For anything beyond quick scripts I’m increasingly reaching for Go instead. Better performance, a single compiled binary, and stronger typing make Go a more honest choice for tools that end up running in production. Python still wins for data work and anything where the ecosystem matters (ML, pandas, etc.).

Tooling

IDE: PyCharm: JetBrains’ Python IDE. Good for larger projects. For scripts and smaller work, IntelliJ IDEA with the Python plugin does the job.

Formatting: Black: opinionated formatter, no configuration needed.

Linting: Ruff: extremely fast linter and formatter, replacing Flake8 + isort in most setups.

Dependency management: uv: modern, fast package manager replacing pip/virtualenv for most workflows.

Where I use it

Infrastructure automation and scripting alongside Ansible
Data processing and log analysis
CLI tooling for internal workflows
Quick API clients and integration scripts