Successful Maven builds can produce thousands of lines that mostly confirm routine lifecycle steps.

That output is noisy when working in a terminal, clutters CI logs, and becomes especially expensive when build output is passed to a coding agent.

I built mvn-lite, a small deterministic Bash wrapper that keeps successful Maven output to one line while preserving the original exit code and complete raw log.

On a real four-module application:

• Standard Maven output: about 6,753 bytes
• mvn-lite output: 16 bytes
• Result: PASS · 3.944 s
• Reduction: more than 99.7%

Failures still return a nonzero exit code and show bounded diagnostics, while the full unmodified Maven output remains available in the raw log.

For example, an invalid lifecycle error was reduced by 91.6% while retaining the actual Maven error.

There is no LLM summarization, API key, or Maven extension involved. It is just a local Bash wrapper with deterministic text extraction.

Source and script: https://github.com/ejboy/agent-scripts

Benchmark details and design notes: https://pvrlabs.xyz/articles/introverted-maven.html

I’d be interested in feedback on Maven failure cases where compact output could hide something essential.

Automatically turn your plain classes and records into value classes!

Add @AutoValhalla annotation to classes or records in your JDK1.5+ codebase:

@AutoValhalla
public final class Point {        // class must be final
    public final int x;           // with final instance fields
    public final int y;
    public Point(int x, int y) { 
        this.x = x; 
        this.y = y; 
    }
}

@AutoValhalla
public record Currency(String code) { }  // or a record class

When your app is run on Valhalla-enabled JVM with auto-valhalla javaagent, these classes are automatically turned into value classes.

More info: https://github.com/thunkware/auto-valhalla/blob/main/README.md

I’ve just released v1.2 of Automatic Relationship Finder (ARF), an open-source Java library I’ve been working on.

The idea behind ARF is to discover relationships between tables without depending on database relationship metadata.

Even if there is no foreign-key constraint defined in the database, ARF can analyze column names and the actual data to identify that

What's new in v1.2?

The main addition is key-role detection.

After identifying a relationship, ARF now analyzes the data characteristics of the columns to determine whether they are likely to represent a primary-key side, foreign-key side, a possible one-to-one relationship, or an unknown relationship.

There are also several improvements and bug fixes around validation, logging, concurrency, and edge-case handling.

The project is here:

https://github.com/NoelToy/automatic-relationship-finder

This is still an evolving project, so feedback—especially criticism—is very welcome.

Over the past months I've been building my pet project, and today I'm open-sourcing its core: Events-Caravan, an event-sourcing framework for Java with Spring-boot starter modules.

The framework is built around an opinionated bet made for the sake of horizontal scalability: there is no global sequence of events. Events are ordered within a single entity.

Axon's default, for comparison, keeps a totally-ordered event log, and that log eventually becomes the ceiling: the one component every write has to pass through. Give up the global ordering, and everything can partition at the entity level: the storage, the change feed, the consumers.
Events-Caravan has no central sequencer, no outbox table either: inserting an event into the database is publishing it, and the database's own change stream carries it to consumers.

Nothing is free, of course. The price for horizontal scalability is at-least-once unordered delivery and strong consistency only within one entity. I've documented every traded-away guarantee in the README's "Compromises" section, along with how to compensate.

The project is modularized. The core is plain Java interfaces to use or implement, no DSL. Reference adapters ship for DynamoDB and SNS/SQS, but the design isn't tied to AWS: any technology fitting the framework's principles can substitute AWS.

The library also brings:
- Entity state snapshotting, to avoid replaying all historic events.
- Sharding of long entity histories, so no partition grows into a bottleneck.
- An adaptive, scalable queue-polling mechanism.
- An optional, eventually consistent entity-stream that compensates for the absence of a global event log.

Apache 2.0, on GitHub with an opinionated README: https://github.com/SagynyshBaitursinov/events-caravan
Maven Central: dev.baitursinov:events-caravan

If you've run event-sourced systems in production, or are just interested in software architecture, I'd genuinely value your opinion on the design, its interfaces, and the 11 principles it's built on - all in the Readme.

Hello my fellow java enthusiasts!

 

I made a cool side project that automatically searches the web for images of our beloved java mascot duke. The website shows a random image from the archive. It will also have a full gallery available soon!

 

How it works:

- It uses the Brave search API to find pages based on some keywords I came up with.

- It uses Openverse and Wikimedia APIs to search for images related to duke.

- Each image gets checked by a custom classifier I have built on top of OpenCLIP and trained on more than 200 Duke images.

- The classifier filters out unrelated results. Because it's not perfect, some images go through manual review. I want to catch unusual duke images without filling the archive with junk!

 

I will most likely make this open source soon after I'm done implementing all the features I want.

Unfortunately, the backend isn't made with java, I went with python for the easy use of ai models

Currently there are 338 duke images and the archive is still growing!

 

URL: https://duke.directory

 

I would love to hear your feedback! If you have any duke images that it hasn't found or collections that it should discover, please let me know!

Hey everyone!

It has been a while since the last update, but we have been working hard on making the Java bindings for SimpleBLE even more reliable for production environments.

For those who don’t know, SimpleBLE is a cross platform Bluetooth library with a very simple API that just works, allowing developers to easily integrate it into their projects without much effort, instead of wasting hours and hours on development.

We have been working on the Java bindings to make them feel more natural for developers and more robust to use in real applications. These are not flashy changes, but hopefully show our commitment towards becoming the trusted option for Bluetooth development for Java.

If you want to try it out, you can look at the SimpleJavaBLE examples on GitHub and see for yourself how easy it is to get started.

What changed

We added support for CompletableFuture wrappers around blocking operations. This should make SimpleJavaBLE much easier to fit into the rest of an application using async flows without having to build extra wrappers first.

We also made an important change to the JNI layer. JNI API calls are now safely wrapped so that C++ exceptions are caught and bubbled up as Java RuntimeExceptions instead of crashing the JVM.

Another small change that makes the bindings nicer to work with is that EventListener interfaces now provide default empty implementations, so if you only care about one callback, you can implement that one and move on.

We also cleaned up a few rough edges across platforms. The missing macOS x64 .dylib artifact is now fixed, JNI symbol issues have been resolved, and the jvm.dll initialization conflicts some users were seeing on Windows have been addressed.

Licensing Stuff

SimpleBLE is licensed under the Business Source License 1.1 (BUSL 1.1) and is free for non commercial use. We gladly offer free licenses for small projects, so do not hesitate to reach out. Java licenses are currently on a special offer for companies interested in shaping SimpleJavaBLE, so if you are interested in a commercial license, hit us up!

If you’re building BLE products or projects, we’d love to hear from you.

Want to know more about SimpleBLE's capabilities or see what others are building with it? Ask away!