Yes. You basically have to keep eating that way and your gut flora adjust to compensate. It’s still a pretty windy diet since you rely on those gut-bugs to break down a lot of the sugars in beans.

Thanks!

I was thinking the same thing. I feel kind of bad now.

Also: this is what it would look like if Linus wrote a CPM kernel instead.

before they put coin machines on the weight systems.

WAT. I’ve never heard of this. Is that like a deposit akin to an Aldi shopping-cart, or like an arcade machine?

melting pot

To them, it’s not a melting pot. They see a caste-system of suckitude where every different group exists on the levels beneath wealthy white people. Every reaction, every lie, every diversion, it’s all in service of that one design. The funny part is: the coded speech and dogwhistles mean that they don’t exactly have enough social sway to be full-throated racists about it.

That’s kind of where my head was going. I also had a good chuckle when I imagined a bright turquoise baby-bag with “Makita” on the side. Then again, that’s exactly how you get a refrigerated compartment for milk.

I agree. To me, this is just an amusing fashion choice. If you’re gonna need the gear, so you may as well have fun with it.

Honestly, when it comes to any accessory or tool, it’s going to have an aesthetic. Who cares what that is (as long as it’s not offensive). There’s also a tendency to consider terms like ‘fashion’ to be emasculating, but that’s what this is: fashion. Plus, kiddo isn’t going to care about logos and any gender representation; the only shit they’re giving is in their pants.

Other fashion choices for diaper bags that could be explored:

• Metal (leather/pleather, spikes, denim, band patches)
• Goth (like above, but with less denim and more ankhs and crosses)
• Gamer (cosplay appropriate bags, pokemon that’s also a bag, D&D mimic on a shoulder strap)
• Sports (tons of practical and team-branded merch options here)
• Office (suit material, inoffensive beige, briefcase handles and leather)
• Handyman/tradesman (toolbag or toolbelt aesthetic, tool manufacturer branding)
• EMT/firefighter (first-aid compartment, red/white aesthetic, cheeky “diaper emergency kit” on outside)
• Outdoorsman (gore-tex, tent material, typical REI brands, lots of straps for different carry options)

Edit: not a dad. Some of these may already exist. Point being: it’s all a matter of taste.

There’s also diffusing responsibility across the organization. It’s easy to achieve unethical things, when the individual’s part of the job hardly seems “bad” at all.

Writing the tests first, or at least in tandem with your code, is the only way to fly. It’s like publishing a proof along with your code.

it sounds trite: make the tests fit the code. Yes, it’s a little more work to accomplish. The key here is that refactors of any scale become trivial to implement when you have unit-test coverage greater than 80%. This lets you extend your code with ease since that usually requires some refactor on some level.

I agree. The negativity in this forum has utility beyond providing a stupid counterpoint. It also saturates attention and screenspace in long threads of people arguing nonsense. The goal is disruption, and in a space far from corporate control like Reddit, yet somewhat under-moderated, it’s alarmingly effective. At worst, there’s an acutual playbook for this exact thing.

Major civilian disobedience and unionizing is required across the board.

The only way we get there is by getting people out of their houses, away from controlled media, and aware that they’re not alone. Without active, live, out-in-public protest, nobody will feel emboldened to take more radical action; they’ll feel like a lone actor and probably not even start. Civil action en-masse comes first.

I agree. Rather each one of those is rather substantial on its own. Plus the churn of going from framework to framework makes it less useful to compress and bundle all this stuff into fixed versions on a slower schedule (e.g. like Ubuntu packages do). I think that all contributes to bloat.

Kind of. They do center on code generation, at the end of the day. That’s where the similarities end. You can’t insert macros into your code arbitrarily, nor can you generate arbitrary text as an output. Rust macros take parsed tokens as input, and generated (valid) code as output. They must also be used as annotations or similar to function calls, depending on how they’re written. The limitations can be frustrating at times, but you also never have to deal with brain-breaking #define shenanigans either.

That said, I’ve seen some brilliant stuff. A useful pattern is to have a macro span a swath of code, where the macro adds new/additional capabilities to vanilla Rust code. For example, here’s a parser expression grammar (PEG) implemented that way: https://github.com/kevinmehall/rust-peg

You say that, but I’ve watched the JS community move from one framework and tool suite to the next quite rapidly. By my recollection, I’ve seen a wholesale change in popular tooling at least four times in the last decade. Granted, that’s not every developer’s trajectory through all this, but (IMO) that’s still a lot.

I used to struggle with this, until I realized what’s really going on. To do conventional web development, you have to download a zillion node modules so you can:

• Build one or more “transpilers” (e.g. Typescript, Sass support, JSX)
• Build linters and other SAST/DAST tooling
• Build packaging tools, to bundle, tree-shake, and minify your code
• Use shims/glue to hold all that together
• Use libraries that support the end product (e.g. React)
• Furnish multiple versions of dependencies in order for each tool to have its own (stable) graph

All this dwarfs any code you’re going to write by multiple orders of magnitude. I once had a node_modules tree that clocked in at over 1.5GB of sourcecode. What I was writing would have fit on a floppy-disk.

That said, it’s kind of insane. The problem is that there’s no binary releases, nor fully-vendored/bundled packages. The entire toolchain source, except nodejs and npm, is downloaded in its entirety, on every such project you run.

In contrast, if you made C++ or Rust developers rebuild their entire toolchain from source on every project, they’d riot. Or, they would re-invent binary releases that weekend.

My reaction as well. I was just fine living out the rest of my life, not having to see that smugshot again. But here we are.

Rust […] could use a higher level scripting language, or integrate an existing one, I guess.

One approach is to use more macros. These are still rooted in the core Rust language, so they give up none of the compile-time checks required for stability. The tradeoff is more complex debugging, as it’s tough to implement a macro without side effects and enough compile-time feedback that you’d expect from a DSL.

Another is to, as you suggest, embed something. For example, Rust has Lua bindings. One could also turn things inside out and refactor the rust program (or large portions of it) as a Python module.

I was convinced of this years ago. This was as true now as ever, with the rate of compromised, a-moral behavior being well above chance, it defies any consideration of mere coincidence. The idea of a political party not conducting background checks on candidates it endorses would be lunacy, so we’re left to conclude that they’re either a very forgiving bunch, or prefer dirtbags they can control.

Where things get interesting is that it may not work forever. Epstein thought that manufacturing dirt on the rich and powerful was enough to keep his operation going, and save his neck, all at the same time. That didn’t exactly pan out for him. This makes me wonder if such a scheme really is tenable when playing at that power level.

It’s been a hot minute, but here’s what I recall.

Take a look under /etc/systemd/system/ This is a good place to put custom system files.

You’ll want to add your new foobar.service file here, then run systemctl daemon-reload or systemctl reload foobar to make systemd load the new config file. Then you can run systemctl start foobar and so on.

The rest is up to you and the published docs for the system file itself. My recommendation is to also try to understand daemons you may already use like nginx, apache, postgresql, etc. Their configs can be found by first running systemctl status <servicename> and to look at the Loaded: line. Most of the packaged stuff is hanging out under /lib/systemd/system.

I appreciate that. And don’t count yourself as less advanced - a lot of folks would consider using a CM tool like Ansible to be pretty wizardly stuff.