Software design gets worse before it gets better • Hacker News Board

Re: Software design gets worse before it gets better

#121

Post by prerok » Sat, Jun 22, 2024, 1:32 PM UTC

rqtwteye wrote: post #115

prerok wrote: post #110

Earlier quoted context omitted.

I think this is actually addressed in the article: > The key question for the designer is, “What would the system’s structure need to be so that would be no harder to implement than necessary?” (It’s a bit surprising when designers don’t ask this question, instead simply asking, “What should the design look like?”—for what purpose?) During my career, I have been in many situations where the SW architects tried to ans…

I have concluded that smaller is better and straightforward is better. I think it’s easier to scale up a small system than to maintain a complex system that was built for scale from the ground up but usually got some things wrong because the requirements at the time weren’t clear. But in the end there is never a clear answer. I am happy when people can explain what the positives and also the drawbacks of a design are…

Indeed, could not agree more. Also, using composition over inheritance is age old advice but that still did not prevent those architectural astronauts from creating inheritance structures 15+ levels deep. Luckily, newer languages make constructing such monstrosities harder and discouraged.

Re: Software design gets worse before it gets better

#122

Post by chuckadams » Sat, Jun 22, 2024, 1:38 PM UTC

danybittel wrote: post #93

My experience is the exact opposite. To implement a new feature, I usually first refactor, make space for the new feature, improve existing design. (uphill). Then I implement the new feature as pristine and clear as possible (top). Then I face the reality, integration tests fail, I add edge cases I forgot, (downhill). And I end up at the bottom, ready to push that abomination to git and forget about it.

As one of my commits said:

    * Replaced dusty old bugs with shiny new bugs.

Re: Software design gets worse before it gets better

#123

Post by tamiral » Sat, Jun 22, 2024, 1:48 PM UTC

throwAGIway wrote: post #98

m463 wrote: post #97

Earlier quoted context omitted.

I think "better" is ambiguous. Better for developers? Better for users? Better for speed? Better for maintenance? Better license? Better software stack? Better telemetry? Better revenues through subscriptions?

At a business, all of these - a good engineer/architect has to find the right balance.

I find the biggest issues in industry and organizations is so called “tech debt” and no plan for future improvement of a solution as it matures or user base scales. Planning for these is essential.

Re: Software design gets worse before it gets better

#124

Post by sylware » Sat, Jun 22, 2024, 1:50 PM UTC

ahartmetz wrote: post #116

sylware wrote: post #112

Earlier quoted context omitted.

wayland annoys the toxic people, because it is currently favoring easy alternative implementations. It won't last, probably. Those toxic people usually always get their way into "core", pouring tons and tons of interfaces and dirty everything, viciously adding "features" to provoke some level of planned obsolescences over some few years cycles. Pure evil.

I'm not sure who you are being sarcastic about in the end, but yes, Wayland is indeed clean and simple enough to not particularly discourage alternative implementations.

Huh.

Indeed, we agree.

We just need to do the hardest part: keep it clean and simple to not particularly discourage alternative implementations... on the long run.

Re: Software design gets worse before it gets better

#125

Post by ahartmetz » Sat, Jun 22, 2024, 1:55 PM UTC

sylware wrote: post #124

ahartmetz wrote: post #116

Earlier quoted context omitted.

I'm not sure who you are being sarcastic about in the end, but yes, Wayland is indeed clean and simple enough to not particularly discourage alternative implementations.

Huh. Indeed, we agree. We just need to do the hardest part: keep it clean and simple to not particularly discourage alternative implementations... on the long run.

...while also doing what users want and expect.

Re: Software design gets worse before it gets better

#126

Post by AndriyKunitsyn » Sat, Jun 22, 2024, 1:56 PM UTC

ozim wrote: post #25

mattgreenrocks wrote: post #5

The multi-dimensional nature of this problem makes it extremely fascinating to me, even twenty years into my career. There's a certain dopamine hit you get for voluntarily trudging into the trough of despair, pushing the Sisphyean boulder of better design uphill in the optimistic belief that you can do better, and then actually arriving at something slightly better. Way more fun than conceptualizing programming as du…

