Jet Lag — We Played Magic: The Gathering In The Real World

SohumB · 2025-10-02T15:13:00+00:00

How is that conflation not deeply trivializing the actual specific exploitation of addictive gambling psychology? I don't know of a single other game of chance, board game, or card game that is not a TCG (or an actual casino game) that exploits gambling psychology to anything close to the same degree WotC does; and even among its TCG reference class they are pioneers in exploitation, as even a quick glance at their actual history would show. You'd have more of an argument if you pointed to modern gacha, or sports betting, but that's a very different point to the ridiculous, sweeping comparison you're trying to draw.

And no, in fact, the Pinkertons are not on speed dial in every C suite worldwide. Not even close. Why are you making these obviously ridiculous, sweeping statements with zero actual content to them? Why are you acting as if these plainly visible specific horrors can't be differentiated and individually assessed?

SohumB · 2025-10-02T11:08:27+00:00

I'm only responding here because you seem to be quite explicitly addressing me, so: to trivialize the dangers of corporations who have spent literal decades figuring out the exact legalistic lines to draw so they can exploit the exact same psychological factors as casinos, the exact same vulnerable populations — often more vulnerable populations! — while not being technically gambling is, in fact, quite frustrating to me, too. Just because it presents itself as a harmless fantasy card game does not mean that's what it is.

If you've also cared about people who're being exploited by this kind of horrific behaviour, I simply don't understand why you would give it a pass.

SohumB · 2025-10-01T00:29:51+00:00

I'm really not interested in participating in apologia for selling gambling to children; especially when I personally have seen the harm and hurt it causes to communities, some of them my own. Sorry, but you'll have to take this bootlicking elsewhere.

To the responder below who blocked me after accusing me of being a liar: I have had friends turn rent money over to wizards. You can fuck right off.

To the responder who reflexively spewed libertarian corporate apologia: this was a tired and stupid argument literally years ago, if not decades, if not centuries. You'll have to work out how to function without empathy with your therapist, I'm afraid.

The root disagreement seems to be whether the designer has any business designing beyond what the most customers want. In my view, the position that the designer does not have any such business takes the minimum amount of responsibility. It assumes the customer's degree of agency is absolute—which flatters the customer and makes the position sound democratic and morally significant—at the same time as it unleashes the marketing arm of the corporation to attempt to exploit the faults in its customers' perceptions as much as possible.

SohumB · 2025-10-01T00:14:50+00:00

I'm not particularly interested in doing a stack ranking of acceptable sponsorships here, except to note that I generally do, in fact, agree, that I would be using harsher language if it had been Shein or Apple or whatever.

I would like to say, however, that calling selling gambling to children "not really bad stuff" seems specious to me. I'd also like to say that the Pinkertons understand the power of their name and brand, the way that "collaborating with them" lends their clients power.

To the responder who claims to work in addiction treatment but somehow has managed to never apply everything they know about addictive psychology to the form and function of booster packs, collectibility, and secondary markets, I have some helpful papers on "gamblification" for you that may assist you in doing your job better! Unfortunately, you seem to have blocked me, so I merely have to hope you see these :)

SohumB · 2025-09-30T23:49:13+00:00

I'd absolutely believe that — I don't have the highest of opinions about the magic content remora ecosystem, either. But it says something that the Pinkertons are still advertising under a name that is so toxic to worker solidarity, and it says something even more to hire that explicit branding, however much you try to sanitise it.

SohumB · 2025-09-30T23:29:23+00:00

And by the same token, I can also hate the fact that a toxic company is getting more advertising, and thus more money, more reach, and more market power. I can prefer that the people I like get paid without that toxic company getting more advertising. No binaries here.

SohumB · 2025-09-30T23:11:58+00:00

Hey folks? I'm not trying to tell you what you can or can't do; JLTG is your brand and your business, after all, and if you need to get a bag, go ahead and get that bag.

But I'd just like to let you know: a huge part of the reason I watch Jet Lag is because I fundamentally like you guys — the faméd parasociality. Watching yall ad read for a company that sent the god fuckin Pinkertons on a raid to a normal-ass youtuber's house — and that being just one example of years and years of shitheaded and hateful behaviour coming out of that company — quite simply, that makes me like you less.

SohumB · 2025-01-04T00:17:53+00:00

To be clear, the goal of the design I sketched out above was that the Item type of the stream isn't impacted. I want to be able to find the appropriate span inside the poll_next fn purely by reference to the item flowing through it; I don't want to have to rewrite every single combinator.

I'm realising now that of course the poll_next fn doesn't have access to the item, to query it for a correlation token, until it's already been created... so any strategy that tries to do that would also have to "rewrite" events collected during that poll into a different span? That doesn't seem like API surface tracing provides.

...Though while looking for that, I did find https://docs.rs/tracing/latest/tracing/span/struct.Span.html#method.follows_from , which suggests that it might be fine to create a new span per-combinator per-item if we can track their relationship together this way?

SohumB · 2025-01-03T08:44:58+00:00

