I mean I think that's fine, especially if that extra performance makes an impact on your ability to achieve your business goals/priorities. The takeaway I'm aiming for here isn't necessarily that declarative code is always better than imperative or vice versa, but that simple code should be deeply intentional, not just explicitly rudimentary- and that Engineers shooting for the top of the salary range should not only understand the trade-offs but should be sharing that understanding with their peers rather than relying on tribalistic hot takes for the sake of driving engagement.
To that end, I'm working on a follow-up where I dive into the difference between complex vs complicated code, and how/when to spread complexity strategically to achieve more sophisticated forms of simplicity at scale. If you're interested, let me know and I'll give you early access.
Thanks for taking the time to read my content and leave feedback!
I recently rolled off a sweet FinTech project with a Fortune 500 bank’s Emerging Technologies team which has the best ADR implementation I’ve seen thus far.
Just fyi, these ADRs, written in Markdown, are kept in separate repo with special Markdownlint rules applied to ensure consistent formatting. But what made this team’s ADR implementation stand out to me were not the technical details of how they were maintained, but rather the SOPs they’d strictly adhered to.
In essence, they had a very academic perspective on ADRs, viewing them more like a potentially publishable white-paper- not necessarily in terms of length or formality, but procedurally. The rule we followed was that a spike should lead to an ADR, which made writing an ADR much more of a build-measure-learn cycle and kept quality high, since authors weren’t scrambling to remember their entire thought process after the fact. This also greatly improved the quality of the spikes themselves, as we spent less time falling down rabbit holes. Basically, a spike became strictly a determination of either feasibility or implementation, with an explicit record of that the determination and the way in which it was made, as well as the other trade-offs considered.
I just cancelled a membership at a gym which utilises these cancellation practices. When I found out that I'd have to mail a physical letter, I called my bank instead.
If you use your credit card, you can wiggle your way out of it if you explain that these cancellation processes are absurd. Call the gym and ask if they'll cancel your membership over the phone first. After they refuse, tell your credit card company about it and ask them to try calling the gym with you on the line to get your membership cancelled. If the gym persists in its refusal you should be able to dispute and block the charge.
For me though this happened to be linked to my debit card (and I never ever put monthly billables on my debit card so I'm not sure what I was thinking when I signed up). However, because I had no other services linked to my debit card, I was able to have my bank just send me a new card and that was that.
If you have a signed contract with the gym, then just cancelling the card account may be a good way to find yourself sent to collections. Eliminating the payment method just means you are not paying them any more, it doesn't mean that you aren't accruing charges.
As annoying as these cancellation procedures are, they are almost always laid out in the up-front contract (especially for a gym, where you signed up in person). The time to object is when you sign the contract, not when you're trying to cancel.
(Not that I don't <strikethrough>hate</strikethrough> like this practice and find it shady and annoying, but wouldn't want people to wind up in deep trouble as a result).
Collections is a boogeyman. No company actively recruiting new non-distressed customers wants to have a reputation for harassing customers who fight back against pickpocketing. They'd rather let the occasional savvy customer go and continue signing up more rubes.
To that end, I'm working on a follow-up where I dive into the difference between complex vs complicated code, and how/when to spread complexity strategically to achieve more sophisticated forms of simplicity at scale. If you're interested, let me know and I'll give you early access.
Thanks for taking the time to read my content and leave feedback!