What could possibly by dark and cynical about that? This is the only way we can possibly deal with mass unemployment.
Also, 6 million people forced to spend their waking lives driving trucks is not a good thing. The thing that's good about that is the income they get from it. If we create enough wealth to give them the income without the truck driving... We won? That's the goal here. That's what the economy is _for_. Employment is the way the economy has always achieved that, but it doesn't meant employment is the goal, it's a means to an end.
how about retraining people to give them skills the world actually needs. education, healthcare, child and elderly care.
art and entertainment.
also science, research. as much as LLMs are able to do here, they can't do everything. and even with LLMs the more people we have doing research the faster we can progress technologically and also socially.
the real question is, who is going to make these investments?
Your point is optimistic and consistent, I won't criticize it.
But you should know that it's a fairly narrow, political, and controversial thing to say that the purpose of the economy is to support people during unemployment crises. In fact it's so axiomatic that I really think it's worth calling out as part of the assumed solution not an obvious and foundational truth.
It’s not the purpose of the economy, it’s the purpose of civilization.
What makes us different than most types of animals is that we’re capable of supporting the less fortunate members of our species even through life-threatening situations.
I remember some archeologist saying that the first sign of civilization is not some tool or whatever but a healed fractured bone. That means the person that got hurt was cared for by other people who had enough resources to afford for one useless member of the group.
But don't assume it's without its own controversy. Maybe the point of civilization is to allow people to help eachother by providing safeguards against treachery.
Maybe they should be forced to help eachother under threat of violence. There's a massive spectrum of "solutions" between those two, and UBI could be considered pretty close to forcing, depending on how it's implemented.
It's not pedantry or technicalities, a lasting system needs to benefit people and support / build shared principles. Ideally it'd support the principles that enabled it in the first place.
The purpose of civilisation (or rather, why it exists in first place) is that “civilized” peoples managed to survive longer and reproduce more and produce better means to take over the land of those who didn’t adopt technology.
Now we are going to see if there is a limit or not. Or if AI changes the game (the dystopian end game is a small amount of people controlling all the production and getting rid of the rest by one way or another)
The optimistic "another" way is that anyone whose job is now obsolete finds a new job. Ideally within the same company.
(if you live in places with healthy worker protections, a company can't just fire someone, they need reasonable grounds; bar that, they need to first try and place them somewhere else in the company, and if that doesn't work, firing involves paying a severance fee. In an ideal and morally correct situation anyway, in practice they'll use dodgy corporate structures to bankrupt companies before paying or retraining anyone)
Assuming the company still gets some value from them. France has good worker protections but you can always just close shop. (And move elsewhere).
Another optimistic look is that there might just be more work, that otherwise would not be done.
For example we always complain about AAA games coming out riddled with bugs, now we have an opportunity to cut a significant portion of that if we also keep the workforce. Same with administrative tasks that take forever because it’s one person filing it for the whole country etc.
I didn't mean its job is to mitigate employment crises I meant its job is to give people (everyone) income/wealth.
I accept a significant amount of conditionality here - it's cool that people can get rich and live materially better lives by doing stuff that creates more wealth overall. But this is completely subordinate to the goal of making everyone's life better, i.e. I accept it exactly to the extent that "a rising tide lifts all boats". It seems the rising tide of AI may not automatically lift all boats though.
Anyway yeah your point stands, I realise this is not something everyone automatically believes. I'm phrasing it like a statement of fact just because I believe it so strongly.
> If we create enough wealth to give them the income without the truck driving... We won? That's the goal here. That's what the economy is _for_.
Assuming such wealth is created by the autonomous trucks replacing said drivers, for the same number of trucks, that would mean we now have to pay for 1 autonomous truck + 1 idle driver. This is more expensive than a regular truck driven by someone.
So either the number of truck increase dramatically or the replaced truckers find another value-creating occupation (or both).
I only skimmed the article but this doesn’t seem to say that loving itself creates value. This value is based on the expected earnings someone will still have in their life because it assumes the person will work. If you have a person that will live off UBI from the rest of their life, that’s not the case.
I'm not sure if you're being serious, so pardon my skepticism and perhaps pedantry here, but in economic terms there is no value created if there are no people. Thus every person on the planet creates value if they are performing any economic activity. A simple analogy for this is that renters create value for landlords, as there is nothing to lend if there is no one to lend it to.
Perhaps you are looking for an explanation that relates to the abstraction of value that some folks keep simply at "only the people producing goods and services are creating value"?
On the contrary, since truckers also mostly all own guns, they have a lot of political leverage. Everyone knows this; in the US at least. Andrew Wang stated as much in a cnbc interview a few months ago.
If humans lost economic leverage (no jobs) but kept military leverage (usefulness as soldiers), that'd probably be utopia. We could all be a leisure class like the aristocrats of the past, and could defend that state of affairs.
Unfortunately we aren't in that world. AI+robots will deprive humans of both economic and military leverage. Most likely, powerful "blobs" of a few owner humans + a lot of automation will inherit the Earth and kick most humans to the curb.
>On the contrary, since truckers also mostly all own guns, they have a lot of political leverage. Everyone knows this; in the US at least.
What everyone knows is that American gun owners voted in the system that's eating them alive and that they don't care as long as that system doesn't touch their guns.
So they can just keep shooting watermelons in their backyards and being keyboard warriors on the internet, for as much as their "leverage" matters.
My extremely non-technical mum is using a 2008 MacBook Air on Ubuntu, it works great. Claude says the iMac is essentially the same to get running.
Only hassle was setting up the Broadcom WiFi drivers which aren't upstream, but I did this before I would have trusted AI with this task and even then it was not a big deal. I think these days running Linux on those things is likely trivial.
You can also just run Bitmagmet for a few weeks and then you have your own tracker. (I think "tracker" might be technically incorrect jargon but it solves the same problem).
If anybody ask, it's not me who said it, but you can also easily use Shodan to find a lot of open Bitmagnet instances. Many people who self-host do not seem to be aware of the “questionable” decision of docker to always listen on 0.0.0.0 by default and make a firewall rule to expose your service to the entire web (you can also find instances of jackett and some *arr stack, but most of them are at least password protected).
From what I can tell in a cursory web search, that regret is more about issues with C++ being unable to abstract that field vs bit divergence properly, not about the concept of having the specialization be bit-based, which is sound.
I think your description is technically accurate, but maybe this phrases it better:
std::vector<bool> is a perfectly nice growable bit array type, and if the exact same code were in the C++ standard library named std::growable_bit_array nobody would be annoyed about this type, some people would use it, others would ignore it, nobody would write epic rants about it or name it the singe worst thing about C++.
The problem is that C++ popularized generics, and std::vector<T> is a generic growable array type, you ask for a std::vector<Goose> you get a growable array of your custom Goose type, great idea, very popular these days -- yet std::vector<bool> is not a generic growable array of bool, it's this other thing instead that's similar but not quite similar enough to be a drop-in replacement.
In C++ there is no way for the specialization to be bit-based without it being apparent that you are not in fact getting a growable array of the bool type.
No, that's not really an accurate rephrasing. Your comment indicates the problem is that it was exposed as a specialization, KerrAvon is saying the problem was instead that the specialization wasn't effectively abstracted (hidden) behind the API of vector (ie: implication is that ideally we'd have a better API for vector that might require C++ language changes due to the nature of the problems with vector<bool>. not that we shouldn't have the specialization)
> Your comment indicates the problem is that it was exposed as a specialization
Because that is the problem? That's what C++ programmmers are unhappy about.
> ideally we'd have a better API for vector that might require C++ language changes
Ideally after almost thirty years "maybe we could re-design the whole programming language to paper over this bug?" would be such an obviously bad idea that I wouldn't see it in a response.
I recommend not indicating you're rewording another commenter when you actually disagree with them if you don't want that difference in content pointed out. I note that you've trimmed out the parts of my comment that made it clear I was drawing that distinction. Maybe you missed those?
Separately, though, it's not accurate to call this "papering over [a] bug". Wanting to have a thing that behaves like a reference that can identify things that aren't addressable directly (ie: having custom reference representations) shows up in a surprising number of places as desirable because we use references (and things like references) as an abstraction in many programming languages to enable nicer, more usable syntax (ie: having assignments behave in a particular way).
Edit: and changing the language would have been at the time that std::vector was designed (ie: c++98-ish c++ has a real problem with abstracting over not-really-references). With current c++, we can get a reference-like-object much closer to being fully transparent (`auto&&`, ranges iterator model, etc). But std::vector regrets reflect the constraints of the time when it was initially designed/standardized. C++ doesn't have a good story for making breaking changes, so if folks want a good vector for bits, today they'll go elsewhere.
> I recommend not indicating you're rewording another commenter when you actually disagree with them if you don't want that difference in content pointed out.
I can see why you're upset but KerrAvon describes their statement as the result of "a cursory web search" and it isn't false so I wanted to be clear that what they wrote was not wrong per se. I don't think I "disagree" with a person who used Google, read some stuff and came away with an emphasis on the technical reasons this is a problem rather than how it's actually a problem for real programmers.
Maybe I do disagree with you, that's very possible.
With current C++ you could design a specialization that's somwhat less crap. But what's actually important - and what would actually happen - is that you would not standardize such a specialization at all because everybody knows it's a bad idea to do this - it would still be crap if you tried today, just less crap than in 1998.
C++ chooses to have a bad story for breaking changes. That's a deliberate choice and should be understood that way. WG21 are not hapless victims.
I definitely agree that the state of the committee's management of C++'s ability to have breaking changes is not good. Languages should really learn from how rust is handling that pattern, as it seems like it's working fairly well there. Though rust so far has a much shorter lifetime, and hasn't needed to make as large of changes as C++ has needed, the editions model (or something like it) with isolation between translation units seems like it's very workable as a general pattern.
I suspect this is because they are usually introduced like "here are bitfields, but DO NOT USE THEM for anything that might become ABI because their order is implementation defined". I think that causes people to mentally file it under <sketchy language features to avoid> when actually there are many contexts where the ABI risk is not real.
It's beautiful to see this perspective! The fact that we are at "whoa, C is fucked up compared to my expectations" instead of "look at Rust's fancy safety stuff" shows that as a field we've started lifting the baseline.
Nowadays I actually believe I'll likely see a world without memory corruption within my lifetime.
It’s definitely great that memory safety is becoming more pervasive. Though I’ll believe “a world without memory corruption” right up until another <insert your relevant hacker hero name> comes along and finds a way through an unsafe block, an FFI boundary, or the hardware itself (Rowhammer says hi).
Yeah I was thinking of prefixing my "memory corruption" with "software-bug induced"! I don't see a credible solution to Rowhammer. ("DDR[n+1] fixes it" - lol)
> an unsafe block, an FFI boundary
Honestly these feel solvable to me at this point! I think we'll see:
- unsafe code shrink as languages get more powerful
- amount of analysis we can apply to each unsafe line shoot up exponentially as AI gets cheaper
- amount of FFI we actually need shrink as it gets easier to just click "rewrite it in $lang" on the decision card when your coding agent says "I found a library for that but it's in a different language"
(Having said all of that, people seem to be adopting Zig for some bizarre reason... So maybe I'm naive to expect unsafe lines to shrink)
(But also, maybe AI gets so good and so cheap that we can just type "go fidn all the bugs andfi xthenm" into an LLM, between sips of a Piña Colada)
I'm one of those people who's adopting Zig :) But I don't think it's best for every project. For context, I've used Rust before for probably two years writing a realtime audio synthesis engine, so I'm fairly familiar with Rust vs Zig for handling low level details.
The biggest reason I use Zig is it's a very explicit language. The creators made a very intentional decision to avoid too many "high level" designs. This doesn't mean there's no capabilities for abstraction (comptime is great for that), but when you see array indexing, you can think "ptr + index * size with bounds check". There's lots of other things like that where the language does exactly one thing, and that thing is a low level operation.
This is terrible when you want to create high level abstractions that hide details from the programmer, but it's what I need when doing realtime audio synthesis or what I'm doing now which is writing an interpreter. I know exactly what allocates, I know what calls IO and can block (both operations explicitly take in an allocator or IO parameter), no data structures have private fields so I can always poke around at the insides. I know what types of errors a function returns, and creating errors is cheap with Zig's error union design.
So I don't use Zig because I think it's the safer language, I know it has sharp edges because of the number of times I've caused a panic on a poisoned pointer or use-after-free. But because it gives me such a transparent view into what is happening I find it liberating.
My take too. (Aside from this being a well-written, clear article, that I think highlighted a fair selection of relevant points; especially the "always use uint8_t instead if int" part).
I don't see rust a "memory safe" language, or a niche one. I have complaints about it etc, but it's overall a fair baseline of reasonable decisions. When I look at C or other languages rust has learned from, I have more "Yikes, that's rough" takes. So... rust as the language of least "fucked up", to use your phrase? Ownership/safety are one part of the picture, but not what defines it for me.
Is this the sort of thing you only need to know about if building/maintaining compilers? I ask because I don't know what that means from a practical perspective. I'm familiar with Ferrous systems from their work on probe-rs, defmt, and flip-link, which are exquisite libraries / tools.
I would say there are two big misconceptions here, which this article (and your comment) unfortunately reinforces.
The first is that it is "C is fucked up" instead of the poor defaults of the C implementation your are using.
The second one is the idea that C all has to be fragile low-level pointer fiddling instead of much safer high-level code build around abstractions, which good C would usually have.
Sorry but no, this is totally wrong. There is no set of compiler flags or design practices that can fix the lack of lifetime analysis in C.
I do actually think that with modern C++ it's possible to get to a style of programming where memory unsafety is mostly a theoretical concern but not with C.
It is true that you will not get full lifetime analysis with a C compiler, I do not think this defeats my point. (and you can get lifetime analysis with other tools, but we lack good tooling for this)
For me, memory safety is also mostly a theoretical concern in C. This is achieved by having proper abstractions instead of low-level pointer fiddling and by having a clear strategy for managing lifetimes.
The thing that defeats your point is that there is no consequential C codebase that has dynamic allocation and no UAF. There simply isn't an argument to be had here, it's an empirical question and it's settled. It's time to move on and adopt memory safe languages. There are no valid excuses any more now that Rust is basically tolerable.
If you wanna claim this is a skill issue and you are built different etc, fine. I guess we can just say C is fundamentally unsafe for _everyone except you_.
(This is like when people wanna argue about if self driving cars are safe or not and they're blathering on about technical capabilities and limitations. No. We have the data).
Focusing narrowly on memory safety is frequently a distraction that incompetent developers use to excuse their buggy code. "Sure, my Rust code might cause deaths and cause millions of dollars lost; and my code might be unsafe, insecure and incorrect; but at least my code is memory safe and easy to debug when I fuck it up!". And then it often turns out that Rust is not memory safe in practice. https://news.ycombinator.com/item?id=49697392
The real value of Rust is likely pattern matching and tagged unions. Apart from modules/packages that are not a disaster, like Gabriel Dos Reis the saboteur's disaster with modules in C++.
For what it's worth, in that specific instance there's no memory safety issue since Rust is guaranteed to crash on stack overflow on Ubuntu (and probably other supported Linux distros)
For what it's worth, this is not only that specific instance. Rust might not be memory safe in theory, but when talking about "in practice" - there is profound evidence that Rust's memory safety works.
Indeed! They shrug it off when you ask them about supply chain safety or compiler complexity. I opine that post 1.0 they wasted precious engineering time trying to placate nodejs webshits over building the best systems language.
There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.
— C.A.R. Hoare, The 1980 ACM Turing Award Lecture
(Is it given that there's a play? Waymo is culturally a little distinct from Google so from personal experience I can't actually rule out that they're just doing this coz they think it would be good for the world).
I suspect they are fielding complaints that autonomous vehicles increase road traffic, so they want to show that they are encouraging the use of public transit. Uber and Lyft have long been blamed for an increase in overall traffic.
I don't think it makes much sense to expect such a cohesive/specific philosophy from an open source project like this.
The goal is "Linux on Mac". In a commercial product, specific details of what gets built usually stem from a more detailed vision that can be articulated as one. In open source projects those details are determined by what individual contributors are motivated to work on.
That doesn't means a cohesive vision can't emerge, there might be one for Asahi actually. But I think the default position is that it's kinda just a mob of people doing what they each feel like doing.
I don't think it matters that Asashi is a generation or three behind, because the moment you really need it is when Apple stops updating the OS for your hardware.
When M1 drops out of support I bet Asashi for the M1 machines will be pretty polished.
Another thing is, the M1 and later hardware is still years later some of the best arm64 hardware youre going to find. Combine that with the really affordable prices you can find on the used market and Linux arm64 on this kind of great hardware at a low price is quite appealing.
I think LWN is not just the best linux news site or the best tech news site, or the best new site. I think it's actually the best website. I just can't think of anything else that comes close in terms of quality of information.
If you have any professional connection at all to Linux then $11/mo is an absolute bargain!
reply