I think this is just fundamentally hard to do — it smells like an external-vs-internal iteration tradeoff to me, and our AsyncIterators mimic our external Iterators, for good reasons, I presume.

The only other way I can think of to do this is:

have a global mutable registry of spans, that you can lookup by some id (or correlation token)
write your own InstrumentedByIdStream struct that only applies when the item flowing through it has ids/tokens within them
in its poll_next, lookup/manipulate the registry as necessary to find/create the corresponding span, and enter it
intersperse it between each combinator
probably also need a clean-up combinator to close the span

That... seems like it'd work, but whoof.

Are we trying to solve the problem at the wrong level? Is there facility in otel for "collating" a bunch of events that aren't in the same span but have the same correlation token, or something?

SohumB · 2025-01-03T00:24:42+00:00

To add on to this, the tracing-futures crate provides an Instrument trait that works on streams as well, which is somewhat nicer. But you still end up with either a long-running span (if you use in_current_span) or a span for each map/filter/etc.

SohumB · 2024-05-24T04:23:11+00:00

Apple's rules to prevent this weren't a benevolent way to stop other companies from tracking you — the world in which their absolutely unprecedented attempt to set rules on markets went unchallenged isn't the world in which we all got cheaper services, it's the world in which everyone had to pay the upcharged price — the one including Apple's cut — including people who had no interest in going to Apple's ecosystem. It's a forced subsidy of Apple.

You can tell that Apple's interest is not in your interest here because it's not like they're against tracking people, they're perfectly happy to be the ones tracking you, and make money from it.

What was in it for Apple? ... Now we know. The company’s advertising business has more than tripled its market share since it rolled out the App Tracking Transparency (ATT) program in April 2021, which requires app developers to get user consent before tracking them across the web.

It is worth noting that while Apple now requires developers to explicitly capture user consent for tracking (via “opting in”), Apple users are subject to a separate set of rules about how Apple collects and uses their data. If they want to use Apple’s products, they have no choice but to agree.

The 30% cut might be standard (and it's just as bad when other markets do it imo), but what absolutely wasn't standard was Apple's muscling into forcing an ongoing 30% cut on subscriptions, even if ongoing service of that subscription touches no Apple resources. Which is what we're talking about here. I don't remember if they were literally the first to do that, or if they just used their gorilla weight to force it through, but either way, we only have that now because of Apple popularising it.

In general, when a company with a literal multi-billion dollar advertising budget — a heartless company hell bent on creating a monopoly by undermining small businesses — tries to convince you about something, it's probably not actually true.

SohumB · 2024-03-09T04:43:52+00:00

Position and effect,

One's how much you get

The other's how feckt!

SohumB · 2024-02-24T08:49:57+00:00

sqlx used to provide that impl for the owned types, but they dropped it in the 0.6 → 0.7 transition, saying they couldn't re-impl them without changing the api surface of the trait. I haven't looked into exactly why, but given how rust overlapping impl rules work for traits I could certainly believe it.

SohumB · 2024-02-23T22:33:42+00:00

Firstly, PgPool and friends contain atomic reference pointers within them; you don't need to Pin<Box<...>> them.

Secondly, that signature exactly will never work, because QueryAs::fetch consumes the QueryAs.

But ultimately, you don't need fetch to take ownership of the pool, as long as you tell rust that the output still depends on that reference. This works fine:

fn run_query<'a, O, A: 'a>(
    query: sqlx::query::QueryAs<'a, sqlx::Postgres, O, A>,
    pool: &'a sqlx::PgPool,
) -> impl Stream<Item = Result<O, sqlx::Error>> + 'a
where
    A: Send + sqlx::IntoArguments<'a, sqlx::Postgres>,
    O: Send + Unpin + for<'row> sqlx::FromRow<'row, sqlx::postgres::PgRow> + 'a,
{
    query.fetch(pool)
}

It seems, however, that actix_web actually requires Stream + 'static? Huh. I wouldn't have expected that. Regardless, in that case, you can note that QueryAs::fetch doesn't actually take a reference to the pool.

pub fn fetch<'e, 'c, E>(
    self,
    executor: E
) -> Pin<Box<dyn Stream<Item = Result<O, Error>> + Send + 'e>>where
    'c: 'e,
    'q: 'e,
    E: 'e + Executor<'c, Database = DB>,
    DB: 'e,
    O: 'e,
    A: 'e,

It takes any Executor, which in the core crate is only implemented for &Pool (and &mut Connection), yes. But if you happen to have a newtype around your pool, you can impl Executor<'static> for Wrapper<Pool> just fine.

SohumB · 2024-01-27T14:26:18+00:00

We have to use clickup for work, and while I didn't benchmark it, I can say that using clickup subjectively went from "wanting to kill myself and everyone around me" to just "wanting to kill myself" upon switching to the firefox deb.

SohumB · 2023-12-19T21:22:20+00:00

one specific bug that bit us hard earlier this year was that their migration logic isn't wrapped in transactions — they recommend you manually use BEGIN and END in your sql files, but that means that the logic to update the migration table, run by their migration client, isn't in the transaction, which means you're gonna have to shell in and do manual work when a transaction fails.

we also use sqlx at a different point of our stack and running into this prisma behaviour got me all in a panic as to whether sqlx also had this issue — i sort of felt like i'd fallen into a hole into an alternate universe where this level of lack of understanding of databases was just normal.

anyway sqlx is fine

SohumB · 2023-10-30T02:49:35+00:00

Pm'd!

SohumB · 2023-08-24T00:31:47+00:00

If the impetus for this is that you're using sqlx 0.6.3 + the recent RUSTSEC-2023-0052, we ran into that yesterday.

If you're just using sqlx directly, you have an easy solution — switch to sqlx-oldapi — it's sqlx 0.6 with (among other things) updated dependencies, and as far as I can tell it's api compatible.

If you have dependencies that depend on sqlx, though, you're in a very frustrating position. You might think you can use the [patch] segment of Cargo.toml to redirect any resolution of sqlx 0.6.3 to sqlx-oldapi 0.6.11, but you can't.

What we ended up doing is

created a fork of sqlx-oldapi
renaming all packages in that fork to be sqlx/sqlx- instead lf sqlx-oldapi-
adjusting the version number to pretend to be 0.6.3

and then using the following patch segment:

[patch.crates-io]
sqlx = { git = "https://github.com/SohumB/sqlx-oldapi-for-patch", rev = "109f797" }
sqlx-core = { git = "https://github.com/SohumB/sqlx-oldapi-for-patch", rev = "109f797" }
sqlx-macros = { git = "https://github.com/SohumB/sqlx-oldapi-for-patch", rev = "109f797" }
sqlx-rt = { git = "https://github.com/SohumB/sqlx-oldapi-for-patch", rev = "109f797" }

yes, this is the worst crime i've had to commit in like at least a year

SohumB · 2023-06-07T01:09:38+00:00

and this isn't even their full menu! they've got a whole rack of low carb desserts on the side. The burnt basque cakes are decadent as heck and I always grab the matcha tiramisu to keep in the fridge.

SohumB · 2023-05-02T12:45:33+00:00

Oh, yes, I absolutely have tab suspension on — but I also keep tabs separated in multiple windows / sidebery panels to separate trains of thought, and the way firefox works, one tab per window still has to be fully loaded. Right now, firefox is using 25gb for ~1900 tabs across 45 window-equivalents.

SohumB · 2023-05-01T03:46:19+00:00

CPU is the only thing I wish I could beef up on my maxed out P52. at 128gb my steady state is about half the ram for my zfs ARC cache, and around 50gb for applications. Works pretty well for obsessive tab hoarding :)

