Gradle on foojay.io - Friends of OpenJDK

Getting Started with Exposed: Kotlin ORM Made Simple

Mon, 06 Jul 2026 03:39:00 +0000

Introduction

For quite some time, I have been a huge fan of and fascinated by JetBrains products, tools, and libraries because of their masterful craftsmanship in product creation and their pristine focus on building high-quality developer tools.

Even more excitingly, JetBrains Java Annotated Monthly newsletters have featured most of the technical articles I wrote for Foojay on topics such as Java, Spring, Spring Boot 4, and OpenRewrite.

Recently, one Kotlin Domain-Specific Language (DSL) library caught my attention. I immediately tried converting my existing Spring Boot 4 application from Java to Kotlin using Exposed, an ORM framework for Kotlin. Kotlin SQL Libary

This Dependency Update Looked Exactly Like an Account Takeover

Fri, 03 Jul 2026 08:31:27 +0000

I pointed a scanner I have been building at an old Spring project, and it flagged javax.activation. The bump was 1.1-rev-1 to 1.1.1. Prior releases carried a GPG signature. This one did not.

If you have read the post-mortems of real supply-chain attacks, that pattern should make you sit up. A package that has signed its releases for years suddenly ships one unsigned. The boring explanation is a build pipeline change. The other explanation is that a different person is publishing now, and the signing key stayed behind with the old one. When ua-parser-js was hijacked in 2021, the malicious versions came from a compromised account. When event-stream went bad in 2018, it was a new maintainer nobody had vetted. The artifact looks fine. The metadata around it is what changed.

Enterprise Java quality gates in the age of AI

Fri, 29 May 2026 07:00:00 +0000

People and AI can write code together, but enterprise repositories still need deterministic quality gates to protect code quality.

Enterprise quality is a scaling problem

Enterprise Java development is not only about writing correct code. It is about keeping a large, long-lived codebase understandable, reviewable and safe to change while many people and many tools touch it over time.

Eliminating Flaky Tests to End World Hunger

Thu, 23 Apr 2026 09:02:34 +0000

Rita Mae Brown once said:

Insanity is doing the same thing over and over again and expecting different results.

However, everyone has at least once experienced a test that failed and then passed in the next run without changing the code or the environment. In software engineering, we don’t call it insanity; we call such unpredictable failures flaky tests. At first, they may seem like minor problems, but like clutter in a junk drawer, they become worse over time if you never take care of them.

Foojay Podcast #81: Maven 4 - The Future of Java Build Automation

Mon, 03 Nov 2025 06:03:12 +0000

Maven 4 is approaching its release, bringing many improvements to the build tool powering millions of Java projects.

In this Foojay Podcast episode, we talk about Apache Maven 4, a significant milestone that has been years in the making. Maven has been the backbone of Java dependency management and build automation since the early 2000s; however, the road to version 4 has been a long and deliberate one. With significant performance improvements, a modernized API for plugin developers, and changes that affect how we think about project structure, Maven 4 represents both an evolution and a revolution. What does this mean for the millions of developers who depend on Maven daily? How should teams prepare for the transition? And what’s the story behind the Maven Central Repository changes that have been making headlines? To answer these questions and more, we’re joined by a few of the many contributors who are actually building Maven 4 and stewarding its ecosystem.

How to Kickstart Your Jakarta EE 11 Projects with Payara Starter

Tue, 23 Sep 2025 10:26:53 +0000

Jakarta EE 11 is here, bringing powerful new capabilities for enterprise Java developers. But getting started quickly can be a challenge - that’s where the latest Payara Starter comes in. With full Jakarta EE 11 support, an updated ERD-based code generator, and a new Jakarta Faces project generator, it gives you everything you need to launch your next application with ease.

With Jakarta EE 11 now officially released , you are likely eager to explore its new capabilities but setting up your first application may take longer than you want. That’s where the latest version of Payara Starter steps in, giving you a fast, hassle-free way to get a fully functional Jakarta EE 11 project up and running. Read more to learn how!

IntelliJ IDEA and Open Liberty - Effective Java app development

Fri, 12 Apr 2024 13:36:25 +0000

See how you can use Liberty Tools for IntelliJ IDEA to enable rapid, easy, and efficient development of cloud-native Java applications with Open Liberty and WebSphere Liberty

