Why are people paying so much attention to Apple charging high commission in their AppStore when Android is taking the same 30% cut?

Back in my days, it was normal to just use an installed application, or a website, or an early mobile app. And pay no commission at all.

I mean, it's installing the .apk in the case of Android, right? So the justification for the fee is just that the app is not fraudulent, and the payment is secure.

Apple can officially be jerks. A good take from a friend of mine is that Apple most definitely are jerks, but they are the best jerks on the planet! So, Apple can justify their fees by the "elite"-ness of the app being present in The App Store.

But Android? With all the competing devices and manufacturers and companies and smaller "app store"-s? With literally the entire capitalistic machine on the planet seemingly working in favor of the customer?

Consider a thought experiment.

In some reasonable country — let's take South Korea as a model example — the following policy is introduced. A particular Android phone-producing and OS-tweaking manufacturer is designated to be a country-level "flag carrier" of the Android ecosystem worldwide.

To accomplish this, our model company — say, Samsung — features not only their own Android phones, but also their own Android store.

This Android store ensures high quality of apps — top-notch reviewing practices and so on — but the payment fees policy of this store feature a regressive scheme. Say, 30% from the first $100, 20% from the next $1,000, 10% from the next $10,000. The justification is straightforward: We put our customers first, and it does not cost more than a few thousand dollars to review the app.

Then this company makes their Apps Store — with all its vetting guarantees — available on all Android phones. As in: the user would have to root their device, sure. But the model Epic Games will release their game for Android in this model Samsung Apps Store and in no other store, unless that other store offers comparable terms.

And our model country — South Korea, in this case — will offer discounted flights to literally "buy the right phone, at a discount, for individual use". Who's going to stop that? In fact, fly Korean Air anywhere in the world, and get that phone in their Duty Free store onboard.

Sure thing, it's an all out "trade war". But it's a real, market-driven, "properly capitalistic" trade war. It's a war that forces monopolies and oligopolies to go out and fight on a level field. It's a trade war where the better player takes it all. It's a trade war that exposes the double standards in today's world economy. It's a trade war where the customer wins.

And exposing these double standards would lead the The Customer — who is presumably the king on The Market, in the long run — seeing it full well how much better their life can be.

IIRC it was Scott Adams who coined the term Confusopoly. Well, I, for one, am very much looking forward to the world where corporate managers know for a fact that The Market will punish them hard if they attempt to create a new confusopoly out of thin air. Instead, "serve your customers better, stupid".

So why are people paying so much attention to Apple charging high commission in their AppStore when Android is taking the same 30% cut?

There’s a deep wisdom in that real estate developers and software developers are called the same.

In both cases getting approvals takes far longer than building.

In both cases good contractors are expensive but not insanely expensive.

In both cases those who streamline approvals some way get paid way more.

In both cases combining the two capabilities — how to get all the approvals quickly and how to keep a strong team of builders nearby to quickly materialize what was agreed upon — is a superpower.

In both cases before you understand it you wonder why is it so slow. After you understand it you wonder how does anything get built at all.

I recall saying just a few days ago that it's highly unlikely that such a tax cut will be introduced ...

... watching very closely!

Check for yourself until it's deleted (since it may well will get deleted).

https://github.com/dotnet/runtime/pull/115762#issuecomment-2898524072

This is a deep enough link to start enjoying.

TL;DR: Microsoft decided to experiment with AIs making pull requests live, with the entire world to see how this unfolds. The results are ... predictable, to say the least.

One uncomfortable thought that terrifies me lately is that in the day and age of AI-assisted coding the concept of System Design will change again.

Hear me out.

SysDesign used to be about patterns. When the "bad OOP" [1] era was in full bloom, a "good" "system designer" effectively was the person who can tell you where and how to use a SQL database and how to [not] use the visitor and the observer patterns.

Throw in some knowledge of how to separate the read path from the write path, and how to invalidate caches, and one is a decent engineer SysDesign-wise as of ~2015. If the candidate can clearly articulate how strong consistency is different from eventual consistency, and which cloud primitives are best at replacing which self-hosted solutions, they truly are on top of their game.

