savant-core VS rife2

I recently came across another build system and similar to gbevin the authors (the fusion auth guys) make a lot of there own tools and libs: Savant. However it has its own language.

I give my boss a hard time about our dependency management system because it is relatively unknown[0], but licensing is built into it from the ground up. You can't import any dependency (no matter how buried) without assigning a license to it.

This lets us confidently know, via software, the open and closed source licenses in our code base.

Licensing is one of those out of band concerns that doesn't burn you until it does.

0: https://github.com/savant-build/savant-core

It is possible, and I realize we've not written docs about it yes, we'll fix that soon. We're using two modules in RIFE2 and bld itself, one for the main build and one for the framework examples https://github.com/rife2/rife2/tree/main/src/bld/java/rife

There's more detail in the readme on GitHub:

https://github.com/gbevin/rife2

Including:

> RIFE2 has features that after 20 years still can't be found elsewhere: web continuations, bidirectional template engine, bean-centric metadata system, full-stack without dependencies, metadata-driven SQL builders, content management framework, full localization support, resource abstraction, persisted cron-like scheduler, continuations-based workflow engine.

Doesn't appear to have websocket support, though.

I'm very excited to see what web projects, both big and small, can be accomplished with such a self-contained framework like RIFE2. And we've only scratched the surface! There's a built-in template system, Continuations, and much more. Definitely read the docs if you want to dig deeper into this framework. Also, be sure to thank the framework author, Geert Bevin, for the amount of effort he has put into this!

The validation and meta-data however doesn't require the model to extend a class, there's the possibility to use meta-data merging to have a sibling class that implements the RIFE2 specific logic, which will be merged at runtime through bytecode instrumentation: https://github.com/gbevin/rife2/wiki/Metadata-Merging

RIFE2 does support arbitrary parameters, in various ways. The manual way is when generating a URL with urlFor, you can add parameters to it c.urlFor(route).param(key, value).param(key, value). You can also annotated Element class fields with @Parameter which will have RIFE2 automatically inject the incoming value, there's an additional annotation attribute that can be set to specific the flow of the data: in, out or inout. When you generate a URL with c.urlFor(route), RIFE2 will look at the element currently in your context, the element targeted by your route and any out parameters that have corresponding in parameter names on the target, will be automatically added to the generated URL with the value they currently hold. Some of that is documented here, but it could definitely use some more love: https://github.com/gbevin/rife2/wiki/Field-Annotations

Java seems to have gained a second wind in recent years, and the innovation in this ecosystem is speeding up. Java 20 and LTS release 21 are expected to happen this year. RIFE2, an actively-developed pure-Java web framework, has recently caught my attention. Like Javalin, it appears to be built on top of the successful Jetty server. I also started exploring FXGL for building games with Java. Lastly, as concerns over COVID-19 variants wane I expect an increase in Java developers participating in community events. For example, Chicago finally had its first in-person JConf event and the Chicago Java User Group (CJUG) is easing back into in-person events.

There's a step-by-step readme to get a quick glance at the feel and the approach: https://github.com/gbevin/rife2/blob/main/README.md, a series of concise examples https://github.com/gbevin/rife2/tree/main/app/src/main/java/rife and a growing full manual: https://github.com/gbevin/rife2/wiki