When it comes to integrated development environments, within the Java community, IntelliJ IDEA is the most popular IDE amongst professional developers. It is the preferred IDE of choice by two-fifths of developers, making up the biggest majority of IDE users in this community, according to JRebel’s 2023 Java Developer Productivity Report .

Elevating Java in Visual Studio Code: New Build Server for Gradle

Mon, 30 Oct 2023 15:24:14 +0000

Introducing Build Server for Gradle

In recent years, Gradle has become one of the most popular Java build tools due to its flexibility in configuring build processes and its powerful extensibility. In Visual Studio Code, users can import Gradle projects into their workspace for development. However, there are some areas where support for Gradle projects is not entirely satisfactory, with two major issues that users have below:

Compiled files are output to the ‘bin’ directory, which differs from Gradle project’s default output location.
Support for code generation, such as Annotation Processing, is suboptimal.

To address these issues, Microsoft and Gradle have joined forces to explore a novel approach to Gradle project import and building, based on the Build Server Protocol (BSP) .

5 Ways to Identify and Manage Flaky Tests

Tue, 12 Sep 2023 03:57:12 +0000

Dealing with flaky tests is a significant challenge in software development. These unpredictable and inconsistent tests can pass or fail without any changes in code, casting doubt on the reliability of your toolchain and ultimately on the application itself. The presence of flaky tests can significantly impact developer confidence and productivity. To better understand why you need to address these flaky tests, read Seven Reasons You Should Not Ignore Flaky Tests .

My Final Take on Gradle (vs. Maven)

Tue, 15 Aug 2023 08:37:24 +0000

I tweet technical content that I consider interesting, but the funny tweets are the ones that get the most engagement.

I attended the JavaLand conference in March, stumbled upon the Gradle booth, and found this gem:

Of course, at some point, a fanboy hijacked the thread and claimed the so-called superiority of Gradle. In this post, I’d like to shed some light on my stance, so I can direct people to it instead of debunking the same “reasoning” repeatedly.

Build Rot: The Hidden Technical Debt in Maven and Gradle Builds

Fri, 21 Jul 2023 08:14:01 +0000

Discover ‘Build Rot’, the hidden technical debt in Maven and Gradle builds. This article explores the impact of Build Rot on build speed and test times, offering strategies for enhanced observability and Developer Productivity Engineering to optimize build processes.

Technical debt is a constant companion in the complex world of software development. It’s the price we pay for quick fixes and postponed refactoring—the “we’ll do it right next time” mentality.

Analyzing dependencies in IntelliJ IDEA

Thu, 11 May 2023 09:33:40 +0000

If you’re working on a real world project, you’re probably using external dependencies.

You might need to analyze which dependencies your application uses.

For example, you may want to find out how a particular version of a dependency ended up in your application.

Let’s take a look at how IntelliJ IDEA can help you to analyze dependencies.

We can view our dependencies in the Maven or Gradle tool window.

Here, we can expand dependencies to show their transitive dependencies, or collapse them again.

How Gradle Works: Inside the Daemon

Tue, 14 Mar 2023 11:27:52 +0000

Previously in the How Gradle Worksseries:

How Gradle Works: Startup

This is the second article of the series How Gradle Works.

In this article, we’ll explain what happens inside the Gradle Daemon JVM.

Why Do We Need Gradle Daemon?

In the last article , we mentioned that Gradle starts a Gradle Daemon JVM (“the daemon”) to run the build.

The userguide explains why we need the daemon.

The Daemon is a long-lived background process that reduces the time it takes to run a build. The Daemon reduces build times by caching project information across builds, running in the background so every Gradle build doesn’t have to wait for JVM startup, benefiting from continuous runtime optimization in the JVM, and watching the file system to calculate exactly what needs to be rebuilt before you run a build.

How to Find & Fix Vulnerabilities with IntelliJ IDEA Ultimate

Mon, 13 Feb 2023 09:09:39 +0000

In this article, we’re going to take a look at the Package Checker plugin , that’s bundled with IntelliJ IDEA Ultimate .

We’ll have a look at how to view known vulnerabilities in your Maven or Gradle projects, how to get more information about the known vulnerabilities in a specific dependency and how to remediate these vulnerabilities inside IntelliJ IDEA Ultimate if a new version with a fix is available.