As the "bad OOP" [1] era started its decline, by ~2020, we had a period of renaissance for System Design. People started talking about causality, vector clocks, logical sharding, read-your-own-writes, consistency, message queues vs. message buses, idempotency and fencing tokens.

I remember in ~2022 you could base an interview on offering the candidate to explain how they understand the CAP theorem after they brought it up in the context of consistency models. For a well-articulating candidate, asking how the Bitcoin protocol maps to these "C, "A", and "P" letters was almost guaranteed to result in an insightful conversation, with tons of signal to extract from follow-up questions.

Now we are entering the post-OOP era, which is great. Rust, for example, specifically makes the claim that we do not need inheritance and what not for the language to be powerful and easy to use. Fantastic. Unfortunately, humankind entering the post-OOP era coincided with, well, Cursor.

So we are at this weird spot where on the one hand it still is seemingly important to understand SysDesign fundamentals. On the other hand, an increasing share of code is being written with or by the AI assistant.

All in all, using tools to boost productivity is great. On the flip side, AI-assisted coding makes it far too easy for an inexperienced developer to make expensive mistakes reliability- and consistency-wise when it comes to making changes to a complex system with many moving parts.

Naturally, on this journey towards conquering complexity, we're back to square one: SysDesign is about making sure the candidate is less likely to use the AI in a way that introduces an expensive-to-debug error.

Which, in my book, is even worse than when a SysDesign interview is about "tell me about the pros and cons of the visitor pattern".
Because instead of designing systems thoughtfully we're inevitably teaching less senior engineers how to speed-run this game of "shipping something". The end result, predictably, will be far more legacy code that no one dares to touch.

Only this time the people who wrote the code did not just leave. They never existed in the first place. It was LLMs all the way down.

[1]

By "bad OOP" I mean the encapsulation / inheritance / polymorphism, public / protected / private, class / interface / virtual methods, visitor / observer, and singleton / factory.

I firmly believe this was a major detour which has hurt the software engineering ecosystem badly.

Ultimately, we had to re-learn the good parts of OOP, when it comes to objects and messages they asynchronously pass to each other, where the true challenge is to figure out a) what should be parallel and where contention should be introduced on purpose, and b) how to make a single-node object-oriented system distributed.

But that's a different conversation.

Just saw this live.

Not sure if it’s quality trolling or a sincere protest.

On the other side of the road the signs are more standard, send Musk to Mars, We The People, Due Process, all the standard shenanigans.

Could some kind soul that happens to live in a nice human body whose brain knows Rust help me?

So this + use<...> thing. Described here: https://rust-lang.github.io/rfcs/3617-precise-capturing.html

