We are experiencing technical difficulties.
Please try back later, we apologize for any inconvenience, thank you for your patience.
© 2025 Alight Solutions. All rights reserved.
and remote start is dead for all cars which have it.
who needs redundant systems?
@wj https://archive.ph/V7Xtg
@wm My wife gives me the same advice.
What's the definition of insanity?
Imagine you’re running a stable system (your "node") you built, but over time, you decide to outsource certain responsibilities. This means you’re no longer directly in control of all aspects of the system, yet you still bear the blame if something goes wrong. It’s like you’ve built a car, and you let someone else drive it, they crash it, and then people blame you for “bad brakes” even though it was their driving that caused the accident. The "key" here is that you knew certain failure modes from external dependencies, such as third-party services or other internal teams, metaphorically weather conditions you cannot control or roads you are forced to travel on. These dependencies were critical to your system’s stability, and you had already accounted for their potential failure. For example, if an authentication service goes down, your system might be unable to authenticate users, but this isn’t your fault. You designed your system with that in mind, expecting and handling these failure modes as part of your initial design so you can easily identify this was not your node. One day, the third-party auth service fails near the end of working day, and engineers are blocked. Instead of waiting passively for the dependency to fix the issue like told by managers, you stay late and quickly build a full end-to-end workaround, enabling developers to keep pushing forward the very next day as if nothing was wrong. This solution saves the team, ensuring progress continues smoothly despite the external failure. However, by executive (function) decision, this fix was never merged into the main codebase, it was carefully tucked “under the hood” and ultimately forgotten. Now, let’s say the manager becomes proactive and decides to distribute what you had designed and built yourself from the ground up. Later, you discover that parts of the system you built are being "refactored" without your knowledge or involvement. The manager delegating these distributed changes intentionally sidelined your input, labeling you as “protective” (in advance, proactively) of your original fully-functional end-to-end implemented and secure system, the same system you designed to be 100% stable and reliable. The manager doesn't code and while the distributed workers he delegated "refactoring" to after having the system be "reviewed" by his "friend" who knows "code" from back in "the day", may think they’re improving things, the "seniors" often don’t fully understand the end-to-end implementations or existing failure modes that you already designed around soundly. Despite you designing comprehensive system architecture documentation, incorporating security considerations into business solutions, and articulating these implementations through clear sequence diagrams and overwhelming technical writing for easy handoff of the code that was written across subsystems using 4-5 different languages in the technical stack for its entire full interoperability. The "distributed work" contributors, unfamiliar with the full end-to-end architecture and the known failure modes you had accounted for, begin making changes and their modifications break things, introducing new instability because they don’t understand how the code interacts with its dependencies or the subtle nuances of the system’s design. When things aren't going on as intended, a new tech anchor appears in the team to take care of things. This new tech anchor is the friend that "reviewed" the code in various languages they never touched, or even could understand. When issues arise, you’re still held responsible because it’s your “car”, your system. Yet you’re dealing with problems caused by hidden changes and a lack of transparency, while your original stable design and stable solutions get overlooked. The tech anchor rallies the juniors around this to delegitimize you and has everyone fooled. Meanwhile, you’re stuck trying to fix messes you didn’t create but are still held responsible because "dude, it's your car". So then you create tooling to highlight your error provocative design to diagnose and breakpoint issues from dependencies or new "distributed work" systematically so they can own this work in a way that helps them visualize flows beyond technical diagrams and they might not understand. Others then interpret this diagnostic tooling as proof that your node (system) was unstable, not that you’re just trying to surface the real issues that are either from existing out-sourced dependencies with failure modes that were already captured in the node before the easy GUI tooling made for 'non-engineer friendliness' or the new distributed work that is done to the node. The tech anchor starts releasing "versions" of your various subsystem in their respective repositories to mark themselves on a contributor for all of them despite contributing zero. The value add for the author who contributed 100% was unprotected disarray through unproductive and forced engagements while being labeled as arrogant and not a team player. Eventually the tooling built for non-technical technical experts to highlight these things decay over time and even the tooling itself becomes "redundant" for the existing team because the entire system for the product has all gone to sh-t anyway due to a held belief that new modifications being made and the pre-existing failure modes in the dependencies that were already originally anticipated to the once stable node are not the problem, the original architect, security researcher, designer, and engineer is. Eventually a cross-functional team that were competent were able to find use of this tooling that was full of working* features you individually came up with and iterated alone thanks to the comprehensiveness of reusability and general usage in mind. Meanwhile, the tech anchor plants a flag on that repo by pointlessly republishing your last version release "redundantly" so they can come up as a contributor to this new end-to-end multi-purpose, standardized, and configurable fp implementation integration and breakpointing authentication software. Ironically, after you’ve been doing systems thinking the whole time, your non-technical manager in your performance review condescendingly tells you to do it more, even though they ignored your solutions and allowed the system to be destabilized by others claiming superiority that dunked on you while forcing you to become their personal locally hosted chatbot while trying to escape from them to perform actual work through bargaining time with them and their gang vs. time alone. You decide to hold a knowledge transfer session spanning across hours due to the complexity and amount of work that was originally put into everything solo in full detail articulately, the session is recorded and now you can refer to sections in the video as a "mitigation strategy", this gives you an opening to being part of a new formed team within your team of 4 new engineers without any exposure to the product. They all have macs while you are the only one with windows, just like when the tech anchor's team originally joined too. Deja vu, but these guys seem calm and their manager that joined in seemed chill too. You now technically have two managers and are dual wielding work. The goal is to convert the entire product, which was currently in its post-MVP stage, and make it cloud-based despite the extremely unique barriers, which also necessitated full featured security implementations I made to my own part of the system originally that was the reason for complexity. Important to mention the original architecture strategy was before I joined, which was still pre-MVP. There was no anticipation or architectural strategy for the system necessitated that I built, must've been a gap... but the estimation to deliver was 3 months using 3 contractors, which I took on solo and delivered appropriately from my past experience (which was dismissed during hiring due to not having an MBA out of undergrad and was denied education opportunities and fcg program benefits to advance or better my situation, contributions did not matter as you will read) from many years before I joined the company as an employee or interned. You leave because you are being lied to by adults with official positions that warranted credibility and realize you're not going to be protected fairly either, but are convinced into staying through tag-team deception. Just long enough until you help prove and deliver a cloud migration strategy for the product cloud-based under unique challenges like a DLL requirement, using systems design and architecture from software you developed and maintained on a daily basis intimately and literally, not figuratively, 15 years ago. You're set to leave the team, sadly holding a bag of promises that were never kept. You end up staying, not by choice, they use your questioning of being misled to retain you for longer and restrict movement under pretenses of you not being a team player. The report they forged had false dates making up lies while making you look like an absolute soulless monster. You're humiliated and isolated among the team you're held hostage in. They give you a new goal. Fix the system they broke that you originally delivered fully working, which months worth of tech debt from a theatre performance of "engineering". You have enough and drop receipts you collected (which started somewhere around the time your manager called you arrogant for delivering him everything and trying to continue just that under unfortunate circumstances that weren't being resolved through "communicated boundaries"). They cover it all up. Your manager, feeling vindicated, messages you after their successful joint department effort in breaking you and isolating any sort of support, despite calling you arrogant more than half a year before for disrespecting someone "senior" to you by questioning the technical anchor's "practices" which was really just a refusal to protect you from credit theft, false promises, product sabotage which led to random character as----------n etc. leading up to this magical buildup of a whimsical question: "Hey does your software (the standalone tool, not the system) support MacOS?" Because a team member does not have an environment, which was also necessary for the product the engineering team owns and works on, like how DLL (third party black boxes) being Windows only to load. Foot on my neck
How about that AWS outage?
No Ford Pension
Amazon web services is having a huge outage.
@a1 Well, I don’t have the keys to fix this myself because I trusted someone else with them. The custodial's got them.
Did you try cold starting your wallet?