How Gradle Works: Startup

Thu, 09 Feb 2023 08:45:57 +0000

This is the first article of a series How Gradle Works, which includes the following topics:

How Gradle starts up
How many JVMs are involved in a Gradle build
What happens in each JVM during the build

We’ll explain the first topic How Gradle Starts Up in this blog.

Before reading on, we assume you are familiar with basic JVM/Gradle concepts (jar, classpath, wrapper, daemon, project, task, etc.).

How Gradle Starts Up

There are many ways to start a Gradle build:

Modular Monolithic in Practice

Wed, 25 Jan 2023 08:01:08 +0000

With the usage of microservices in application modernization, we have seen both the advantages and disadvantages of maintaining such software development styles.

When we create applications mostly in enterprise organizations, the first thing that comes to our mind now is how to decouple our applications.

But there will be times when creating too many microservices is not the best way and may cost you time and money.

Because of that, one alternative is to leverage the use of modules.

Managing Dependencies in IntelliJ IDEA

Tue, 10 Jan 2023 15:13:39 +0000

In this tutorial, following on from viewing dependencies , we’re going to take a look at managing dependencies in IntelliJ IDEA.

We’ll look at different ways to add dependencies to your project, and how to add, upgrade and remove dependencies using Package Search.

There are several ways to add new dependencies to your project.

From the build file using copy-paste

You have probably copied a dependency from Maven Repository (or another website) and pasted into your build file.

Building JavaFX with Gradle

Thu, 05 Jan 2023 11:32:24 +0000

Usually Maven is my build tool of choice and for Java front-ends I sometimes still build a front-end application using ANT, Swing with Oracle’s JDK 8u202 and JDK 8’s Java Packager, but don’t tell anyone….

Over time, as I wanted to move forward with some more lightweight front-ends, I started building JavaFX applications.

Of course, I don’t want to lock customers into JDK maintenance contracts; for backend software and servers, where the customer usually has their own runtime architecture, that’s easy, but for GUIs, I generally don’t want to ship a full JDK anymore, I want to use modular Java, ship a JDK of my choice, and provide a proper build system for it all. So that’s it, I use the following components and software:

Viewing Maven and Gradle Dependencies in IntelliJ IDEA

Wed, 07 Dec 2022 08:54:13 +0000

In this article, we’re going to take a look at different ways to view your external dependencies in IntelliJ IDEA.

Introduction

If you’re working on a real-world application, your project will probably use external libraries and frameworks.

Occasionally, you might want to see which dependencies your project uses, for various reasons.

There are several ways to view dependencies in IntelliJ IDEA .

Each view has a different focus.

Dependency management config file

You can find direct dependencies in the dependency management config file. Direct dependencies are the dependencies that your project depends on directly.

Introducing Gradle Test Suites

Tue, 06 Dec 2022 13:28:26 +0000

This article was initially published at blog.gradle.org

As projects grow in size and complexity and otherwise mature, they tend to accumulate a large collection of automated tests.

Testing your software at multiple levels of granularity is important to surface problems quickly and to increase developer productivity.

In Gradle 7.3 , released November 2021, the Gradle team introduced a new feature called Declarative Test Suites.

Using this feature makes it much easier to manage different types of tests within a single Gradle JVM project without worrying about low level “plumbing” details.

A Better Way To Use Gradle With Github Actions

Wed, 21 Sep 2022 12:54:10 +0000

Running Gradle builds on GitHub Actions

GitHub Actions provides a convenient and powerful CI platform for projects hosted on GitHub. To enhance the experience of building Gradle projects on GitHub Actions, the Gradle team has developed the gradle-build-action.

Together with Gradle Build Scans™, the gradle-build-action provides deep integration between Gradle and GitHub Actions, providing easier setup and a better experience when building and testing your Gradle project with GitHub Actions.

Java on Azure Tooling Update – June 2022

Mon, 13 Jun 2022 07:40:38 +0000

Hi everyone, welcome back to June update of Java on Azure Tooling.

In this update, we will introduce the new application-centric view on Azure toolkit for IntelliJ that will make the interface more user-friendly.

In addition, we have added support for more Azure services.

For Gradle plugins, we have some new features for Azure Web Apps and Azure Functions.

We hope you like these new features and share your feedback with us. So let us get right into it…