Moritz Becker retweeted
JEP 401: Value Objects (preview) targeted to JDK 28 today :-)
openjdk.org/jeps/401
"Java for the AI world"
#java #AI
Moritz Becker retweeted
JEP 540: Simple JSON API as a new candidate! A lightweight API for parsing JSON in the Java Platform. JSON has become the universal language of modern applications, yet even simple JSON processing requires third-party dependencies.
openjdk.org/jeps/540
"Java for the AI world"
Moritz Becker retweeted
The Java Story | The Official Documentary youtu.be/ZqGSg4b_cZA?si=rMod…
Moritz Becker retweeted
JEP 401: value objects moving to candidate :-) Value objects will enable a major step forward for Java. They give the JVM more freedom to reduce memory usage, GC pressure and model specialized numeric AI types with performance closer to primitive types.
openjdk.org/jeps/401
How is it possible that @supabase does still not support rate limiting?
32
Moritz Becker retweeted
Microservices is the software industry’s most successful confidence scam. It convinces small teams that they are “thinking big” while systematically destroying their ability to move at all. It flatters ambition by weaponizing insecurity: if you’re not running a constellation of services, are you even a real company? Never mind that this architecture was invented to cope with organizational dysfunction at planetary scale. Now it’s being prescribed to teams that still share a Slack channel and a lunch table.
Small teams run on shared context. That is their superpower. Everyone can reason end-to-end. Everyone can change anything. Microservices vaporize that advantage on contact. They replace shared understanding with distributed ignorance. No one owns the whole anymore. Everyone owns a shard. The system becomes something that merely happens to the team, rather than something the team actively understands. This isn’t sophistication. It’s abdication.
Then comes the operational farce. Each service demands its own pipeline, secrets, alerts, metrics, dashboards, permissions, backups, and rituals of appeasement. You don’t “deploy” anymore—you synchronize a fleet. One bug now requires a multi-service autopsy. A feature release becomes a coordination exercise across artificial borders you invented for no reason. You didn’t simplify your system. You shattered it and called the debris “architecture.”
Microservices also lock incompetence in amber. You are forced to define APIs before you understand your own business. Guesses become contracts. Bad ideas become permanent dependencies. Every early mistake metastasizes through the network. In a monolith, wrong thinking is corrected with a refactor. In microservices, wrong thinking becomes infrastructure. You don’t just regret it—you host it, version it, and monitor it.
The claim that monoliths don’t scale is one of the dumbest lies in modern engineering folklore. What doesn’t scale is chaos. What doesn’t scale is process cosplay. What doesn’t scale is pretending you’re Netflix while shipping a glorified CRUD app. Monoliths scale just fine when teams have discipline, tests, and restraint. But restraint isn’t fashionable, and boring doesn’t make conference talks.
Microservices for small teams is not a technical mistake—it is a philosophical failure. It announces, loudly, that the team does not trust itself to understand its own system. It replaces accountability with protocol and momentum with middleware. You don’t get “future proofing.” You get permanent drag. And by the time you finally earn the scale that might justify this circus, your speed, your clarity, and your product instincts will already be gone.
Moritz Becker retweeted
"You don't need an ORM"
Goes on to build their own custom ORM.
Every single time.
Moritz Becker retweeted
stateOfSoftwareDevelopmentIn2025 redd.it/1mxj5ge
Moritz Becker retweeted
We just released #BlazePersistence 1.6.16 with some fixes for @Hibernate ORM 7+, GraphQL enhancements and bug fixes. For further information, take a look into the release announcement: persistence.blazebit.com/new…
Moritz Becker retweeted
Virtual Threads With Java 24 - Will it Scale? gaetanopiazzolla.github.io/j…
Moritz Becker retweeted
We are working on a new big project for @GraalVM — Project Crema: github.com/oracle/graal/issu….
It will lift Native Image's default closed-world assumption by allowing dynamic loading and execution of classes at run time.
Stay tuned for updates!
Moritz Becker retweeted
🐬 MySQL Query Optimization with Releem
vladmihalcea.com/mysql-query…
Moritz Becker retweeted
Article from Quanta this morning in the comments. As @burkov, @ChombaBupe, @GaryMarcus, and many others have been clearly stating, LLMs are not the path to more sophisticated reasoning models (I am not going to say AGI because that is just science fiction). From the article:
“Dziri’s team showed that LLMs that have only been trained to predict the next word in a sequence — which is most of them — are fundamentally limited in their ability to solve compositional reasoning tasks. Other researchers have shown that transformers, the neural network architecture used by most LLMs, have hard mathematical bounds when it comes to solving such problems. Scientists have had some successes pushing transformers past these limits, but those increasingly look like short-term fixes. If so, it means there are fundamental computational caps on the abilities of these forms of artificial intelligence — which may mean it’s time to consider other approaches.”
Moritz Becker retweeted
Another local company that used Scala heavily 5 years ago is rewriting to Java because of difficulties with the language. People who think Scala is on the rise are delusional, sorry.
Moritz Becker retweeted
We just released #BlazePersistence 1.6.14 with some fixes for @Hibernate ORM 6+. For further information, take a look into the release announcement: persistence.blazebit.com/new…
Moritz Becker retweeted
We just released #BlazePersistence 1.6.13 with some fixes for @Hibernate ORM 6.6 and latest Quarkus versions. For further information, take a look into the release announcement: persistence.blazebit.com/new…
Moritz Becker retweeted
I keep hearing that OOP makes programs unbearably slow. The writer invariably mentions fast non-OO systems (though they never seem to mention the myriad slow non-OO systems). If that's you, can you please prove to me that the slowness is directly attributable to OO, as opposed to just being run-of-the-mill bad programming that could happen in any language? Thanks.
Moritz Becker retweeted
"Microservices first" indicates that the person advocating that idea isn't thinking like an architect. No single architectural pattern is appropriate in all contexts. An architect will first identify the essential system characteristics and then pick an architectural pattern with pros and cons that match the characteristics. Microservices are fault-tolerant, highly elastic and scalable, incremental-development friendly, and support hot deploys into running systems. They are also slow, complex, and network-based (I see that as a huge negative). Use the pattern if those characteristics (pros and cons) work for you. If they don't, use a different pattern. There's also a third choice. A very simple microservice system can run as threaded components in a monolith, thereby giving up the elasticity but also lowering the complexity quite a bit by getting rid of the network issues. In other words, you can meld patterns to create new patterns. It's all about identifying characteristics and choosing (or inventing) appropriate patterns.

















