It's clearly not clear cut, it's a whole spectrum. I wish more web developers would at least ask themselves the question before having knee-jerk reactions reaching for their favorite framework of the day.
Nice reasoning. It very well highlights the tradeoffs coming the choice they made. And of course the decision might change if the situation changes.
To take with a pinch of salt, it conflates a few things in my opinion. Still it's a good reminder that eliminating complexity shouldn't be a goal. Managing said complexity and avoiding the undue one, this is what matters.
Excellent points. Don't be fooled by alluring architecture changes. Always keep the complexity in check and favor tuning what's already here or changing your use patterns to meet the performance you need.
Hosting applications can be cheap and simple. You need to cater to complexity and mind your dependencies.
A bit sarcastic, but makes its point efficiently. It's important to realize that more code to maintain is definitely not what we need.
Good piece about the hype cycles our industry constantly fall into. So much undue complexity for nothing in some projects... and then we'll complain about technical debt. It would have been much easier to pick the right tool instead of wanting to use whatever new got released by some big tech company.
Neat little resource. We indeed should pay more attention to complexity across our industry.
Interesting parallel taken with IKEA. Some of their principles translate to nice traits for software as well.
Very interesting case full of lessons. Of course, increasing the complexity of the system overall can lead to such hard to find issues. It's also a tale into how seemingly innocuous settings can interact in unexpected ways. I also like the lessons learn pointing to the fact that you can and should debug even the systems you use through abstractions, diving into the code is almost always a good thing (even if in this particular case it wasn't strictly necessary in the end). And last but not least it shows the tension between mastery and automation... the more you automate the least you master the system, and at the same time this automation is necessary for building resilience in the system.
Definitely this. This is an interesting talk, most thing shouldn't be shiny. It's not about stagnating of course, but you should think more than twice before adding a new technology to your stack. Mastery is when you know everything that's wrong with a piece of tech, before that keep in mind the amount of unknown unknowns and the cost of exploiting something new.
Even the giants are slowly moving back from microservices. DHH has a very cruel way to point it out, still that's true. Let's hope people realize the mistake it was in term of complexity.
Interesting train of thoughts. Indeed we should keep in mind that large scale software is almost always a complex adaptative system, even more so if we don't forget the people developing it and not just focusing on the code. This can give us guidelines on how to organize the development.
Also does a good recap about what a complex system is and how it behaves. Definitely worth a read at least for this.
They were probably using RabbitMQ for the wrong scenario in the first place. That said it's a good reminder that sometimes a simpler architecture is what you want and it can bring benefits.
It's been a while since I dived into reading a Ph.D thesis... I bumped into that one through an article which was trying to summarize it but I wasn't super happy with it. That's why I decided to go to the source.
It's an interesting read, it has the benefit of making a clear difference between complicated and complex from the get go, which is welcome (generally a good sign for me).
If you want the tl;dr it's at the end of page 16:
"we found that differences in architectural complexity accounted for differences in developer productivity of 50%, three-fold differences in defect density, and order-of-magnitude differences in staff turnover".
Note the last point about the staff turnover should be taken with a grain of salt though. It is well explained in the limitations of the study, being a lot in the high complexity areas of the code can also be a sign of higher skills and thus more job opportunities.
Anyway, I think we all suspected some link between complexity and productivity but I always wondered how much. Seeing how the study was done it's definitely not an absolute answer (very thorough and precise, even historical data taken into account over several releases... but in a single company). Still the value is in at last giving us some rough numbers on how far the impacts can go. Thus, the scale of those impacts are potentially huge.
Maybe it's time to stop trying to find rockstar developers or mythical 10x developers (common "leprechauns" of our industry)... Let's focus on tackling undue or uncontrolled architectural and code complexity instead, shall we? Even better if that's done through the use of documented patterns when applicable.
Interestingly, the literature review part gives a few clues about why there is under-investment in architecture in general, or reworking the architecture on long term project. It's unclear to organizations the costs of the undue complexity will carry. It's exactly what this thesis tries to shed light on (see tl;dr above).
Also, it's interesting to see confirmed that the perception of the architectural complexity we have is often wrong when looking at parts in isolation. The relationships need to be transitively mapped to start to grasp the presence of architectural complexity. That's why only coordinated efforts can tackle it, it's almost impossible to tackle for a single developer.
Of course I'd advise reading it in full, that requires investing some time into it though.
Very stimulating, I'd like to apply some of those tools on projects in the wild but I'm not sure there are ready made tools available. Also I'm wondering what we would find if I'd reuse some of those in ComDaAn to work on temporality of changes rather than dependencies. I think this could give interesting insights.
Now, this is interesting research. With all that complexity, emergence is bound to happen. There's a chance to explain how and why. The links with the training data quality and the prompts themselves are interesting. It also explains a lot of the uncertainty.
Definitely this. If it's too fancy and fashionable you're likely to pay it in later with the undue complexity it introduced.
Indeed, in some type of projects people tend to turn to Dependency Injection Frameworks a bit blindly (especially true in the Java world). Still there are other patterns which give similar benefits without less headaches. That's worth investigating if this fits your context before picking up a framework.
A bit of a rant so brace yourselves. Still, it's very much aligned with the current backslash against "everything must be an SPA" trend and makes very good points on how it happened. This indeed turned into a popularity contest based on false premises. Meanwhile... complexity increased dramatically on the web frontend side and the performances are bad for most users.
Good musing about simple code and complexity. We definitely should avoid unwarranted complexity in our code, or at least try to prevent it's spreading.