spring-fu

> And that is a problem how? Stick to one style. Switching an API from "a result or nothing" to "a result or an error message" happens all the time, and switching in the other direction is only slightly less frequent. And of course most programs have some APIs where one is appropriate and some where the other is. So consistency is valuable. > https://github.com/spring-projects-experimental/spring-fu/tr... Still reflection-based. > There's nothing magical about it. It's magical to anyone thinking in the language - it breaks the rules of the language, so you can't reason about what it does.

> Kotlin is an unmaintainable soup of features Are you sure you're not confusing Kotlin with Scala? > For example, Kotlin has null safety and it lets you write code using errors-as-values style "either" types - but it has two completely separate syntaxes for these things, and so it's impossible to interoperate or reuse code between those two approaches And that is a problem how? Stick to one style. > In practice Kotlin codebases still use magical incomprehensible reflection (Spring Boot) https://github.com/spring-projects-experimental/spring-fu/tr... > and magical compile-time manipulation (Kapt) There's nothing magical about it.

The wheel of karma is ever-turning, though [0],[1]. Disclosure: I work for VMware, which sponsors Spring development. [0] https://spring.io/blog/2021/03/11/announcing-spring-native-b... [1] https://github.com/spring-projects-experimental/spring-fu

There's a next stage after annotations. The current thinking is to replace annotations with function calls. It makes more sense if you use Kotlin because Java is a bit verbose when you do this and in Kotlin you get to create nice DSLs. This cuts down on use of reflection and AOP magic that spring relies on and also enables native compilation. It also makes it easier to debug and it makes it much easier to understand what is going on at the price of surprisingly little verbosity. Kofu and Jafu are basically still experimental but work quite nicely https://github.com/spring-projects-experimental/spring-fu/tr... Another trend is native compilation. Spring native just went into beta (uses the Graal compiler). That still relies on reflection but they re-engineered the internals to be more native friendly. Spring Boot basically added the notion