Only if people wouldn’t switch jobs every 2 years. Only if new joiners wouldn’t feel like they have to “show up with something” making existing stuff obsolete. Well not blaming people or companies just thinking out loud.

Is it really impossible for an individual engineer to make decisions that are good for business, and still feel inclined to job-hop?

Re: Software design gets worse before it gets better

#127

Post by sylware » Sat, Jun 22, 2024, 2:02 PM UTC

ahartmetz wrote: post #125

sylware wrote: post #124

Earlier quoted context omitted.

Huh. Indeed, we agree. We just need to do the hardest part: keep it clean and simple to not particularly discourage alternative implementations... on the long run.

...while also doing what users want and expect.

... while avoiding their tantrums which will most likely destroy that "clean and simple".

Re: Software design gets worse before it gets better

#128

Post by throwAGIway » Sat, Jun 22, 2024, 2:02 PM UTC

prerok wrote: post #121

rqtwteye wrote: post #115

Earlier quoted context omitted.

I have concluded that smaller is better and straightforward is better. I think it’s easier to scale up a small system than to maintain a complex system that was built for scale from the ground up but usually got some things wrong because the requirements at the time weren’t clear. But in the end there is never a clear answer. I am happy when people can explain what the positives and also the drawbacks of a design are…

Indeed, could not agree more. Also, using composition over inheritance is age old advice but that still did not prevent those architectural astronauts from creating inheritance structures 15+ levels deep. Luckily, newer languages make constructing such monstrosities harder and discouraged.

Just having a huge bikeshedding festival at work after I wrote this sentence into guidelines...

The worst thing is how hard it is to talk about it because all the books - by authors making more money from talking about software than from writing and maintaining code - recommend it, and it's just so SOLID and Hexagonal and looks obviously intuitively correct.

Re: Software design gets worse before it gets better

#129

Post by prerok » Sat, Jun 22, 2024, 3:43 PM UTC

throwAGIway wrote: post #128

prerok wrote: post #121

Earlier quoted context omitted.

Indeed, could not agree more. Also, using composition over inheritance is age old advice but that still did not prevent those architectural astronauts from creating inheritance structures 15+ levels deep. Luckily, newer languages make constructing such monstrosities harder and discouraged.

Just having a huge bikeshedding festival at work after I wrote this sentence into guidelines... The worst thing is how hard it is to talk about it because all the books - by authors making more money from talking about software than from writing and maintaining code - recommend it, and it's just so SOLID and Hexagonal and looks obviously intuitively correct.

Can you elaborate, you have piqued my interest :)

The sentence for preferring "composition over inheritance" for code reuse is in the book by the gang of four (the design patterns book). I really don't understand how we ended up in the situation, where 30 years old advice is still valid and still not followed. I lay, perhaps too much, blame on Java, which seems to have this baked into its infrastructure, but similar approaches have also been adopted in C++ with multiple inheritance making things even worse.

I mean, SOLID, when used appropriately, is also valid. The problem is that the design patterns are used where a simpler solution would work just as well.

Re: Software design gets worse before it gets better

#130

Post by jt2190 » Sat, Jun 22, 2024, 3:55 PM UTC

pydry wrote: post #99

NegativeK wrote: post #55

Earlier quoted context omitted.

A good dev I worked with was promoted to senior, due to a vacancy. They were an improvement on the decent abilities of the person who left. The CTO confided in me one day, around six months to a year after the promotion, that the dev deserved a fat salary raise because they were doing well with their new responsibilities -- but the CTO was worried that promoted dev would expect that kind of pay raise again in the fut…

The CTO was more likely being dishonest rather than stupid. Most justifications for not giving a pay raise are carefully crafted bullshit designed to sound reasonable. After all, if the reason is "I want more money available for me and the shareholders" you can't just say it.

If the company has gotten to the point that the only way to provide returns to the shareholders is to squeeze employee salaries, take that as a sign that the company can’t increase revenue and is struggling, and it’s time to look for another job.

(If, for some reason, the company is making gobs of money for the shareholders but management has still decided to squeeze employee salaries, increasing the risk of loosing key people that help generate that revenue, also leave because those managers will end up destroying the company.)