rife2 VS Graal

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

Contrary to what vocal Kotlin advocates might believe, Kotlin only matters on Android, and that is thanks to Google pushing it no matter what.

https://spectrum.ieee.org/the-top-programming-languages-2023

https://snyk.io/reports/jvm-ecosystem-report-2021/

And even so, they had to conceed Android and Kotlin on their own, without the Java ecosystem aren't really much useful, thus ART is now updatable via Play Store, and currently supports OpenJDK 17 LTS on Android 12 and later devices.

As for your question regarding numbers, mostly Java 74.6%, C++ 13.7%, on the OpenJDK, other JVM implementations differ, e.g. GraalVM is mostly Java 91.8%, C 3.6%.

https://github.com/openjdk/jdk

https://github.com/oracle/graal

Two examples from many others, https://en.wikipedia.org/wiki/List_of_Java_virtual_machines

Pkl was built using the GraalVM Truffle framework. So it supports runtime compilation using Futurama Projections. We have been working with Apple on this for a while, and I am quite happy that we can finally read the sources!

https://github.com/oracle/graal/tree/master/truffle

Disclaimer: graalvm dev here.

That's pretty interesting. It's not as aggressive as Bee sounds, but the Espresso JVM is somewhat similar in concept. It's a full blown JVM written in Java with all the mod cons, which can either be compiled ahead of time down to memory-efficient native code giving something similar to a JVM written in C++, or run itself as a Java application on top of another JVM. In the latter mode it obviously doesn't achieve top-tier performance, but the advantage is you can easily hack on it using all the regular Java tools, including hotswapping using the debugger.

When run like this, the bytecode interpreter, runtime system and JIT compiler are all regular Java that can be debugged, edited, explored in the IDE, recompiled quickly and so on. Only the GC is provided by the host system. If you compile it to native code, the GC is also written in Java (with some special conventions to allow for convenient direct memory access).

What's most interesting is that Espresso isn't a direct translation of what a classical C++ VM would look like. It's built on the Truffle framework, so the code is extremely high level compared to traditional VM code. Details like how exactly transitions between the interpreter/compiled code happen, how you communicate pointer maps to the GC and so on are all abstracted away. You don't even have to invoke the JIT compiler manually, that's done for you too. The only code Espresso really needs is that which defines the semantics of the Java bytecode language and associated tools like the JDWP debugger protocol.

https://github.com/oracle/graal/tree/master/espresso

This design makes it easy to experiment with new VM features that would be too difficult or expensive to implement otherwise. For example it implements full hotswap capability that lets you arbitrarily redefine code and data on the fly. Espresso can also fully self-host recursively without limit, meaning you can achieve something like what's described in the paper by running Espresso on top of Espresso.

I'm also using GraalVM if that's of any help.

Quarkus is one of Java frameworks for microservices development and cloud-native deployment. It is developed as container-first stack and working with GraalVM and HotSpot virtual machines (VM).

Apologies, I didn't mean to imply DCEVM went poof, just that I was sad it didn't make it into OpenJDK so one need not do JDK silliness between the production one and the "debugging one" since my experience is that's an absolutely stellar way to produce Heisenbugs

And I'll be straight: Graal scares me 'cause Oracle but I just checked and it looks to the casual observer that it's straight-up GPLv2 now so maybe my fears need revisiting: https://github.com/oracle/graal/blob/vm-23.1.0/LICENSE

> to be compiled to a single executable is a strength that Java does not have

I think this is very outdated claim: https://www.graalvm.org/

https://github.com/oracle/graal/issues/7182