that’s a git problem, not Windows.

I use Git, and I don’t use Windows. I have no problems. Sounds like… a Windows problem?

You are never guaranteed to be able to do anything during a crash. You are better off handling these kinds of edge cases in a recovery phase during the start of your app.

Allusion to Animal Farm, which is relevant to the discussion about class warfare.

This type of shit makes me aware that there really are devs that don’t care about efficiency and will spend weeks on some really novice shit because their tools and skills are bad.

Cool so this article calls out various types of coupling and offers no strategies for managing it.

Waste of time.

I don’t really like the “as intended” take because it fails Hanlon’s Razor. Even Karl Marx understood that Capitalism is doomed to a crisis and revolution cycle, not because that’s what anyone wants, but because it is a law of nature.

The same is true of first-past-the-post voting.

The resolve to tear it down is still plausible though. I don’t know whether it is possible to escape capitalism without a revolution. The alternative is a perfect storm of progressive legislation that seems unlikely to occur in my lifetime.

I’ll move my foot to its dedicated spot in your ass.

• Red Foreman

Agreed.

And sometimes code is not the right medium for communicating domain knowledge. For example, if you are writing code the does some geometric calculations, with lot of trigonometry, etc. Even with clear variable names, it can be hard to decipher without a generous comment or splitting it up into functions with verbose names. Sometimes you really just want a picture of what’s happening, in SVG format, embedded into the function documentation HTML.

One thing I like a lot about Rust is that it rarely does blow my mind.

But one crate that actually did blow my mind is corosensei. It’s not Rust per se that is so crazy here, but the way it’s essentially implementing a new language feature with assembly code. This is how you know Rust really is a systems programming language. I invite you to read the source code.

Clippy will warn you if you don’t use this feature.

There are plenty of good resources online. Here are some topics you probably wouldn’t see in an intro algos course (which I’ve actually used in my career). And I highly recommend finding the motivation for each of these in application rather than just learning them abstractly.

• bloom filter
• btree
• b+ tree
• consensus algos (PAXOS, RAFT, VSR, etc)
• error correction codes (Hamming, Reed Solomon, etc)
• garbage collection (mark+sweep, generational, etc)
• generational arena allocator
• lease (i.e. distributed lock)
• log-structured merge trees
• min-cost + max-flow
• request caching and coalescing
• reservoir sampling
• spatial partition (BVH, kd-tree, etc)
• trie
• write-ahead log

Sir, I estimate the project will be completed in 135 days and 11 hours.

Not exactly. I’m talking specifically about being able to call axum::serve with non-Send futures.

I’m not sure what tokio (or axum) can do to avoid the trait bounds. Would it makes sense to provide a “share nothing” runtime implementation that can be injected at startup? I wonder how the intermediate layers (e.g. axum) would indicate that futures are usable by a more generic runtime which may or may not need Send + 'static.

Are sockets not files?

Objects may have a single trailing comma.

I just came.

Large ISPs still don’t support it. It’s a fucking travesty.

I think there’s a pretty big overlap of gamers and programmers who use Windows or WSL because they don’t want to have to dual boot.

It’s definitely faster. I have seen measurements from many people showing that Windows is slower compiling Bevy on the same hardware.

Yea I agree. Good UX is a lot of work, and I think FOSS projects rarely prioritize it. Even good documentation is hard to come by. When you write software for your own use case, it’s easy to cut UX corners, because you don’t need your hand held.

And good UX for a programmer might be completely different from good UX for someone that only knows how to use GUIs. E.g. NixOS has amazing UX for programmers, but the code-illiterate would be completely lost.

I believe that the solution is “progressive disclosure”, and it requires a lot of effort. You basically need every interface to have both the “handholding GUI” and the underlying “poweruser config,” and there needs to be a seamless transition between the two.

I actually think we could have an amazing Linux distro for both “normies” and powerusers if this type of UX were the primary focus of developers.