I've heard folks insist a lot of times that they get extra productivity from putting in more than 40-50 hours / week. From those who I've actually worked with, I have been able to verify that it's more of a psychological conviction than anything. You say that your 90-hour work weeks got you familiar with the codebase so that you became the person on the team who knew the most about it. But, a more experienced professional could have done it in even less time if than you, without such absurd hours.
If you have so much tech debt that you absolutely need to refactor a bunch of things, 90% of the work should be grokking the original codebase (mostly reading and comprehension), as well as redesign. Of the remaining 10% of the work, 5% of that 10% should be writing tests. The remaining 5% is slicing and dicing the old code.
If I was your manager (and I've had to talk engineers away from the ledge in similar situations before), you would likely be running this plan by me before you did it, and I would very strongly recommend you to take a different, less risky strategy to get whatever changes we needed for the client launch. If you decided against that, it's likely I would fire you for poor performance, although it's likely I wouldn't have hired you in the first place. Solid engineers don't need >50 hr workweeks to hit their deadlines, and they can sustain productivity reasonably indefinitely at healthily run organizations.
I'm relatively inexperienced, so I can't comment on the rest of your comment. There's a good chance you're right.
Beyond my own anecdote, the larger allegory I was trying to get at was: I can't think of any real way to stop someone who really wants to work long hours; and at least some of the time, those extra hours will translate into more pay, resulting in a pay gap.
Edit: I like your username! I yowl, I yowl.
"To me, the most important concept brought in by Feathers is seams. A seam is a place in the code where you can change the behaviour of your program without modifying the code itself. Building seams into your code enables separating the piece of code under test, but it also enables you to sense the behaviour of the code under test even when it is difficult or impossible to do directly (e.g. because the call makes changes in another object or subsystem, whose state is not possible to query directly from within the test method).
This knowledge allows you to notice the seeds of testability in the nastiest heap of code, and find the minimal, least disruptive, safest changes to get there. In other words, to avoid making "obvious" refactorings which have a risk of breaking the code without you noticing - because you don't yet have the unit tests to detect that.".
As you get more experience under your belt, you'll begin to see these situations again and again of code becoming large, difficult to reason about or test, and similarly having low direct business benefit for refactoring. But crucially, learning how to refactor as you go is a huge part of working effectively with legacy code and by virtue of that, maturing into a senior engineer -- to strain a leaky analogy, you don't accrue tech debt all at once, so why would it make sense to pay it off all at once? The only reason that would occur is if you didn't have a strong culture of periodically paying off tech debt as you went along.
I'm not going to insinuate that it was necessarily wrong that you decided to solve the problem as you did, and the desire to be proactive about it is certainly not something to be criticized. But it wasn't necessarily right, either. Your leadership should have prevented something like this from occurring, because in all likelihood, you wasted those extra hours and naively thought that extra hours equal extra productivity. They don't. You ought to aim for maximal results for minimal hours of work, so that you can spend as much time as you can delivering results. And, unless you're getting paid by the hour instead of salaried, you're actually getting less pay. So to recap: you're getting less pay, you're giving the company subpar results (by definition, because you're using more hours to achieve what a competent engineer could do with only 40 hour workweeks so you're 44% as efficient), and everyone's losing a little bit. Thankfully, you still managed to get the job done, and because you were able to gain authorship and ownership over the new part of the codebase, you were able to politically argue for better compensation. Good for you, you should always bargain for what you deserve. But, just because you got a more positive outcome doesn't mean you went about it the most efficient way.
The best engineers (and I would argue workers in general) are efficient. They approach every engineering problems they can with solutions so simple and effective that they seem boring, only reaching for the impressive stuff when it's really needed, and with chagrin. If you can combine that with self-advocacy, you'll really be cooking with gas as far as your career is concerned. And, it'll get you a lot further than this silly childish delusion that more hours equals more results, or more pay. Solid work, solid negotiation skills, solid marketing skills and solid communication skills earn you better pay. The rest is fluff.
[0] https://www.amazon.com/Working-Effectively-Legacy-Michael-Fe... [1] https://softwareengineering.stackexchange.com/questions/1220...
I think you make a good point; we shouldn't fight that pay reflects time/effort put in.
But I think that when we 'engineer' society, we want to make sure we make it as easy as possible for people to make the decision between work or other endeavors. There's nothing we can do to get around that women give birth and men don't, but we can at least afford them both the same generous paternity leave. And on the other hand, the more we empower women to have educated careers, the less men will feel pressured to make as much money as possible just to support their family.
People who want to complete tasks with ruthless efficiency will struggle immensely with the waste at union (and government) orgs.
Sorry for the rant, but you're question isn't worth worrying about because people that would want to work from home wouldn't be working in a union shop that barred work.
The union working rules make sense for the company. It's not sustainable to work that much. Worker burnout and churn is bad for the company. Fostering a culture that forces people to work until they drop if they want to get ahead is toxic.
If they are willing to do that once, rewriting everything using a coding pack animal, it is pathological and they WILL be willing to do it twice, regardless of whatever reassurances to the contrary they give you on a death march.
The 40 hour workweek as a standard isn't arbitrary, it's about preventing workers from creating a race to the bottom on hours worked, because that ends with anyone unwilling to be driven like a slave becoming unemployed.
Do your part and defend your right to your personal time and to go home unmolested after your workday ends.
(As for why I'd be so masochistic, I'm weird in that I actually enjoy mundane work like refactoring and rewriting abstractions. It's interesting to me.)
And though this is conjecture on my part, even if you find refactoring and rewriting interesting, if you had the 50 hours back from doing these things and were instead rewriting and refactoring your own personal projects, I suspect you'd be equally as happy and would be something like 30x as likely to get fair remunerations for your work, rather than either enjoying the pittance they're going to give you or feeling the eventual heartbreak when they realize you're demanding a lot of money and they could just hire another passionate drone to pick up where you left off.
But the point is, even if working 90 hour weeks was a stupid thing to do, for better or worse it positioned me to negotiate more pay. Not because the company somehow had a fetish for long-hour workers, but because of what I learned during those hours. Is there a real way to prevent that? If not, is part of the pay gap inevitable?
By not hiring somebody who isn't a team player? Look, I don't know you, and sometimes there's a real deadline. But on a big project, I'd rather take two guys working 35 hours a week than one guy working 70 hours a week (all other things equal).
And while most cooperations don't care about ethics, societies should. How the hell are you going to be a good parent after a 90 hour week? So we're going to rely on underpaid teachers to teach our kids everything? Hmm, I guess Adderall is the next best thing to parenting.
All in all, nobody would stop you from being so stupid, and when you end up burned out, your fault. In a country with decent labour laws though the business might end up paying your salary during sick leave. Suddenly overtime is a massive liability.
We could also make managers responsible. For example, somebody has a crash on the way home because he fell asleep at the wheel after weeks of overtime. The manager should have some blame for not managing the workload of his employers better.
Of course, this is all moot as long as there's some asshole out there who thinks he needs to one-up everybody else and put in massive amounts of unpaid extra work. Generally though teams wise up to this quickly, and code written at 2am isn't an asset - it's a liability that somebody else needs to fix. I'll bet that's how your code ended up laden with technical debt, and I'll bet the next guy who inherits it from you will curse at the technical debt, maybe rewrite it in a frantic effort - and so the cycle begins again.
It's always easy to make more money with a short-sighted view. In the long run, it's usually not worth it. But you only hear the stories about the exceptional successes, and rarely the tragedies.
Not everyone has offspring. Stop projecting your insecurities about not working overtime onto the rest of us about how people who choose to work extra with their time are a detriment to society.
Some people work well in grinds, particularly when it is pretty mindless refactoring and they have a strong grasp of the language. If this person put in the extra mile and actually delivered something that wasn't a turd, good for him/her for choosing to use the asset of time to boost the company and his/her career.
I once worked at a startup where we'd established product-market fit, and all our problems boiled down to tech debt. The codebase simply needed to be rewritten. Doing so wasn't so intellectually hard that you needed to be a genius; you just needed a decent mastery of general programming, and to be willing to put in the hours. I worked a couple 90-hour weeks to get it done in time for our largest client's launch, and became the person on our team who knew the most about our codebase. This gave me enormous leverage in salary negotiation.
How do we stop me from doing that?