DEV Community: Matthew Murray

Sleeping on the floor

Matthew Murray — Sat, 22 Aug 2026 10:05:34 +0000

Something

@StandardException

Matthew Murray — Sat, 22 Aug 2026 10:05:33 +0000

I recently came across a little gem annotation from Lombok that I had never heard of before: @StandardException.

You can annotate your Exception classes (extends exception) with this annotation, it will generate the usual constructors for your exception type that you would normally write.

https://projectlombok.org/features/experimental/StandardException

This is a small thing, but it can save you some time and make your code cleaner. I will definitely be using this annotation in my future projects.

On one hand, this makes me wonder about all the other useful annotations that I have not yet discovered, but it also led me to think about the problems of annotation driven development

@Delegate annotation

Matthew Murray — Sat, 22 Aug 2026 10:05:02 +0000

I recently came across the @Delegate annotation from Lombok.
It turns out I'm not the only person who frequently discovers new things about Lombok, as I've written about another annotation recently: @StandardException.

The @Delegate annotation is a handy way to delegate methods from one class to another. This can be useful when you want to reuse the methods of another class without having to write them all out again.

Here's a simple example to demonstrate:

import lombok.experimental.Delegate;

public class DelegateExample {
    interface Greet {
        String greet();
    }

    static class GreetImpl implements Greet {
        @Override
        public String greet() {
            return "Hello, World!";
        }
    }

    @Delegate
    private final Greet greet = new GreetImpl();

    public static void main(String[] args) {
        DelegateExample example = new DelegateExample();
        System.out.println(example.greet());
    }
}

In this example, we have an interface Greet with a single method greet(). We then have a class GreetImpl that implements this interface. Finally, we have a DelegateExample class that uses the @Delegate annotation to delegate the greet() method to an instance of GreetImpl.

This code will output Hello, World!, which is the result of calling the greet() method on the GreetImpl instance.

According to the Lombok page on @Delegate, this annotation will probably not move out of experimental status, so use it with caution. However, it can be a useful tool in your toolbox when you need to delegate methods between classes.

I'm always a fan of reducing boilerplate code especially when it comes to Java, @Delegate is a great way to do that when you need to reuse methods across classes. I'll definitely be keeping this annotation in mind for future projects.

JManc Unconference 24

Matthew Murray — Sat, 22 Aug 2026 10:05:00 +0000

I recently attended the JManc Unconference 24, and it was a great experience. The event was held at the Auto Trader's office in Manchester, and it was a full day of discussing all things Java.

The day kicked off with a keynote from Helen Scott, a developer advocate at JetBrains, the keynote was focused on AI, touching on developer effectiveness.

The event followed an Open Space Technology format where the attendees could propose sessions and join in on the ones that interested them. The schedule ended up as follows:

It was interesting to hear other people's thoughts on each topic. I felt that some sessions lacked direction, but I think that's the nature of the format. The facilitators tried their best to navigate, avoiding awkward conversations and silence. I enjoyed the sessions that were more focused and had a clear direction on the topic being discussed.

There is one law of the Open Space Technology format: "The Law of Two Feet":

If at any time during our time together you find yourself in any situation where you are neither learning nor contributing, use your two feet, go someplace else.

I will remember this for next time. I'm looking forward it, and I hope to see some familiar faces there.

Streamline password management on MacOS with pass & fzf

Matthew Murray — Sat, 22 Aug 2026 10:04:29 +0000

I use pass and this simple shell script that searches .gpg files in ~/.password-store or PASSWORD_STORE_DIR (if set) and pipes into fzf:

#!/usr/bin/env bash

pushd "${PASSWORD_STORE_DIR:-$HOME/.password-store}"
PASSFILE=`fd -t file -e gpg --color=always | sed 's/\.gpg//; s/^\.\///' | fzf --ansi`
popd

[ -z "$PASSFILE" ] && exit 0

pass -c $PASSFILE 1>/dev/null

iCanHazShortcut let me assign shortcuts to my script. Pressing Command + P runs alacritty -e sh -c '~/bin/fzf-passmenu', which opens a new terminal window and runs the script. It's a fast and simple process.

From sitting, to standing, and now I'm on the floor

Matthew Murray — Sat, 22 Aug 2026 10:04:27 +0000

I've opted for taking apart my FlexiSpot standing desk down in favour of a portable Chabudai style of table and a "meditation" cushion to sit on. These tables are really low down close to the ground and suited for working whilst sitting on the floor.

Long gone are the days of being constrained to a desk in my bedroom, but instead a small table I can set out anywhere in the house. I want to enjoy all parts of my home while WFH, and encourage myself to go out to work, whether this be at the office or a coffee shop. Essentially moving around a lot more!

Supposedly there are long term benefits to sitting naturally, on the floor. I'm sure it will take some getting used to.

These are the items for anyone interested:

Looking into Spring Validation

Matthew Murray — Sat, 22 Aug 2026 09:57:31 +0000

I recently had a look into Spring Validation and discovered new ways it can be used. Here's a simple example that is commonly used in Spring Boot applications.

A simple Person class with validation constraint annotations:

package com.example.spring_validated.lib;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;

public class Person {

    @NotBlank
    private String name;

    @Min(18)
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

And a controller that uses the Person class as a dependency:

package com.example.spring_validated;

import com.example.spring_validated.lib.Person;
import jakarta.validation.Valid;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Validated
public class PersonController {

    @PostMapping("/person")
    public String createPerson(@Valid @RequestBody Person person) {
        return "Person created: " + person.getName();
    }
}

If we use this endpoint without giving a name in the request body, we will get a 400 Bad Request response since it does not meet the constraints in the Person class.

In my application, the Person class is declared in a separate library, meaning that Spring Validation actually works across different libraries. Additionally, not only will Spring Validation apply constraints from your dependency class, but it also works with sub-dependencies as long as they are annotated with @Valid, like this Address record:

package com.example.spring_validated.anotherlib;

import jakarta.validation.constraints.NotBlank;

public record Address(@NotBlank String street) {}

package com.example.spring_validated.lib;

import com.example.spring_validated.anotherlib.Address;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;

public class Person {

    @NotBlank
    private String name;

    @Min(18)
    private int age;

    @NotNull
    @Valid
    private Address address;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

My investigation was led by a desire to validate outside a controller, and I found that @Validated can also be applied to other beans like Services.

package com.example.spring_validated.app;

import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import com.example.spring_validated.lib.Person;
import jakarta.validation.Valid;

@Service
@Validated
public class PersonService {

  public void validate(@Valid Person person) {
    System.out.println("Validated person: " + person);
  }
}

This is useful in my case where I want to validate data classes that we formed via extensive business logic before it is persisted or sent to another service.

I found some new ways to apply validations in my applications and I hope you can too.

New beginnings

Matthew Murray — Sat, 22 Aug 2026 09:57:30 +0000

After a long struggle with my old blog, I've decided to start fresh. I'm going to write about all the things that interest me, and I hope you'll enjoy reading about them.

I'm planning to write about:

Software development
Technology
Books
My vegetable garden
And anything else that catches my interest

This blog will also act as a sort of public notebook for myself. I'm always learning new things, and I want to keep track of what I've learned. I hope that by writing about it, I'll be able to retain more information.

It will be interesting to see if I can keep up with this blog given my hectic family life, but I'm determined to give it a shot.