java-21

Java 21 language and runtime patterns for modern, safe code. Trigger: When writing Java 21 code using records, sealed types, or virtual threads.

Quality

72%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./community/java-21/SKILL.md

When to Use

Load this skill when:

Writing Java 21 application or library code
Designing immutable DTOs or value objects
Modeling closed hierarchies with sealed types
Using virtual threads for blocking I/O

Critical Patterns

Pattern 1: Records for immutable data

Use records for DTOs and value objects, validate in compact constructors.

Pattern 2: Sealed types + pattern matching

Use sealed interfaces/classes and switch pattern matching for exhaustiveness.

Pattern 3: Virtual threads for I/O

Use virtual threads to handle blocking I/O without large thread pools.

Code Examples

Example 1: Record with validation

package com.acme.user;

public record Email(String value) {
  public Email {
    if (value == null || !value.contains("@")) {
      throw new IllegalArgumentException("Invalid email");
    }
  }
}

Example 2: Sealed hierarchy + switch pattern matching

package com.acme.payment;

public sealed interface Payment permits Card, BankTransfer { }

public record Card(String last4) implements Payment { }
public record BankTransfer(String iban) implements Payment { }

public final class PaymentPrinter {
  public String describe(Payment payment) {
    return switch (payment) {
      case Card card -> "card-" + card.last4();
      case BankTransfer bank -> "iban-" + bank.iban();
    };
  }
}

Example 3: Virtual threads for blocking calls

package com.acme.io;

import java.util.concurrent.Executors;

public final class Fetcher {
  public void fetchAll(java.util.List<String> urls) throws Exception {
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      for (String url : urls) {
        executor.submit(() -> blockingFetch(url));
      }
    }
  }

  private void blockingFetch(String url) {
    // perform blocking I/O here
  }
}

Anti-Patterns

Don't: Use mutable data carriers

// BAD: mutable DTO
public class UserDto {
  public String name;
  public String email;
}

Don't: Spin up raw platform threads per request

// BAD: expensive and unbounded
new Thread(() -> blockingFetch("https://api" )).start();

Quick Reference

Task	Pattern
Immutable DTOs	Use records with validation
Closed hierarchies	Use sealed interfaces + switch
Blocking I/O scale	Use virtual threads executor

Resources

Java 21 Release Notes: https://www.oracle.com/java/technologies/javase/21-relnote-issues.html
JEP Index: https://openjdk.org/jeps/0

Repository: Gentleman-Programming/Gentleman-Skills
Path: community/java-21/SKILL.md
Commit: c8036a3

Last updated: 5 days ago
First committed: 8 months ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.