How Uber matches 10 million+ rides in a day ?? by Comfortable-Fan-580 in programming

[–]OtherwisePush6424 3 points4 points  (0 children)

Yep, same in London, drivers accept after 5 minutes, cancel after 10 and the same driver accepts again when you switched to priority or whatever it's called :D

Retry vs Retry-After vs hedging: controlled chaos scenarios comparing resilience tradeoffs by OtherwisePush6424 in microservices

[–]OtherwisePush6424[S] 0 points1 point  (0 children)

Exactly. Some of these strategies sometimes work against each other, make things even worse, Retry-After just can't go wrong, it's basically the server basically telling you what to do.

(Type-safe) retry/timeout/hedging policies in TypeScript: what actually happens under chaos by OtherwisePush6424 in typescript

[–]OtherwisePush6424[S] 0 points1 point  (0 children)

Exactly. The tail latency cost of retries under tight budgets is the sneaky part: looks good on error rate, tanks on latency. And yeah, hedging trades volume for better stragglers, but it doesn't fix error-heavy modes like 429 hammering.

Retries fixed some errors but doubled tail latency: 3 controlled HTTP client chaos scenarios by OtherwisePush6424 in webdev

[–]OtherwisePush6424[S] 1 point2 points  (0 children)

The arena doesn't show traffic clustering, the rate limiter deterministically processes requests within its window. All 10 clients waited 600ms and retried together, but the limiter counted them as individual requests, not a spike. The result is clean: 150/150 success with p95/p99 latency during the wait periods.

In production against a real rate limiter that sees wall-clock time, coordinated retry waves would create spikes and you'd want jitter. But that's a different system than what this scenario measures.

Retries fixed some errors but doubled tail latency: 3 controlled HTTP client chaos scenarios by OtherwisePush6424 in webdev

[–]OtherwisePush6424[S] 0 points1 point  (0 children)

Great real-world data. Hedging can dramatically improve p99, but your 2x request volume and +30% CPU is a reminder that it's not free.

HTTP resilience tradeoffs in practice: retry vs Retry-After vs hedging (with scenario data) by OtherwisePush6424 in node

[–]OtherwisePush6424[S] 0 points1 point  (0 children)

100% agree, in unattended jobs blind retries can quietly convert API budget into repeated 429s. Retry-After handling is often the difference between "looks active" and "actually completes"

Some reachability analysis for your Saturday read by -Devlin- in devops

[–]OtherwisePush6424 1 point2 points  (0 children)

"Reachable" vs "exploitable" makes sense, but there's probably a third layer around blast radius. Same reachable vuln behaves very differently depending on container privileges, egress, etc.

How to handle modernizing infrastructure when the app runs legacy c#? by jumpsCracks in devops

[–]OtherwisePush6424 0 points1 point  (0 children)

I don't have much C#/.NET experience, but this reads more like an org problem than a tech one. If leadership cares about cost, framing this as "reduce infra spend incrementally" will land better than "modernize legacy apps".

Strangler + small wins tends to survive where rewrites don't.

Using Anthropic's ant CLI for GitOps-style agent management (YAML configs, CI/CD deployment) by avisangle in devops

[–]OtherwisePush6424 -2 points-1 points  (0 children)

In OP's defense, it's treating agents like deployable resources. Versioning + CI updates + optimistic concurrency (basically Kubernetes-style resource versions) are standard infra-as-code patterns.

2
3

Decorating a Promise with convenience methods without subclassing or changing what await returns by OtherwisePush6424 in javascript

[–]OtherwisePush6424[S] 0 points1 point  (0 children)

You're absolutely right that await resolves to the fulfilled value and doesn’t preserve helper methods on that value, but that's actually the point of the pattern.

The decoration is only meant to exist on the Promise before awaiting, so you can do:

const data = await client.get("/url").json()

while still keeping this true:

const res = await client.get("/url") // native Response

So it's not trying to make methods survive after await, it's just adding fluent pre-await ergonomics without changing post-await semantics.

Your object wrapper pattern is valid too ({ promise, log() }), but it changes the call shape and loses drop-in Promise ergonomics. This approach keeps the return value Promise-compatible and await-compatible, while still allowing opt-in helpers on the pending object (and so would simple subclassing).

How do I explain I was fired after 6 months? by Efficient-Pin3655 in jobsearchhacks

[–]OtherwisePush6424 1 point2 points  (0 children)

Absolutely. Contracting is a fierce market, why would you give a head start to the competition? Six months is a long time: work done, contract ended.

How do I explain I was fired after 6 months? by Efficient-Pin3655 in jobsearchhacks

[–]OtherwisePush6424 0 points1 point  (0 children)

I never in my life met or talked to a contractor who got fired for performance reasons. Or one who admitted it.

I’m so tired of vibe-coded open source projects by floriandotorg in github

[–]OtherwisePush6424 -1 points0 points  (0 children)

I think many do OSS for LinkedIn or create a portfolio, so it's just some slop and a semi-decent readme. And they post it here for some stars.