Readit NewsBut is government oversight getting better?
Is this a story of local corruption, or of a larger corrupt system?
And if it has "millions of views" on Weibo, is this an indicator that the government takes it seriously, or just a means of entertaining the public with the latest scandal and establishing legitimacy of government intervention?
I don't know about the medical conditions, per se, but I think this does bring up a point that is often overlooked when discussing best practices: our brains are different and organize things in different ways.
What works and makes sense to one group of people might not work or make sense to another group of people. I find that more literal-minded people are frustrated by what they see as unnecessary abstraction and are fine with duplicated code whereas people who think in abstractions have no problem seeing the bigger picture and are proponents of abstractions when the abstractions make sense to them.
I have coworkers who will look at a codebase with a layered/onion architecture and immediately understand and reuse all of the abstractions without issue and others who will immediately want to simplify it and change it all into concrete implementations. I find myself to be fairly evenly split so I see it from both sides.
I think it's often more about the nature of the latest person who looks at the codebase than the codebase itself. Eye of the beholder and all that.
I sometimes wonder if we'll replace traditional design patterns, especially OOP, with new patterns, that are neither OOP or FP, but perhaps a different paradigm (e.g. how Prolog is wildly different from C++).
But I've met many people who hated onion architecture with a passion.
I have a few theories:
- Maybe a lot of programmers have ADHD, are autistic, or suffer from dyslexia, and find planning, naming, designing abstractions as excruciating activities.
- Onion architecture etc. is a long-term strategy that mainly benefits the company/project owner, but not the individual contributor. So it basically has to be forced upon programmers, who will resist it in every way possible, because they have no real incentive to use it.
- It's supposed to make writing software easier. But it really requires an IDE that's designed for abstractions, such as IntelliJ, and also requires a different way of working with the code. It's also verbose. So it's really a different paradigm, and it won't work if you use a plain text editor. You'll drown in code and a vast number of files.
- Onion architecture is not OOP, but often mixed in with enterprise OOP, and therefore bad associations that come with enterprise OOP.
Any other thoughts on why people resist it so much?
And what changes in how we work with code, would make onion architecture more practical?
The important part though is that people have the freedom to use, modify, and learn from them. Imho it would only be market failure if that freedom disappears.
In practice, however, the source code can be overwhelmingly large or complex, e.g. Chromium.
And yes, even if you're blocked from contributing to the project, you could 'just' fork it. But it would be incredibly hard to maintain a fork, and to get users to use/support it.
It is therefore important to distinguish between community-owned projects (e.g. Linux Foundation) that aim to be inclusive, and those that are privately-owned, and can easily have political behaviors (e.g. intentionally ignoring contributions, e.g. VSCode, because it goes against your interests, e.g. .NET, Copilot, etc.).
Yes, open source is now common place.
But I sometimes wonder if it, too, is a market failure, in that many projects are governed by, or mostly funded by, single entities, e.g. Facebook (React), Google (Flutter, Go, Android), Docker (Docker), and so on...
Is C++ a better example of open source, with broad industry contributions?
What about WebAssembly? Major browsers (Chromium) can pretty much refuse to support some functionality, and that'll be the end of that. The power centralization has severe consequences for openness.
I'm not convinced that community/industry-driven public-good type of FOSS will continue to flourish. If anything, I worry that we'll end up with a bunch of "open source" projects that in reality have built-in limitations (or as the author said "a carefully engineered bottleneck"), that prevent truly open adoption (like HashiCorp preventing contributions that compete with their commercial edition feature offering).
Edit: Could this have been used to hijack/create TLS certificates?
With things like banning any equipment including clothing and shoes... Or with cycling giving one standard mass manufactured piece. And then a pile of standard replacement parts and standard tools. All bought from cheapest supplier randomly distributed to participants.
Similarly in football, by studying your opponents in previous matches, so that you can identify weaknesses during the match, even if playing in isolation.
So it's important that the penalties are significant enough to deter non-compliance.
- Web frontend: TypeScript (maybe Gleam in the future!?)
- Fast performance and iteration if I want a binary: Kotlin (native compiled)
- Blazingly fast and good for WASM: Rust
- languages that I keep an eye on: Gleam, Zig, Odin
- languages that I will never touch: C, C++
- languages that I think are quaint: OCamel, Lisp, Haskel
- languages that I have used in the past and that are fine: Dart
- languages that I have used in the past and that are ok: Java (if it had nullability, it'd be fine)
I appreciate their work on native/wasm, and I think it's great if they could be financially rewarded/sponsored for that work. It's just unfortunate that it has to be in the shape of an IDE dependency.