Didn't you just mis-spell "Hodor!" ?

There. Fixed that for you.

From the article: "starting with a particular type of cell removed from cow necks obtained at a slaughterhouse."

There was also a mention that there's an ongoing need for animal products to produce the growth medium.

There's work going on to be animal independent, but for now this meat is also slightly murderous.

Actually, I didn't break it, I discovered where it was already broken when it was given to me.

If I'm doing my job right, I build tools that automatically identify where something is already broken. Then we can use that tool to give actionable insight to the developer about where they strayed before they've swapped their brain to a new context.

> Now if only someone could come up with a version where we could control the privacy a bit.

You have complete control over the visual privacy of your face in the presence of any CCD camera: IR emitting glasses

I think you missed the reference. If you haven't seen it before, it's hilarious.

I never suggested that it was a good idea to write crap code. I suggested that it's a good idea to have some developers focused on things that all developers need to be taking care of (e.g. a platform that supports universal tasks). In that way, you raise everyone's efficiency with a single core effort and the vast majority of the team can focus on implementing features that move the business forward.

Not to pick too nittily, but your assertion that a load balancer should just "go[es] to the most responsive server" is kind of simplistic. When I was working there, we had a failure mode where the most responsive server was one that had tripped over a subtle bug causing all subsequent requests to that instance of the service to almost immediately respond with an http 200 and empty content (it was a bug, after all, and it was compounded by this failure mode of returning a 200). Because we used weighted round-robin, we were able to diagnose that only some of the servers were behaving badly and could focus on reproducing the problem, finding the root cause and fixing it. The short-term mitigation was to bounce the ones in a bad state as they got into the bad state. This was at the cost of a poor user experience for 1/n of current traffic. In your proposed model, all traffic would have black-holed into this highly responsive server possibly making diagnosis and mitigation more difficult.

As far as having to abstract away the heavy lifting of service management into a dedicated layer, I'm in violent agreement with that architectural decision. Without providing service management as a service, you put the burden on everyone's shoulders to manage it themselves. I'd rather have 98% of the developers focused on application logic and a specialized 2% of the developers providing productivity improvements to the core platform.

While it might be more rewarding for some to re-blaze trails that have already been explored (and improvements do come out of parallel efforts) it's a much better business decision to put as much weight as possible behind moving the product forward and leave the task of lifting the efficiency of the platform to a dedicated team.

To your point, if you were 1,450 miles away in the middle of Kansas, you'd have a 7.7 millisecond ping time just for speed-of-light latency if you ran redundant fiber from your DC directly to the exchange in Manhattan. Probably add some small amount of time for the network gear on each end of the connection.

I think he was actually saying that many folks are wearing incorrectly sized leiderhosen.

The juxtaposition of these two statements struck me as somewhat incompatible from an actuarial perspective:

You shouldn't have posted this anonymously. I think it's great that you've identified the key friction present in all software development efforts: tossing the product over the wall and assuming the downstream person will fix it. Whether it's a product owner tossing incomplete requirements to a developer, a developer tossing code without unit tests or non-performant code to a tester, a tester not validating whether the code will really run in prod, or an operations person blindly deploying whatever comes down the pipe.

All of these non-communicative behaviors work together to create a sub-optimal user experience (and pissing off the people who benefit from the system you build is a self-defeating practice, since they're the ones that indirectly sign your paycheck).

Wait. Intelligent life evolved here? I haven't seen much evidence of it.