I struggle to wrap my mind around the idea of capturing types. Lifetimes — sure, makes sense. Instances — sure, makes sense. With the trait a.k.a. -> impl ... return type, w/o any Box-ing — sure, makes sense. So that the compiler knows how to instantiate ... err, monomorphize that particular type-defined instance of my `fn — sure.

But why would the code read -> impl ... + use<T>?

I mean, this T could be the type of more than one argument, to begin with. And these arguments ("parameters" in this Rust terminology) could have different lifetimes. So capturing + use<T> just makes ... no sense to me.

Not-too-arrogant and moderately condescending explanations are more than welcome. Thanks in advance!

Holy war time.

Personally, I am moderately against early `return`-s in code, including `break`-s and `continue`-s. I prefer my code to read linearly.

So, for instance:

// I tend to replace this:
if a == 0 {
  continue;
}
// ... use `a` ...

// By this:
if a > 0 {
  // ... use `a` ...
}

And similarly:

// I tend to replace this:
let SomeSumType::DesiredCase(x) = x else {
  continue;
}
// ... use `x` ...

// By this:
if let SomeSumType::DesiredCase(x) = x {
  // ... use `x` ...
}

A major counter-argument is that the code may well get more "horizontal" this way.

Well, yes. But my brain is permanently damaged by certain events, among which are the high school / university dude who made us all bold on structural programming [*], and the Google C++ Style Guide.

So my rule of thumb consists of three heuristics:

1) The code that has some indentation to the right is easier to read than "just" linear code,

2) If the indentation is too large, branch out a function, with a clear name and clear purpose, and

3) Use a reasonable maximum line length (120 is okay), and, drum rolls, two spaces indent.

I would guess (1) and (2) are a matter of style that can be tolerated by most people one way or another.

But the latter part of (3), about two spaces instead of four and instead of tabs, is what might drive people nuts.

So, seriously. Is it totally insane to use two spaces indent and "endorse" some three levels of indentation in a single logical code block? As in, do you think it's worth it for me to force-change my habits?

Or are two spaces okay, and/or are the screens wide enough these days for ~150 characters lines instead of ~120 characters, so that a few levels of indentation are no big deal?

Thanks in advance and enlighten me pls.

PS: It goes without saying that on someone else's project I follow the existing coding convention. This is about my pet projects and/or about projects where I am present "at inception".

PPS: No, I do not think goto is inherently bad. We just happened to converge to high-level programming languages where other constructs are admittedly more readable, and they optimize just fine in the vast majority of cases down the path to machine code.

Back when I learned the US work visa application process from the employer side quite literally includes posting job ads in a newspaper (!) to prove (!!) that no qualified American citizen or permanent resident is interested (!!!) In that position, I was quite shocked.

The minor shock was that apparently this comes with an added benefit of companies that are petitioning for H1B-s must publish salary ranges. So that there physically exists some dark corner in some office building where current employees can go and look at all those postings. Sometimes people would find out that some prospective new hire at a lower level than they are is being offered a higher base pay. Glitches happen.

The major shock was that this is a huge vulnerability in the entire system. Do not do this, I repeat, DO NOT DO THIS, but one can literally f*ck a big company over and across by simply monitoring the newspapers for respective ads and paying qualified US-based candidates to apply. Voila: the company must either reject this candidate (and be willing to defend the case in court), or concede there does indeed exist a US-based candidate, so that their entire legal justification to hire from abroad falls apart.

For the record, my take since forever was and remains to abolish lottery-based immigration and go all-in on merit-based. Lower the "talent" threshold on the "talent visa" to accept ~10x more people, let them enter the country and roam freely, as in, change jobs, found companies, etc., and we'd be golden.

That was back in ~2010. Now, in 2025, I am experiencing similar concerns. With AI-generated candidates.

Remember the lovely idea of AI-generated "crawler wormholes", so that the Web crawler that does not respect robots.txt gets stuck forever in random pages that do not exist?

Imagine how vicious it would be to flood a company you do not like with fake candidates?

Gen AI is most definitely good enough for resumes. In-browser agents should be able to click "Apply" automagically. Cover letters are no big deal.

What's left is passing the initial screening. And I most definitely believe we are right at the point where an AI-generated totally fake persona can answer questions about their past experience, including all the STAR bulls**t questions.

What's next?

Do we build counter-tech to handle this?

Do we get back to in-person interviews only, where referrals matter as much as they should and more?

Do we have some blockchain-based solutions so that someone's claim that "they worked at X" is expensive to fake and trivial to audit?

Or do we, as usual, pretend that the problem does not exist, and wait until it truly does bite us in the a** when it's far too late? Because what do you do if you suddenly realize 99% of your recruiters' bandwidth and ~75% of your interviewer bandwidth is wasted on candidates who have no intention to join your company? The latter, tech conversations with interviewers, may well happen with real humans on the other, "dark" side.

The "dark side" of tech interviewing would be that there are indeed good engineers who get to the final stages of your interviews. They will all be covered in makeup, and their goal would be to practice your questions and to practice negotiating with you.

Part of me is extremely excited. Since the entire "the interview is entirely confidential" state of the art is what's playing against the industry, in my book. Personally, I would much prefer another extreme — extend some levels.fyi and layoffs.fyi and Blind all the way to individual interviewers being rated by the community, with perfect notes on what they asked whom and when, etc.

Obviously, it'd be a terrible state of the art. But it would be far less terrible to my taste compared to what we have today, where "you're not from a top school, you're out" and other explicitly anti-meritocratic practices.

Time will tell. Maybe there is fun in this AI hype, after all. But the Jing Yang character from Silicon Valley comes to my mind far too often these days.

Was unpleasantly surprised today to realize the .eth domain names are not real domains in the Web2 / browser meaning of the word.

I mean ... why not?

The ledger is there. The ownership of a particular domain can be traced perfectly.

There exists encryption schemes so that only the bearer of the private key of whoever has signed the "current" (most recent) domain transfer transaction can decipher requests that come to it.

Alternatively, to not expose this private key to the very nodes that serve traffic, the ledger can — and should! — contain more public keys, which should instead be used for encryption.

So it is quite literally TLS-grade key proof. No need for a central authority. And no man-in-the-middle attacks are possible, since it's unambiguously clear which key should be used.

For bonus points, decentralized pub-sub buses exist. So even OAuth2 is perfectly possible via this fully decentralized protocol. In fact, for some ~$0.1 per login event, it is trivially possible to perform the OAuth2 handshake via a good old Web2 callback URL while leaking zero metadata whatsoever.

Seriously, "sign in with wallet" should be as trivial of an operation as "type in your authenticator code" is today. We used to have SMS messages as the provider for two-factor authentication. Thankfully, they are mostly gone. But now we are using authenticator apps, which use symmetrical encryption and are thus insecure by design. Why not fix it once and for all?

I recall having difficulties explaining how come I need to type my own password — for the SSH key — to log into a remote machine. Sure, such a protocol is somewhat counterintuitive, and requires special knowledge. But I'm not asking for that product-wise.

What I'm asking is a proper authentication-code-based secure login. And this code will be the QR code to show from an offline device into the laptop's webcam. And the user has to type in their PIN code on that offline device. And scan the request QR code. And read on the screen what exactly they are logging into, to make man-in-the-middle attacks impossible.

And, to the best of my knowledge, the above protocols exist for a long, long time in the Web3 world. And they are as secure as they can get.

Guess I'm just ranting about low adoption of Web3. Sure, it's not all unicorns and rainbows. But some Web3 ideas are just so obviously unambiguously useful and positive, that I often begin assuming conspiracies when it comes to explaining how come they are not adopted widely as of yet.

And instead we are teaching kids AI.

For God's sake, let's perhaps start from basic cybersecurity? So that the next generation of humans knows that "trust no one" is the only sensible default when it comes to private data.

And so that the Customer slowly yet surely moves the Market towards Products that unconditionally respect this "trust no one" attitude on the protocol level. Where no mistake can possibly creep into any authentication process, even accidentally.

I can now tell the code is Cursor-generated by the fact that the comments in it are not complete sentences.

// This is how you should do it. With full stops.
// Because Google Style Guides FTW!

Somehow this lack of punctuation literally jumps into my face. Moreover, in my own AI-generated code, I struggle to convince the model to actually include those full stops.

Although maybe it's a good thing. Not only because it offers a signal, albeit weak and imprecise. But also because this very minor irritation may well be what makes me less embarrassed about checking in AI-generated code where I have not carefully reviewed every single line.

See, in HTML/JavaScript code I'm perfectly fine with lack of full stops in "my" comments. The explanation ought to be that I am far less emotionally attached to how "my" HTML code looks like. Which serves as a decent proof that I indeed *am* emotionally attached to how my Rust code looks like!

Alternatively, I can choose to find meaning in this suffering, and embrace it.

Perhaps the purpose of my life is to be that person who embraces quality human-produced code, in this uphill battle while not a single human being has looked at an increasingly higher fraction of "freshly produced" source files.

At ease. AI-generated code is good. My code is good. And there will remain a broad enough set of domains where it *is* important to have nontrivial code which several experienced enough people have read through and understood in its entirety.

And those very likely are the domains where I would like to get my hands dirty with code. In other domains ... well, I can play a TL[M] and call it a success.

Besides, tests are good these days. All hail good tests.

Amen.

Not sure who needs to read this, but I spent an hour this fine Sunday to build a script that transcribes a directory of directories of Zoom recordings [1].

Now it'd probably take the rest of the day + night to transcribe the calls I want to have transcribed.

Guess this qualifies for success.

[1] https://github.com/dkorolev/transcriber

Not long ago, I shared a thought experiment with a friend. He looked at me like I’d just escaped from a mental institution. When I asked, “What do you think of this?” he replied, “I don’t think of this at all — and neither should you.”


Here’s what I had in mind.

As kids, many of us played cryptic games. One involved a square sheet of paper with holes cut in specific spots. You’d place it over a blank page, write letters in the holes, rotate it 90 degrees, and repeat until the message was complete. The final page looked like nonsense — unless you had the original grid and knew how to rotate it. Then it all made sense.

Here comes the thought experiment.

What if modern encryption were just as easy?
Suppose you could send a secure message — or even sign a financial transaction — using nothing more than a pencil, paper, and a few minutes of effort. In this world, anyone could handwrite a QR code encoding an encrypted message, then burn the working sheet.

To transmit it, you'd drop the QR code into a mailbox — a centuries-old, network. We even presumably have a constitutional right to private correspondence, but that’s a different conversation.
So here’s the question.

If this world existed — where encryption is manual, accessible, and untraceable — would society tolerate it?

Would we ban the "wrong kind of math"?

Would teaching kids how to do paper-based encryption become suspicious?

Would it be illegal to drop a QR code into a mailbox?

Surely this sounds absurd. Only a totalitarian regime would criminalize a child’s paper game or a harmless act of privacy. Right?
Well, today, end-to-end encryption is under attack. The UK has recently passed legislation making it effectively illegal. I'm not a lawyer, but it's plausible that, under current UK law, manually encrypting a message and mailing the QR code could be a crime.

Even in the US, the cypherpunks community worked hard to fight the S.266 bill, introduced in 1991 by Senator Joseph R. Biden. The bill aimed to require government backdoors in all strong encryption. It failed — but later Edward Snowden revealed how little that mattered.
And now, why are we so hostile to cryptocurrencies?

We already have taxes. We already have KYC/AML. There’s nothing wrong with paying cash for a haircut or a train ticket. Why not with a QR code?

The burden of reporting income lies with the recipient. The sender merely sat alone in a quiet room for five minutes and did some math. Nothing possibly wrong with that.

So why are we all acting like this? Just because the math is such that it's not something one can do on a piece of paper, and "secure computing devices" are something the lawmakers are successful enough at declaring "dangerous"?

I'm not advocating we should aim to create more simplified encryption schemes. It's a thought experiment after all. But I do wonder when will the world see that the king of controlling access to information flows does in fact have no clothes.

Pop quiz: why do you think yandexmetrica dot com resolves to 127.0.0.1?

I normally don't share upcoming off-the-record events of the SysDesignMeetup, but we had a break of a few months, and thus some extra visibility is warranted.

This Saturday. If you'd like to join, vote for the best time slot with a Slack reacc here.

To get to Slack, https://tinyurl.com/sdm-slack-invite should still work.

More details and links at http://github.com/sysdesignmeetup/sdm.

Hope to see you soon!

Lately, I’ve been editing texts in Cursor, and it's been surprisingly productive. Line-by-line revision with checkpoints suits my style. But I’ve been thinking — what if this process could go fully mobile, voice-first?

Imagine walking while reviewing a blog post on your phone. You speak commands: “Add a section,” “Make this shorter,” “Rearrange that.” By the time you're home, the draft’s ready to publish.

That’s just for personal writing. At work, AI could be trained on formatting and style guides to prompt clarifying questions during drafting. Over time, it could anticipate team feedback, minimizing back-and-forth.

Now take it further: each team member’s AI learns from past reviews — a sort of pull request history of questions. By the (N+1)st draft, most likely questions are already resolved.

Eventually, AIs trained on domain experts (engineering, product, marketing) could review documents in real time. Instead of 30+ hours of meetings, we’d spend a focused 10 — because our AI-augmented selves already processed the context.

That’s the promise: fewer meetings, clearer output, more time doing real work.

But here’s the catch — I doubt this future brings the efficiency we hope for. Not because it’s technically impossible, but because productivity isn’t a knowledge problem. It’s a coordination one.

We already *know* what slows us down: over-engineering, poor communication, shallow opinions. At Miro, we joked: “It’s just a hash map!” — shorthand for: don’t make it more complex than it needs to be.

AI today reflects the crowd’s thinking. It suggests Kafka pipelines where in-memory would do. It mirrors bad architectural patterns because it’s trained on quantity, not quality. Unless guided with nuance, it reinforces mediocrity.

And in meetings? We already know who’s late, who didn’t read the notes, and who derails conversations. An AI could summarize this — but it won’t change behavior.

The real bottleneck isn’t ignorance, it’s ego. People resist change, avoid accountability, and prefer comfort over friction. That won’t change because an AI points it out.

I might welcome working for an AI manager — one that helps unblock me, follows through, holds others accountable. But let’s be honest: the ones who “talk to AI” best will outperform in appearance, not necessarily output.

So here’s my TL;DR: The tech is promising. The human systems are not. And unless those evolve too, we’re still stuck in the same mess — just with fancier tools.

[ N.B. My original text was longer. I'm experimenting with the AI making texts more concise. Personally, I prefer "my" style better. But the above fits a LinkedIn post, while my text does not. In the spirit of learning to exist in this brave new world, I'll keep experimenting. ]

I've been reading Žižek lately, and several of his ideas resonate with me. One in particular stands out: the notion that identity — whether personal or collective — is fully internalized only when one encounters a profound moral dilemma that cannot be resolved within the "standard model" of their ethics.

A commonly cited example is the Joker’s role in The Dark Knight. The director subtly nudges the audience to identify not with Batman, the protagonist, but with the crowd — who, crucially, are not necessarily opposed to the Joker. By the end of the film, we leave the theater questioning our own moral choices.

A broader, geopolitical example is how China came to possess the agency we attribute to it today. This transformation is rooted in its confrontation with Western colonialism during the Opium Wars. Forced into a position of resistance, China had to contend not just with foreign powers, but with an alien moral and economic worldview — one openly exploitative and imperialist.

Here’s the provocative idea: what if the rise of AI today plays the same role for the West that the Opium Wars played for China?

To simplify: Western civilization — built on competitiveness, market-driven logic, and a growth-for-growth’s-sake ethos — has generated internal contradictions. In order to truly understand what it is, the West might need its own “century of humiliation” — a period of reckoning where it is forced to confront itself, see its reflection in the mirror, and ask what values it truly holds — and where those values are taking it.

The AI boom may serve as that mirror. It exposes everything we’ve been sweeping under the rug for centuries. It demands that we confront ethical blind spots and accelerates the need to define new moral ground — or adapt to the consequences of failing to do so.

Now, imagine a different version of the “AI panic” we’re currently witnessing — one in which AI emerged not from the West, but from the East. Would the prevailing anxieties still revolve around job loss and economic disruption? Or would we instead fear a mass acceleration of introspection, meditation, and the pursuit of transcendence?

David Deutsch once wrote that AI would inherit and eventually improve upon human morality. He even suggested that opposition to AI is inherently racist — or, more precisely in modern terms, speciesist. I think there’s real insight in that claim.

A society grounded in strong ethics should welcome the emergence of more powerful, agentic entities within itself. If these agents are truly aligned with our values, they will only strengthen us. But if we fear their emergence, perhaps we need to re-examine the ethical foundations of our society before trying to slow down AI development.

To be clear, this is just a thought experiment. I don’t believe LLM-based systems are anywhere near having the kind of agency necessary to "compete" with human civilization. But that doesn't mean the mirror they hold up should be ignored.

I keep saying it for many years: Disabling screenshots is just discriminating against those who only have one device.

Ultimately, it's a proof that the market leaders can get away with not giving device and software owners enough control.

Especially when it's not the phone or tablet, but a browser. The browser is the piece of software that is run on my hardware. The browser should represent me, and act in my best interest. If the website is asking the browser to do something that I do not want my browser to do, I expect my browser to be on my side.

What saddens me is not that services keep blocking screenshots. What saddens me is that the people are okay with this.

In a reasonable world which I'd love to live in there'd be a simple control in device options. Screenshots enabled: Always / unless the app temporarily disables them / never.

Sure, 99+% of the people would leave that setting at its default option. Sure, banking or otherwise personal applications do mean well when they disable screenshots at various steps of the UI flow.

But making it out right impossible to take a screenshot is just wrong to my taste.

I hope to live long enough to see the next generation growing up understanding they need to demand the above, not cave in to the "we are doing it to protect your security" narrative.

Context: Yet another app featuring that taking a screenshot will now notify one's conversation partner.

PS: This applies even stronger to text controls from and into which we can not copy-paste the text. The worst offenders are PDF files where the "copy text" option is disables. Please, I can take a screenshot and select the text from the picture these days. Perhaps kill this rudimentary features that is not doing anyone any good once and for all?

PPS: And ChatGPT having the "Share" button that generates a proper link that can not be "Save"-d or "Print"-ed as full text is the next level of evil to my taste.

The "make illegal states unrepresentable" idea may well qualify for the best one of a decade of modern software development.

Seriously, it's bigger than all the OOP/FP debates altogether, it's a superset of the entire strong typing holy war.

I could even say it contains the very Event Sourcing philosophy in its entirety, as long as the history of every single instance of every single object and of their interactions is part of the "state" to be represented.

Making illegal states unrepresentable is just the natural extension of data immutability in append-only systems. And while immutability is a tricky concept to convert someone into, making illegal states unrepresentable is something I've had success making people believe in.

Now we only need our storage layers and schema registries to catch up. Well, I'm on it. Good news is, unlike the enterprise world, Web3 folks know exactly what to do. And Rust is a great language to tackle this particular task.

I keep circling back to a very philosophical belief: if The Good is the goal, The Adversarial Approach must be embraced.

Another way to put this is that I see The Market as a force of nature, like gravity. If we want it to bear fruit, the aim shouldn't be to override it, but to create conditions where it thrives — driving innovation, lowering the cost of creating value, and, by extension, wealth.

In business and products, The Adversarial Approach is just what we usually call competition. And competition is good. The philosophical leap is simple: if we want better products, we need to design systems that foster more competition. More adversarial structure — more competing players — means more innovation and better outcomes for users.

Eventually, markets saturate. Smaller players vanish or get absorbed. As Peter Thiel noted, every business seeks monopoly — and most reach it in some form, often as an oligopoly. The exact structure doesn’t matter; what matters is that competition fades.

Yes, regulators exist, but they always arrive late. So big companies face no real disincentive to monopolize — even if it means big fines later.

During the phase of fierce competition, customers win. But once dominance sets in, focus shifts from delivering value to extracting more of it. Metrics might still trend upward, but user sentiment often doesn't — ask around about recent changes to Facebook, Gmail, YouTube, or Maps, and you'll hear more “meh” than “wow.”

The goal, then, is to leverage The Market cleverly, with customer benefit as the definition of success. And while this idea applies far beyond commerce — governments included — we’ll leave that tangent for another day.

Now for the controversial part.

Suppose platforms like Facebook had to open paid APIs once they passed, say, 100M users — priced according to the value extracted from each cohort. That way, I could pay ~$20/month for Facebook and toss ~$1/month to use a third-party client that works better for me. Facebook still gets paid, and developers get a fair shot. Maybe a school kid in Bangladesh or Nigeria builds the best client and enjoys a few thousand users. Everyone wins.

It also forces honest pricing. Too low, and people flock to ad-free experiences. Too high, and regulators notice Meta underpaying taxes.

I love this model — but it’s unlikely in traditional Web2. Here’s the punchline: it is happening in Web3.

Web3, by design, separates app, service, and data layers. There’s no data-based vendor lock-in. Business models are adversarial from the start — and that’s a feature, not a bug.

Imagine email untied from Big Tech. You pay ~$1/month for encrypted storage, and ~$1/month for your preferred client — or just use a great open source one. Clients compete. You own your data.

Or imagine banking where you own the account. No overdraft fees. Banks offer value-added services — auto-deposit, tax prep — and earn your ~$1/month by doing a good job. Power users might pay $10–50/month for extras like KYC-based startup investing, margin trading, mortgages, or 24/7 human support.

Banks can still offer custody — not everyone wants to manage their own keys. But self-custody is the default. You can leave any provider, taking your financial identity with you. That’s what “self-custody” means in Web3 — and spreading that understanding beyond crypto is, in my view, a noble goal in itself.

That’s what makes Web3 so exciting: it’s uniquely positioned to inject real competition where we badly need better products — where current models, from social media to messaging to banking, have mostly failed to deliver.

Next up should probably be GovTech — but that’s a conversation for another time.