Confidence can be achieved using https://en.wikipedia.org/wiki/Mutation_testing. this involves running an engine that mutates your code and check if you have at least one assertion failing.
Java reached somehow parity with Go performance when using GraalVM and virtual threads. For a Java shop, this will minimize the appeal to move everything to Go as the gains are marginal.
As this targets developers, aren't developers supposed to be familiar with the terminal. So doing `chmod +x` is trivial. Especially since they probably use a lot of other tooling to build, package, deploy, etc.
This wasn't a big refactor to be honest. It was just a recursion which ChatGPT suggested to be replaced with an iterative approach. This is why I've asked the question, as maybe I'm not setting the right context. I've provided regexes that were overflowing, etc.
Context is very important. If this happens overnight and out of nowhere/excess pro-activity, it's definitely an issue.
But the reality is usually more nuanced. Even saying that because of this particular situation clean code is bad, it's an exageration.
> Firstly, I didn’t talk to the person who wrote it.
This might be an issue in itself sometimes. People identifying with the code they wrote. When you are part of the team, the code belongs to everyone. Everyone should be able to change it if it makes sense and all quality gates are passing.
Kind of a similar approach: one drawer for paperwork, google drive for all files, evernote for all notes with a dedicated notebook for different frequent used stuff like IDs, birth certificates, etc. Use search when I need something digital. Periodically throw away warranties and manuals from the big drawer (every 1-2 years) :)
This starts with the assumption that people/devs are oriented towards continuous improvements for all their activities. Which is not always the case in real life. There is a small amount of people who will want this (which on the other hand do other productive stuff in the 15 minutes their tests run). While the majority are just "waiting" for those 15 minutes to have an excuse to do something else.
Out of this frustration I've built: https://github.com/Endava/cats. It's for APIs, but mostly addressing exactly this case: don't use strings for everything, if you choose to use it though, make sure you add patterns for checking if things are valid, make sure you think about all the corner cases and all the weird characters that can brake you app, and so on.
OnePlus is pretty close to stock. Very fast, very good battery. It's the only Android I've loved before switching to iPhone.
I have a Samsung and a OnePlus 5T bought in the same period (around 5 years ago). The OnePlus still rocks 1 day battery with medium usage, while the Samsung is dead in a couple of hours.
It's always hard to balance delivering fast vs delivering quality software. I've been involved into multiple similar reviews were I'm coming as an outsider and assess existing platforms. Both what people will typically call "legacy" but also "modern" (read microservices) ones. Without a clear governance and consistency any of the approaches will end up with similar issues: performance, scalability, hard to extend/maintain, excessive use of tooling (there was one platform that kept all logs in a log aggregating tool, but didn't have any way to get the raw data). You can be fast and consistent/have a clear vision. No need to get it to production "no matter what".
This is why fuzzing is so important for every system. It will throw all kind of unpredictable input at your system and check how it behaves. There are so many tools out there, just waiting to be used :)
Fuzzing is just a measure to monitor that you didn't miss any areas. You might guard your code using well defined patterns or behaviours, but you cannot be perfect at it. Fuzzing will make sure you do this consistently.
It might be just my impression, but fuzz testing is underrated and not usually considered as something mandatory for a given system. It's setup cost is not high, and gives enough benefits. As long as you have it in place, you can focus on more functional testing, rather than negative scenarios, which are already covered through fuzzing.
And tooling is getting better, moving up the application layer. API spec standards like OpenAPI (and adoption of it) enable fuzzing on APIs which was significantly hard to setup prior to this.
I totally agree. This is why is bad to "measure". When you say measure, everything will look right in the end. But if you say "monitor", at least to me it feels more towards: "I'm proactively looking at my team to see how it goes. I have a way to see when things will start to go wrong. I can also see how productive people are by correlating data. If I just take PRs as an isolated number, it's not relevant. But if I take it, and see that 80% are actually bug fixes, that raises an issue in itself"
On a tangential note I've also asked here (https://news.ycombinator.com/item?id=35245329) what will be some performance indicators to take into consideration when delivering software. That '50 PRs in 6 months' is interesting. You might argue that "it's important to deliver business value" and "as long as your hitting your market/business capabilities targets" everyone is happy. But my question is still: "how do you know you are being efficient? can you still deliver with half the number of people?".