This is exactly my view, especially with the web apps. If you take a distributed system, the majority of components/microservices will have more than 50% commonality in behaviour. Therefore you do mostly the same things when you start a new one. Even if code itself might be harder to generate, as even a CRUD app might have specific behaviour, testing it is definitely the same, especially when doing negative scenarios, boundary testing, CRUD operations, etc. I wrote a tool specifically for this purpose, targeted at REST APIs, aiming to automate this repetitive work and let you focus on the tests which are specific to the context.
The fact that you will have inconsistencies doesn't mean you don't need to thrive for a standard where you have control. It will still significantly simplify things.
To be honest these feel like excuses to avoid structure. Keeping things consistent is something that require dedication and explicit effort. Just saying "everyone just do logging in their preferred format" seems the easiest way.
Structured logging gives you lots of benefits. You monitoring will just work out of the box if you keep to the standard. Additional logs won't arbitrarily come up within your system with no anticipation. I'm not saying it will never happen, but you have control over it.
I'm currently writing a Java desktop app. I thought about using electron and others, but outside Qt, which seems like the "best framework", there isn't something without tradeoffs. Starting with JavaFX was quite simple (having a Java background helps). What I miss is the level documentation that you can typically find for Java.
Yes. I think this is something technical people usually forget: you need to be able to quantify technical debt somehow in order to get relevant. Otherwise it seems that tech people wanting everything to be cool and shiny
It's fun to build simple stuff that work, but it's even more rewarding to build stuff you actually use every day.
I made a simple expense tracker that will parse the SMS messages I get from the bank when paying for stuff, categorise based on merchant categories and push it to a google spreadsheet for traceability and visual charts. Good opportunity to play with building native images (it's done in java) in order to minimise resource usage as it's deployed in a 5$ digital ocean droplet.
10 years ago I've built a Swing app to generate invoices in a local compliant format. It was great to flexibility to customise everything.
Thanks. I'm also looking for ways to have cash at hand i.e. ability to use them at any time, rather than investing different products. The reason for mentioning bank accounts in different banks/countries is due to uncertainty in different regions.
Leaving the low level languages aside, most of the top level one can achieve the same things with similar costs. It's still up to the individual/team skill how those apps/systems end up to be built. If some project fails, is rarely "picking the wrong language" reason...
Java didn't have all these things, because there were a lot of very good libraries already doing that. Adding them inside a project is trivial. I think this approached encouraged creating alternatives to the standard APIs as well as extensions which in the end made the language even more rich.
How do you measure "mediocre"? And what do you mean by inefficient? In any language you can code 99% of the things needed by 99% of most of the systems.
Most of the "I love/hate this language" is usually subjective perception or strong preference for certain programming paradigms: people loving/hating OOP, people love/hating verbosity and so forth.
I've written an API Fuzzer that (among other things) tests specifically for things like this: https://github.com/Endava/cats (with a lot more other unicode special chars). People many times forget how big the Unicode standard is and that a lot of Control Characters are used by different processors for specific logic not-very-obvious logic.
This is an OpenAPI Fuzzer that I've been working on for a while. It has a significant number of fuzzers covering most the negative/boundary testing. It's written in Java and compiled to native using GraalVM - you can run it as any typical CLI tool. This is the first thing I run when building or extending any OpenAPI endpoint. I hope you find it useful.
Looks like a good start. Things can get complicated when going into request bodies, especially oneOf, anyOf relations.
I went through this journey while writing a similar tool: https://github.com/Endava/cats. Currently it has 72 Fuzzers registered which cover quite a lot of scenarios.
I'm honestly happy I see "Insecure Design" into the list. With all the buzzwordy Agileness people often forget that (at least) high level design is important and brings a lot of value if done early on.
Why does it always has to be language 1 vs language 2? "Better" is hardly something objective about languages. This is why people are still building new languages every year. To make things "better", although ultimately a bunch of others will find quite a big list of why they don't like it. Just pick whatever language you like. As long as you have good tooling and community around it, it won't be neither the best nor the worst choice... It's just "a choice"... Projects hardly fail because of the language itself (although there are some well known failures with dynamically typed languages). It's mostly bad architectural or business decisions...