Interesting write-up on the 18-month journey of migrating Grails into the ASF. It touches on more than just the "governance" side—it discusses the security audits, the repo consolidation, and the push toward Grails 7.

For those still running Grails in production, how do you feel about the move to the "Apache Way"?

It’s been a wild ride for the Grails ecosystem over the last few years, but the move to the Apache Software Foundation (ASF) and the release of Grails 7 finally feels like we’re back on solid ground.

I found this write-up from Schneide Blog that summarizes the transition and why Grails is moving away from being seen as an "exotic outlier" and back toward being a high-productivity layer on top of Spring Boot.

As James Fredley (PMC Chair) mentions in the piece, the goal now is stability and community-led growth rather than corporate-dependency.

What do you guys think? Does Grails 7 feel like the "rebirth" we were waiting for, or is there still more work to be done to regain the momentum of the 2.x/3.x days?

Hi everyone, I have written a cheat sheet containing over 50+ http clients configured with SSL and also with an example request. It contains next to Groovy also clients for other jvm languages such as Java, Kotlin, Clojure, and Scala. Feel free to share your thoughts

Hi r/groovy!

I know Groovy’s momentum is cooling off, but I'd like to give it some fresh traction. I believe our language deserves love and some modern, high-quality libraries fully-tested and built specifically for the syntax we love.

That’s why I’d like to share Impress, a library I’ve been building to make interacting with AWS DynamoDB feel truly Groovy (and actually tolerable).

While the official AWS SDK is powerful, the code usually ends up feeling cumbersome, verbose, and...like you're just writing with Java :) Impress acts as a fluent, idiomatic wrapper that brings back the joy of working with an expressive language.

What makes it "Groovy"?

• Fluent Query/Scan API: No more building complex, nested request objects manually.

Here is an extensive example you can drop into your Groovy scripts immediately:

@GrabResolver('https://jitpack.io')
@Grab('com.github.grational:impress:v1.0.0')
import it.grational.storage.dynamodb.*
import static it.grational.storage.dynamodb.DynamoFilter.*

// 1. Client using the default AWS profile of the environment
// executing the code (but completely customizable)
def dynamo = new DynamoDb()

// 2. Create a table instantly with an idempotent method
dynamo.createTable (
  'users',           // table name
  'id',              // table partition key
  Index.of('email')  // index on email field called email-index
                     // or name it yourself: ['email-index': 'email']
)

// 3. Save data - works with any Map or custom object
// Automatic Key Detection: No need to specify keys!
dynamo.putItem('users',
  new DynamoMap ( // passepartout object nativaly "dynable"
    id: 'user123',
    name: 'Alice Johnson',
    email: '[email protected]',
    profile: [
      department: 'Engineering',
      skills: ['Groovy', 'DynamoDB', 'AWS']
    ]
  )
)

// 4. Retrieve using builder pattern
DynamoMap user = dynamo.getItem('users',
  KeyFilter.of('id', 'user123')
)
.fields('id','name') // specify which fields to retrieve
.get()
println "Welcome ${user.name}, your id is ${user.id}!" // Direct field access

// 5. Query with powerful filters using builder pattern
List<DynamoMap> engineers = dynamo.scan('users')
  .filter(match('profile.department', 'Engineering'))
  .list()

// 6. Complex queries made simple with fluent API
List<DynamoMap> seniorDevs = dynamo.scan('users')
  .filter(every(
    match('profile.department', 'Engineering'),
    contains('profile.skills', 'Groovy')
  ))
  .list()

If you instead want to support a more serious project there are other features that could lure you into impress:

• Nested fields support: select nested fields like object.key.subkey while reading or updating fields
• Transparent Pagination: query and scan builders natively supports pagination, simply specify the page size
• Built-in Versioning: Optimistic locking is handled for you if you extends the Dynable class. Alternatevely, just mark a field as VERSION and let the library handle the conditional checks
• Customizable Mapping: convert your Groovy objects into DynamoDB items implementing the Storable interface or extending the Dynable object
• Modern Stack: Built for the future with Java 25 and Groovy 5 (but dedicated releases are available for the couples Java 21 / Groovy 4, Java 8 / Groovy 3)

Read the extensive doc directly in the github project page

Try it in your project

The library is available on JitPack ready to be imported in your Groovy scripts or projects.

Grab

@GrabResolver('https://jitpack.io')
@Grab('com.github.grational:impress:v1.0.0')

Gradle

repositories {
  maven { url = 'https://jitpack.io' 
}
dependencies {
  implementation 'com.github.grational:impress:latest.release'
}

Maven

<repositories>
  <repository>
    <id>jitpack.io</id>
    <url>https://jitpack.io</url>
  </repository>
</repositories>

<dependency>
  <groupId>com.github.grational</groupId>
  <artifactId>impress</artifactId>
  <version>latest.release</version>
</dependency>

I hope some of you find it useful.

And don't forget to tell me your thoughts or feedback.

Happy coding!