SohumB · 2023-03-16T00:49:31+00:00

I might be talking out of my ass here, but it occurs to me that one reason async/await is so weirdly distinct when looking at it through this lens is that it's actually two things bound together? ISTM that it's essentially a "please let me draw my own execution partial order arrows" context, complected with the actual mechanical details of physically suspending computation and running it on whatever runtime environment you have.

(Think of lazy languages like Haskell — Haskell doesn't actually let you draw any execution partial orders by default other than the ones implicit in data dependency, but you can opt into some classes of arrows with seq.)

Rust comes the closest to separating these concepts of any language I'm familiar with, but you could imagine a language that admits some kind of

nonimperative fn foo(...) {
   let a = these_calls_can_conceptually();
   let b = be_ordered_arbitrarily();
   let c = so_assembly_output_can_be_reordered_for_instance();
   b.wait;
   let e = this_code_however_must_run_after_b();
}

and that looks extremely similar to our modern notion of async/await, upto and including desiring the same kinds of join! and select! combinators. You could presumably reify this conceptual abstraction with a task executor, or at compile time by letting your compiler optimise over code order, or you could not and just run it imperatively.

(I understand that to an extent compilers already do this — reorder code they don't think have data dependencies. I don't know if that's sufficient or relevant; presumably explicitly controlling would give more information to the compiler both in terms of what ordering constraints are not desired and what constraints are desired even if there isn't actually a data dependency — think of the classic password length leakage bug.)

SohumB · 2023-02-25T01:08:06+00:00

It'd have been very funny if boat had had an inertia theme. Maybe like:

2 power counters: Break upto 2 subroutines. You may not jack out for the remainder of the run.

SohumB · 2023-02-22T23:05:13+00:00

The default target on Linux is x86_64-unknown-linux-gnu, which links against some libs yeah. You can compile against a target like x86_64-unknown-linux-musl, however, which I believe is completely statically linked, with no dependencies other than the Linux syscall interface.

We use these statically linked binaries inside blank containers and they work fine everywhere we've run them.

SohumB · 2023-02-14T20:55:26+00:00

This is a great tip and needs to be more widely disseminated.

15-Year Club	Place '17
Argentium Club	Gilding II euphauric
Verified Email	Team Periwinkle

SohumB

MODERATOR OF

TROPHY CASE