Live data from Hacker News

Software development is a loser’s game

thehosk.medium.com

131–140 of 159 posts

Re: Software development is a loser’s game

#131
post #11

Because long-term maintenance isn't the concern. Most devs switch jobs in 2-5 years (or at least that's the common advice given). So the incentive is to play musical chairs, and hope that you've moved on by the time the music stops. Software has also been such a new field that it was the startup that moved fast and broke things that got the prize rather than the slow but stable company. I think this is changing (lowe…

That's the advice I've given: No equity? Chose the tech stack of the next place you want to work at and leave after 2 years.

Re: Software development is a loser’s game

#132
post #31

Big fan of Tom Gamon's Programming is a Losers Game (Sept 2020)[1]. Tom's short post was a very welcome introduction to the matter for me, very open ended, & Ben Hosking here elaborates much more clearly specific concerns & outlooks. [1] https://tomgamon.com/posts/a-losers-game/ Both Ben in this "Software" and Tom Gamon in "Programming" anchor their arguments to Charles Ellis, & his example of tennis as a game where…

One missing link, Steve Yeggie's Notes from the Mystery Machine Bus[1], whose core thesis is that:

> Software engineering has its own political axis, ranging from conservative to liberal.

Which is really very much at the heart of what this whole winners vs losers game discussion is about, I think.

[1] https://gist.github.com/cornchz/3313150

Re: Software development is a loser’s game

#133

Earlier quoted context omitted.

This reminds me of advice I give to junior devs who over-complicate things in the planning phase: "Start with the stupidest thing that will work". You need to make something work before you can make it work well. You need to start simple before you dig into the complexity. Sometimes you find that the "stupid" solution is good enough.

I think it's important to note here that you need to start your thinking or design from the simplest possible solution, but that doesn't mean it always makes sense to actually implememt that solution.

Agreed. That's why I advise to start simple/stupid, not necessarily deploy the stupid solution. It's a direct response to those who start out with crazy-complicated schemes in mind.

Re: Software development is a loser’s game

#134

Earlier quoted context omitted.

This reminds me of advice I give to junior devs who over-complicate things in the planning phase: "Start with the stupidest thing that will work". You need to make something work before you can make it work well. You need to start simple before you dig into the complexity. Sometimes you find that the "stupid" solution is good enough.

I wonder if there is something going wrong in the software engineering education pipeline that is encouraging developers to always keep reaching for the most complex tool in the toolbox rather than the simplest. We all see this all the time, so the problem is widespread. Maybe it’s not education but career growth: It sounds like “resume-driven development” where people are incentivized to add complex tools to their t…

I think it's just inherent in the personality types that are successful at software. We are good at understandinging complex things, and we like it; it makes us feel good to master them, and creating one is a special variety of mastery, so we incline towards that.

I think it also takes experience to see that simple solutions can be more robust; the more natural response to foreseeing future problems (another trait) is to have specific responses for all of them, which generates a complex result.

Re: Software development is a loser’s game

#135

Earlier quoted context omitted.

This reminds me of advice I give to junior devs who over-complicate things in the planning phase: "Start with the stupidest thing that will work". You need to make something work before you can make it work well. You need to start simple before you dig into the complexity. Sometimes you find that the "stupid" solution is good enough.

I wonder if there is something going wrong in the software engineering education pipeline that is encouraging developers to always keep reaching for the most complex tool in the toolbox rather than the simplest. We all see this all the time, so the problem is widespread. Maybe it’s not education but career growth: It sounds like “resume-driven development” where people are incentivized to add complex tools to their t…

I hear this often, and I see many on HN be in favor of this narrative, but I have the opposite experience. Its often the cargo-culting companies pushing these soft requirements onto education, as students and companies will otherwise complain about not being employable / finding starters who reach their expectations respectively. Most of the time, I see seniors reach for overly complicated solutions, when much simpler solutions exist. Which later falls apart when errors happen silently and simple ideologies like "single truth" are ignored for no particularly good reason, leading to massive duplicate code and gotchas.

At this point, I'm extremely unconvinced the problem is just education or juniority/seniority. The "paper factory" is just doing what companies are demanding. The real problem is a general lack of competence being used to market products, be they good when used properly (e.g. GoF, where many readers only look at design patterns and completely forget "composition over inheritance"), or snake oil.

Re: Software development is a loser’s game

#136

