sa46

Railway has an overwhelming incentive to pin the blame on Google. This report doesn't answer why Google suspended Railway's account.

I'd wait for more details before adjudicating.

Presumably, OP refers to the generated rust types which depend on the specific protobuf framework.

I had the same issue when looking to adopt ConnectRPC for Go, which uses a custom wrapper type to model requests.

It might interest you to know JS has real private fields, formally introduced in ES2022. [1]

[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

A new Go protobuf parser [1] made the rounds here eight months ago [2] with a specialized VM that outperforms the default generated protobuf code by 3x.

[1] https://mcyoung.xyz/2025/07/16/hyperpb/

[2] https://news.ycombinator.com/item?id=44591605

About 15 years ago, our brigade conducted a training exercise to test overall readiness. The opposing force (OPFOR) figured out how to triangulate the brigade headquarters' position using Tinder.

Tinder provided 1-mile granularity, so OPFOR would roam around until they had enough points to locate the headquarters. Then, they'd artillery it out of existence. The brigade commander was most displeased—moving a brigade headquarters is not for the weak or fainthearted.

govulncheck analyzes symbol usage and only warns if your code reaches the affected symbol(s).

I’m not sure about cargo audit specifically, but most other security advisories are package scoped and will warn if your code transitively references the package, regardless of which symbols your code uses.

The problem is that pre-commit hooks are much slower with a much higher false-positive rate than type checking.

Pre-commit checks should be opt-in with CI as the gate. It's useful to be able to commit code in a failing state.

Wouldn’t a mono space font provide more information since you can extrapolate the exact number of characters?

I’ve been very happy with Pganalyze.

Advisory locks aren’t all sunshine and rainbows. They can only be unlocked by the Postgres connection that acquired the lock. That means you need to track the connection, typically by dedicating a connection to the job that needs locking.

Here’s a good issue describing the tradeoffs between a lock table and advisory locks.

https://github.com/bensheldon/good_job/discussions/831

That's quite a strong claim. I disagree. Military leadership, like business leadership, is imperfect. Both vary based on individuals, the operating environment, and culture.

Depends on the state and child age. California is on the stricter end of legally mandated ratios:

0-18 months: 1:3

18 months to 3 years: 1:4

3-5 years: 1:5

Trickle-down titles? I’m familiar with operator to refer to tier-1 special operations personnel like Seal Team 6 and Delta Force.

Sold if you provide a rock or something.

Weight loss in Ranger School is additionally “aided” by limiting students to 2 MREs per patrol day (2400 calories) to increase stress.

Anecdotally, I lost 26 lbs in Ranger School.

Why not use the standard-library adjacent semaphore package?

One problem with using a channel as a semaphore is you need to track if you've closed the channel when "releasing".

https://pkg.go.dev/golang.org/x/sync/semaphore#Weighted.Acqu...

None of those situations imply the business was poorly run.

Think about it, if a business is fairly priced and well run, PE firms have no incentive to buy it because where do they generate returns?

PE has access to business models unavailable to the original owner.

- Buy all local dentist clinics at an enticing markup then increase rates.

- Buy businesses and migrate them to tech where the PE firm holds an advantage. For example, a PE firm that runs its own payment gateway.

- Buy a business that complements a larger business to reduce churn or increase sales.

Go is certainly capable of async programming. https://en.wikipedia.org/wiki/Asynchrony_(computer_programmi...

The goroutines run in parallel. Also, don't use complicated words when simple words will do.

That’s not called for, especially since you’re wrong.

The arena experiment is on indefinite hold:

Note, 2023-01-17. This proposal is on hold indefinitely due to serious API concerns.

https://github.com/golang/go/issues/51317

Potential successor: https://github.com/golang/go/discussions/70257

Page Object Models trade off clarity for encapsulation [and] obscure what's actually happening.

This argument also applies to using a function for abstraction.

I've just written a few dozen e2e tests with Playwright. The code looks like:

    await invoiceDetailPage.selectCustomer(page, 'Acme');
    await invoiceDetailPage.selectCustomerPoNumber(page, '1234567890');
    await invoiceDetailPage.setCustomerReleaseNumber(page, '987654321');
    ...10-15 more lines

Isn't gettimeofday implemented with vDSO to avoid kernel context switching (and therefore, most of the overhead)?

My understanding is that using tsc directly is tricky. The rate might not be constant, and the rate differs across cores. [1]

[1] https://www.pingcap.com/blog/how-we-trace-a-kv-database-with...

Veterans is just another word for retired military personnel.

A sergeant who leaves after a three-year enlistment is a veteran, but not a retiree.

The distinction matters because military retirees retain some privileges from their service, most importantly, a pension. Those privileges mean retirees fall under the emoluments clause.

However, a veteran not receiving retired pay is not subject to the emoluments clause as they have no relationship with the federal government. The Congressional Research Service states:

Former servicemembers with no military status and not entitled to military retired pay can perform [foreign military service] on the same basis as a U.S. national who never served in the armed services. [1]

Interestingly, this implies a retiree could forfeit their retired pay to avoid being subject to the emoluments clause.

[1] https://www.congress.gov/crs-product/IF12068

US veterans have to seek permission

Retired military personnel, not all veterans.

This uses global state under the hood.

Looks safe to me. It uses `crypto/rand.Read` which is declared as safe for concurrent use. The cache is accessed via sync.Pool which is thread safe. As a check, I ran the tests with `-race` and it passed.

It might be. I've seen the trick pop up a few times:

1. https://puzpuzpuz.dev/thread-local-state-in-go-huh

2. https://victoriametrics.com/blog/go-sync-pool/

It's probably too complex for the Otel SDK, but I might give it a spin in my experimental tracing repo.

Funny timing—I tried optimizing the Otel Go SDK a few weeks ago (https://github.com/open-telemetry/opentelemetry-go/issues/67...).

I suspect you could make the tracing SDK 2x faster with some cleverness. The main tricks are:

- Use a faster time.Now(). Go does a fair bit of work to convert to the Go epoch.

- Use atomics instead of a mutex. I sent a PR, but the reviewer caught correctness issues. Atomics are subtle and tricky.

- Directly marshal protos instead of reflection with a hand-rolled library or with https://github.com/VictoriaMetrics/easyproto.

The gold standard is how TiDB implemented tracing (https://www.pingcap.com/blog/how-we-trace-a-kv-database-with...). Since Go purposefully (and reasonably) doesn't currently provide a comparable abstraction for thread-local storage, we can't implement similar tricks like special-casing when a trace is modified on a single thread.

Other fun fact, Army Rangers trace their lineage to Rogers’ Rangers. Rogers fought for the crown in the Revolutionary War.

https://en.m.wikipedia.org/wiki/Rogers'_Rangers

The convenience of writing `?` means nobody will bother wrapping errors anymore.

A thread from two days ago bemoans this point:

https://news.ycombinator.com/item?id=44149809

“Simply declaring” is inaccurate description of the Go team’s decision. The team built several proposals, reviewed dozens more, and refined the process by gathering user feedback in multiple channels.

The Go team thoroughly explored the design space for seven years and did not find community consensus.