A monopoly is not a "state-imposed single seller". Where'd you get that definition from?
There are many examples of natural monopolies, which is a concept that has been recognized in economic theory for at least two centuries. Walter is either being deliberately obtuse or is ignorant of history.
AT&T, Western Union, most railroads, many local utilities—all examples of monopolies that formed "naturally" i.e. without state intervention.
Insofar as there was state intervention in the formation of these monopolies, it was because the state intervened on the company's behalf to suspend antitrust law—such as in the case of AT&T, where the government decided it would be most efficient to permit AT&T to continue operating as a monopoly (until it didn't, and broke AT&T up).
This is WalterBright's operative definition of a monopoly[0], and I'd agree that he's being either deliberately obtuse (perhaps via ideology?) or is misrepresenting history (perhaps also via ideology?).
I'm honestly fine with whatever definitions, but they need to be able to cross the chasm from concept to criterion in conjunction or disjunction to be useful as a means of discriminating. So far, Walter's proposed definitions for monopolies and free markets together fail this test even if they're separately some measure of fine, inaccuracies relative to their term-of-art counterparts notwithstanding.
Recursion reduces each step toward a base case: each step is defined in terms of previous/simpler steps, not more advanced ones. The "recursive" in "recursive self improvement" has things precisely backward. Iteration correctly describes a process where each step is the starting point of its successive step, so it should be "iterative self improvement" but I guess that didn't sound as cool.
I think you're confusing a recurrence relationship with recursive execution. Until AI has control over its inputs (including physical inputs - compute hardware, etc.) it's not quite RSI. We'll get there. They'll get there, rather.
> The choice of @form(vec) here is itself a real design decision, not an arbitrary one.
> The point of the surface isn’t completeness — it’s that every distinct kind of structural commitment a unit can make has a syntactic home. ... Each commitment is declared, not inferred from code.
> type is pure shape. A record. No lifecycle, no flow, no state machine, no bus participation.
And so on and so forth. Every paragraph, every sentence was transparently written by an LLM (sounds like Claude to me). It's difficult to get interested when the humans involved couldn't even be bothered to write down their own thoughts and make them coherent (and much of this text isn't, though it appears so at a glance).
As for the locus concept (https://aperio-lang.github.io/aperio/concepts/the-locus.html), the entire page reads like one of those LLM fever dreams in which it can't stop praising an idea you've pasted into the chat window. It's a kitchen sink primitive that codifies a specific architectural pattern. It's a program structure that probably fits the kind of problem the author has been seeing a lot lately.
There recently was a change to VSCode where commits are being co-authored even if AI wasn't used. Not saying that AI wasn't used in this case, but it could be ambigious.
Deterministic compilation, aka reproducible builds, has been a basic software engineering concept and goal for 40+ years. Perhaps you could provide some examples of compilers that produce non-deterministic output along with your bad news.
He is a software engineer with a comp.sci masters degree with about 15 years industry experience with primarily C++. Currently employed at a company that you most likely know the name of.
> I'm coming to the view that Rust mostly requires less cognitive load than other languages.
This view is only remotely within the bounds of plausibility if you intended for "other languages" to refer exclusively to languages requiring manual memory management
- `&mut T` which encodes that you have exclusive access to a value via a reference. I don't think there is any language with the same concept.
- `&T` which encodes the opposite of `&mut T` i.e. you know no one can change the value from underneath you.
- `self`/`value: T` for method receivers and argument which tells you ownership is relinquished (for non-Copy types). I think C++ can also model this with move semantics.
- `Send`/`Sync` bounds informing you how a value can and cannot be used across thread boundaries. I don't know of any language with an equivalent
- `Option<T>` and `Result<T, E>` encoding absence of values. Several other languages have equivalents, but, for example, Java's versions is less useful because they can still be `null`.
- Sum types in general. `Option<T>` and `Result<T, E>` are examples, but sum types are amazing for encoding 1-of-N possibilities. Not unique to Rust of course.
- Explicit integer promotion/demotion. Because Rust never does this implicitly you are forced to encode how it happens and think about how that can fail.
All of these are other ways Rust reduce cognitive load by encoding facts in the program text instead of relying on the programmer's working memory.
In languages like Java their version of the Billion Dollar mistake doesn't have arbitrary Undefined Behaviour but it is going to blow up your program, so you're also going to need to track that or pay everywhere to keep checking your work - and since Rust doesn't have the mistake you don't need to do that.
Likewise C# apparently doesn't have arbitrary Undefined Behaviour for data races. But it does lose Sequential Consistency, so, humans can't successfully reason about non-trivial software when that happens, whereas safe Rust doesn't have data races so no problem.
Neither of these languages can model the no-defaults case, which is trivial in Rust and, ironically, plausible though not trivial in C++. So if you have no-defaults anywhere in your problem, Rust is fine with that, languages like Go and Java can't help you, "just imagine a default into existence and code around the problem" sounds like cognitive load to me.
The problem Cloudflare had, and from what it seems, still have is that they don't actually test software at small volumes before global deployment. I would guess that two outages in quick succession means the voices saying "You need to test everything properly" might win, but perhaps not.
The Billion Dollar mistake is about not even having the distinction shown in the commit you linked. In languages with this mistake a Goose and "Maybe a Goose or maybe nothing" are the same type.
> DevOps was a reaction to the fact that even outsourcing ops to AWS doesn’t entirely solve all of your ops problems
DevOps, conceptually, goes back to the 90s. I was using the term in 2001. If memory serves, AWS didn't really start to take off until the mid/late aughts, or at least not until they launched S3.
DevOps was a reaction to the software lifecycle problem and didn't have anything to do with AWS. If anything it's the other way around: AWS and cloud hosting gained popularity in part due to DevOps culture.
That was one of the most frustrating seasons of any television show I’ve ever watched, right up until the finale—which completely redeemed it for me! What an ending.
It's phonetically identical or very near it in most dialects. If anything it's a transcription error, but in this case just a way to imply the spoken cadence of a certain accent. Not any more incorrect than spelling "going to" as "gonna" in dialog.
It's not even that, they're pronounced the same in most dialects. It's either a transcription error or an atypical spelling depending on the intent of the author. It doesn't represent a different meaning or pronunciation in speech.
You've misunderstood the theorem. It doesn't say you can't achieve any combination of mostly C/A/P; it says you can't have perfect C, A, and P at the same time.
There are many examples of natural monopolies, which is a concept that has been recognized in economic theory for at least two centuries. Walter is either being deliberately obtuse or is ignorant of history.
AT&T, Western Union, most railroads, many local utilities—all examples of monopolies that formed "naturally" i.e. without state intervention.
Insofar as there was state intervention in the formation of these monopolies, it was because the state intervened on the company's behalf to suspend antitrust law—such as in the case of AT&T, where the government decided it would be most efficient to permit AT&T to continue operating as a monopoly (until it didn't, and broke AT&T up).
reply