Earlier quoted context omitted.

This reminds me of advice I give to junior devs who over-complicate things in the planning phase: "Start with the stupidest thing that will work". You need to make something work before you can make it work well. You need to start simple before you dig into the complexity. Sometimes you find that the "stupid" solution is good enough.

I wonder if there is something going wrong in the software engineering education pipeline that is encouraging developers to always keep reaching for the most complex tool in the toolbox rather than the simplest. We all see this all the time, so the problem is widespread. Maybe it’s not education but career growth: It sounds like “resume-driven development” where people are incentivized to add complex tools to their t…

Sometimes people haven't been exposed to different ways to solve problems, so they reach for the first thing that comes to mind. Sometimes the never learn to consider multiple solutions and weigh their costs and benefits.

I once had a boss who still coded, even though all the developers begged him to stop. His code was spaghetti, but worse was his inability to come up with more than one solution to a problem. If the first solution he came up with was complicated and error-prone then that's the one he proceeded with.

Re: Software development is a loser’s game

#137
post #91

Earlier quoted context omitted.

> In many years there has not been a single time the unit test saved me from anything. You've never even made a typo that a unit test has helped you spot? You've never, ever, had a unit test show you that one of the assumptions was wrong that you made about the behaviour of a piece of third party code? That seems mighty unusual to me...

As I said, I try to always thoroughly understand anything I am about to modify. For example, if I change a function body I always familiarize myself with how the function is being used, exactly, what the code of the function does, exactly and how other function it calls work, exactly.

I’m afraid I find this somewhat unlikely, or if you are genuinely not only this careful but this fault-less, can only imagine you progress at a very slow pace.

Do you not consider unit tests useful because they might help others understand and catch changes to the implicit contracts in your own code?

Re: Software development is a loser’s game

#138
post #99

> Unit testing In the game development, videogames are primarily tested by humans. Games are highly interactive pieces of software often running on a variety of hardware with complex agent-based simulations. Are all game developers "amateurs"? I don't think so.

Videogames overall are primary tested by humans, but smaller components inside them do have unit tests. Unit test and integration testing are two different things.

Hmmmm, how would you test, for instance, a rendering engine?

Re: Software development is a loser’s game

#139
A vapid post that doesn't cover a vast range of 'winning' development strategies that aren't about 'not losing'. Direct things like really understanding the problem you're trying to solve; Making invalid states unrepresentable; Using composable techniques to separate parts of a problem that can be combined safely and meaningfully.

Re: Software development is a loser’s game

#140

Earlier quoted context omitted.

I think you're right, but I also think the author isn't necessarily wrong. Using his tennis analogy, each chunk of code written is like swinging at the tennis ball. You don't have to have the perfect curve-ball, you just have to NOT screw it up. I've too often seen developers try to attack the ball with the perfect swing and the most force possible, only to have it go straight into the net. If they just focused on ge…

This reminds me of advice I give to junior devs who over-complicate things in the planning phase: "Start with the stupidest thing that will work". You need to make something work before you can make it work well. You need to start simple before you dig into the complexity. Sometimes you find that the "stupid" solution is good enough.

> This reminds me of advice I give to junior devs who over-complicate things in the planning phase: "Start with the stupidest thing that will work".

> You need to make something work before you can make it work well. You need to start simple before you dig into the complexity. Sometimes you find that the "stupid" solution is good enough.

100% true.

People love to dig at Test Driven Development, but it solves a common problem and is great for junior developers because it has 3 important rules.

1. Understand your requirements. And not in a wishy-washy hand-wavey way. But in an explicit, expressed as a single test verifiable/falsifiable requirement.

2. Implement the simplest solution that meets your requirements. Don't over-engineer anything, don't chase the latest fad, don't sleeve solve a way more complicated generic problem that you think we'll hit later, because you don't have enough experience to know how likely we are to hit it and the costs to make that tradeoff.

3. Keep you codebase clean and well factored. Don't let cruft and hacks build up.

Ignoring TDD, any junior engineer that can consistently exhibit those three behaviors is almost by no longer a junior engineer. Those are hard things to learn as an early coder.

Yes as you become mid-level and senior you should be more independent and break the above often - but at that point you have good foundations and the experience to make the tradeoffs to know when to deviate and by how much.

TDD is a very effective method for solving a problem that otherwise often takes a while to solve. Developing good fundamentals.

Post reply on HN