I've built a simple word game with my kids recently. It's fun to add stuff quickly even if they are used only by the family. It has only 5 players now and they have their own group, the family, but open to anyone if interested.
As this is already distilled information, rather than an essay/blog post, my thought was that every part is important. Just like you take notes from a course and use different UI elements to signal how each thing is important.
I’m working on https://hilogame.cc It’s a word guessing game based on binary search. Only having around 10 users for now, but hope more people will find it fun.
I wouldn’t reduce it to don't use Java/Spring Boot. Rewrites often (not always) look great because they remove years of accumulated complexity, not because the original stack was inherently bad.
Just rewrite it in X doesn't "just work" for complex systems. It ignores risk, and the fact that design usually matters more than language.
With Quarkus (and other new frameworks) you can have webapps with less than 100MiB. Startup times in a couple of miliseconds. CLI apps, with limited number of third party libraries are under 40-50MiBs.
I program in Java for more than 15 years now. I can resonate with people hating the language from it's early days due to the experience with all the enterprisy features and over abstractions. Or confunding Java with the Spring ecosystem. But Java came a long way over the years. It's now what many would call a "modern" language. It's less verbose, has many of the features people find appealing in Scala and Kotlin and it can even compile to native binaries using GraalVM. This made building CLIs in Java feasible. Or lambdas.
Fuzzing as a concept is heavily underused in routine testing. People will usually focus on positive flows and some obvious/typical negative ones. But it's almost impossible to have the time to write exhaustive testing to cover all negative and boundary scenarios. But the good news is, you don't actually have to. There are so many tools now that can almost exhaustively generate tests for you at all levels. The bad news, they are not so widely used.
I'm building a CLI that automatically generates and runs negative and boundary tests from OpenAPI Specs: https://github.com/dochia-dev/dochia-cli. It aims to reduce effort that engineers spent on this type of testing, either automatic or manual. But also making sure it comprehensively covers test scenarios which might not be considered by everyone.
Author here. It generates valid API requests based on your OpenAPI description. It also has generators that try to add meaningful values in the generated fields.
You can do a simple run to see how it goes for your API on a single endpoint with the HappyPath playbook: `dochia test -c api.yaml -s http://localhost:8080 --path /test-path --playbook Happy`.
Author here. I've just launched the tool and wanted to have some simple dev humor in it. It intentional says future testimonials.
The story is real though. And it happened with other types of hidden chars in different forms.
GraalVM is great. I built several command line apps in Java and having the ability to compile them to native code makes them start fast create a good user experience.