- NPM/Yarn/Gems etc is a disaster waiting to happen. Having lots of dependencies is a security nightmare and a maintenance issue. As these projects get dropped by their original maintainers we'll start seeing more supply-side attacks and more vulnerabilities going unpatched.
- Docker is a great solution for a specific problem. But I don't think it needs to be used for everything. Same for K8s. Same for microservices architecture.
- Simplicity is an important design goal for all systems. Complexity breeds bugs. Boilerplate is simple. DRY can be taken too far. Every abstraction layer leaks at least a little. "clever" code is usually not what is needed for reliable software.
I expect to get downvoted because these are unpopular opinions. But I'm used to arguing about them. It's always interesting to discuss.
You want a controversial opinion (on HN), how about mine:
"It's not always a good tradeoff to throw something under the bus to save developer time."
So many important things are routinely sacrificed at the altar of developer speed and comfort, app runtime performance being the big one. It's used to justify all sorts of crazy things we do in modern software to ship faster, but so hard to push back on because developers are expensive and software needs to be done yesterday.
Some things are worth giving up so that developers can move faster, but I argue not everything. Need to evaluate case by case.
Like Wordpress optimises for edit functionality, at the expense of render speed. Most of the internet is now slow, optimised for Susan From Marketing because they don't know how to edit HTML.
Same for Ruby/Rails, same for Python/Django, same for Node/whatever. Web pages render slower so that whoever edits them can do that faster.
This isn't good.
Containers are a simpler solution than Operating Systems. Operating Systems is a tightly bound non-simplistic system that breeds complexity, just as you state npm does. Because those interfaces are tightly bound, we were not about to build on top of them. Almost immediately after we got Docker, we got K8s. Once we got Docker we got the ability to manage these things at a higher level. That's the mark of a more simple solution.
Are there things that Docker can't do? Are there things that require so much performance that Docker can't handle it? Only then should you step back to the more powerful solution.
Not to say that there aren't problems with Docker. Dockerfiles have a lot to improve. Running containers has a lot to improve.
I think. I'm still at a state where I might change my mind. It's partially why I'm posting this.
[0]: https://blog.codinghorror.com/the-principle-of-least-power/
What you're thinking of is Unikernels. These are simpler than OS's. And yes, Unikernels are a good alternative to containers for a lot of applications we currently use containers for.
Counterpoint: some problem-spaces are inherently complex; most problem-spaces have hidden complexity. Complexity cannot be removed, it can only be moved up or down your tech stack, and obviously, you can needless add more complexity.
Docker, K8s and the like are perfectly fine when they fall below your project's complexity floor - they are good place to shift your complexity to as they are battle-tested and well-documented. If your projects complexity floor is lower than docker/k8s, then integrating them will just increase your solutions complexity needlessly.
I don't really agree that there is a "complexity floor". Things can always be made simpler, up to the limit of the problem space. As you say, complexity can always be added. Most projects do this. Very few stick to the minimum complexity. The complexity floor for most projects is therefore way below where that line is normally drawn.
This is the key. One of the harder things to do in software design is to find a representation of the problem that gets closest to that complexity floor. It's often not obvious.
Well, not really. These opinions are very common among my peers. We sold multi-million dollar transformation projects with the stated goal of making things simpler and easier to use and understand.
You had me at
> - Simplicity is an important design goal for all systems. Complexity breeds bugs. Boilerplate is simple. DRY can be taken too far. Every abstraction layer leaks at least a little. "clever" code is usually not what is needed for reliable software.
Nuff said.
Just this year I was working with another team that wanted to move to an architecture that I thought was overengineered for their specific problems. They shared with me an article about some company that was using it. I explained my experiences with such a pattern and where the pitfalls were, hoping their lead dev would think about it or discuss the pros and cons. Well, it was met with silence. They went ahead with their plan anyway.
Too many times that’s happened in the work world, so at least now I don’t invest a lot of effort into changing minds. Best advice
I’ve learned these last few years is don’t tie yourself to your work. If you’re opinionated about how to do things because you love designing software, that’s great, but you’re setting yourself up to be disappointed by how things really get done.
There are times for both speaking and listening in our careers; as I've progressed further in my career I have felt it is often more valuable to exercise active listening.
After couple of years people realize that just having opinion and being vocal about it does not make one a Senior/Manager/Leader. There is much more to it and one learns about it on the job.
Senior dev: This won't work but it's no use explaning why since they've made up their minds (as have I).
I feel that if I present what I think we should do, and why I think it's the best alternative, I shouldn't have to get into a shouting match or even a debate. I don't take it personally if people disagree with me.
If I've got the best ideas and my managers are ignoring them for the loudest ideas, that's on them, not me.
As always the wise approach is probably somewhere in the middle, in this case choosing your battles. You don't have to voice every opinion, but you shouldn't be silent if you have a strong and well-formed opinion about something important.
I’ve worked with too many people who think that their opinions are their identity and defended them as such. A difference of opinions shouldn’t become an excuse to go to war with your coworkers or argue endlessly instead of getting things done.
One of my worst work experiences was with a team of developers who were old friends from a college debate team. We could never have any productive discussions because they entered every conversation intent on winning instead of having an honest, productive conversation.
The best engineers I’ve worked with have had strong opinions but have also been happy and willing to go a different way if that’s what the team decides as a whole.
I've been a developer for 15 years... anybody else feel like the further they get into their career, the more they want to keep their opinions to themselves?
I feel like as a junior dev I had way stronger opinions and I was a lot more vocal about them. Now, I still have opinions, but I've learned that nobody gives a damn about my opinions so I just keep them to myself.