That's true. But in the same time I think it will be useful to _understand_ if I can deliver that vision with 10 people or with 100 people. You can start with the assumption that everyone has good intentions and will contribute similarly (in correlation with their experience and capabilities), but I think it's missing the bit that will tell you more objectively if that's the case.
As the classic saying says: there are languages everyone complains about and languages that are not (actually) used. Verbosity is usually a _good_ think especially in large code bases with large number of people (where every successful startup will eventually get)
Having people with strong opinions is important. Even more important is having a lot more people which will weight the strong ones and put the missing context :)
Seems a well balanced discussion. I think people are generalising too much when they make statements pro and against Clean Code practices. They take their context and make universally true affirmations. The context will always drive the conversation. Will you use clean code when programming micro-controllers or OS kernels or games? Probably not. Your focus is somewhere else. But for the 90+% of use cases, those practices will give other benefits which are more valuable, like better maintainability, extensibility, etc. When you start from "let's built an Electron app for example", performance is for sure not your main concern.
I've exaggerated a bit when saying close to ChatGPT. But my focus is getting something which already bundles the complexity, feed it data and start using it. Without running 100 seps to reach that state.
Why would you say that? Majority of code is repetitive. Why still focus on writing it for every project? I agree that you cannot have 100% of tests without actual code, but a significant percentage can just be feature files only.
This is why we need better tools which will give benefits for the added complexity. If you need to create both the feature files AND the code, it's just complexity with little benefits. But frameworks like https://github.com/karatelabs/karate or https://github.com/Endava/cats are hiding this complexity and remove the code layer entirely. Which, in my view, this is where you need to be in 2023, particularly for API testing.
Exactly. Saying remote works best it's a bold statement. You can give significant number of arguments for both "in the office" or "remote". Remote work has benefits, but also downsides. There is a different dynamic between people when they sit together vs when they talk remotely. Each of these interactions will foster different outputs.
Also, each of these cases start from extreme premises. "Bad managers" want workers within the office because they want to micromanage. While all employees are fully responsible, productive and albe to do their work without issues. Again, both of these are extremes and there are a lot of nuances.
I was strictly referring to the polarisation of opinions in the context of Covid vaccines. It was just a statement. (I have all my shots, covid + recommended vaccines, regular flu, etc).
I don't want to go everyday to studies, as this is not may job (although I want to have the possibility to do this when I want, which I currently can), but I need a reliable source to do this (being their actual day to day job) and read that reliable summary somewhere.
In the past years Java is a strong candidate for cmd tools.Using Quarkus + Picocli + GraalVM for native compiling, gives you a standalone binary which can be used on any platform.
I've built a tool specifically to test if these kind of characters will reach API backends: https://github.com/Endava/cats. My idea was that APIs should explicitly reject or sanitise input containing such characters.
Currently, there is some support for resource correlation. Especially when fuzzing DELETE, it will identify a successful POST based on conventions and use that as an identifier. Also checking that DELETEd resources are not available anymore.
As long as an API rejects invalid values if they are not part of an agreed list (but not enum), the same logic should apply for fields explicitly marked as enums.
HTTP headers are not meant to be a limited set. As for the HTTP methods, it's a clear recommendation from OWASP to explicitly reject methods not supported by your API. It's like converting everything not known to POST...
True. This is why I run it only for one path. I also run it against Kubernetes API and some of the payloads resulted in timeouts which I submitted to the security team.
That's true. It will definitely mitigate different category of exploits out of the box, but you still need people to acknowledge and be intentional about their decisions.
Safer languages cannot protect from bad design. Many libraries have implicit behaviour which is not always visible. It's a hard tradeoff to make. You want safety, but in the same time enough customisation and features. I worked recently with an http client library which was forbidding to send special characters in headers. I understand that this is a safety feature, but I really wanted to send weird characters (building a fuzzing tool).