and the fact that air quality usually gradually worsens over time. i think it's easier to tell bad air quality when you move in between rooms/spaces.
but i agree with the op that 'looking' at a display already subconsciously tells you something about the air quality and your relation to it. my air quality sensor [0] has a green/orange/red light system though, so i can sometimes just tell that the air quality is bad by a red led flaring up in the corner of my eye.
The AIRCO2NTROL MINI is a great little device to have in a bedroom or living room, the green/orange/led lights are easy to understand (think traffic lights) even by non-technical people.
I do believe that personal narrative place a huge role here. I know of a poll, in which over 80% of the people believed they’re going to end up in heaven.
most people believe they do good and care about other people.
If we're talking about Christianity, the bible says all you need is to believe that when Jesus died your sins against God were forgiven. It doesn't say anything about going to heaven or hell based on how good you were. In fact, it explicity says that going to heaven is not based on "works".
That's why being brutally truthful with yourself is essential in learning how to love others so as to actually become a good person.
The worst lies we tell are most often the ones we tell ourselves.
It's just like the low-achieving over-confident folks of Dunning-Kruger: they don't really care about the truth, they're satisfied just believing they're an expert. The real experts take a far different tac, one of humility and intense, honest work.
"Nothing is more important than compassion and only the truth is its equal."
> It's just like the low-achieving over-confident folks of Dunning-Kruger: they don't really care about the truth, they're satisfied just believing they're an expert. The real experts take a far different tac, one of humility and intense, honest work.
Of course. Very, very few people are fully cognizant of all their existing weaknesses; those are successively revealed as we make progress on the path of love. The spiritual path is not, to my knowledge, ever fully traversed in one fell swoop of Divine Grace; in fact, it is the protracted struggle that inculcates humility, kindness, mercy, and patience in the student, of which I am but a humble struggler, too. As such, in regards to their and my own desperate need for mercy, I must selfishly insist on being merciful to others, to sow for others that which I need to reap for my own spiritual advancement. It's a benign kind of selfishness that helps foster better and better treatment of others.
So, at least for me, it's a long slog through the morass of my life full of idiotic bad habits of attitude and behavior. No, these vices must be dilligently picked off one by one, whack-a-mole style, using our mind and practices. As we progress, we must develop our humility towards those a bit further back on the progression or even stalled before the starting block, remembering that we all started out from zero when we first decided to take the path of love.
Our struggles with our ego result in either developing a demeaning, self-righteous persecution of others via false pride (thus nipping our nascent spiritual progression in the bud, if not our ill-gotten confidence), or developing a humble gratitude to the universe and its Creator for helping us overcome that vicious beast and our weakness in confronting and defeating its many dimensions of vice, one after the seemingly endless series of others.
We must either humbly submit to kindness, gratitude, and patience or suffer defeat at the hands of an ego gone mad with ignorant power.
The greatest medicine and sustenance for surmounting such formidable obstacles in the ego is compassionate service to mankind, asking nothing in return, and consulting often with the Source for help, appreciation, and inspiration.
To those who haven't begun the journey yet, we must only offer our compassionate, kind help in the best way possible, with gentle touches of wisdom. That is the best way to testify to God's love we are to carry to one and all in our every intention, thought, emotion, word, and deed, purifying them incrementally over time. These are called by some "the fruits of the spirit", and are mentioned in this NT quote:
"You will know them by their fruits."
People can say whatever they want, but the truth of everyone's life shows more and more clearly upon our face as our years of living accumulate, and also in our tone of voice and content of our utterances, but most importantly in our desires and treatment of society's least valued members.
That why Rumi said, "You have no idea how little we care about what people say."
whenever i'll teach newcomers computing, i will now adopt the approach laid out here. it's easy to forget how painful learning computing is, how much you need to know about the internet to make a single http request and read out it's response. user @simonw talked about this recently on twitter [0][1]
absolute beautiful point about needing a different kind of literacy in the modern age at the end of the video.
i wish, with all my heart, that this and similar projects develop a loving community which will enable other communities to learn computing in an accessible, cheap and memorable way.
I've wondered about something related and the origin of Erlang in the 80s/90s. Back then when it was running on the telephone switches etc, was it running bare metal? Or did those switches run an OS like some form of Unix or something else?
Not to downplay it or anything, but it is "just" the normal Erlang BEAM VM compiled together with the real time OS RTEMS (which basically implements all POSIX things that the VM needs). Of course, getting it to work needed a lot of research and and experimentation, but the end result is surprisingly simple for what it is. The maniac/genius part is coming up with the idea in the first place and actually pushing through until it works, not many people have the stamina and focus for that.
Source: I was part of the original core team, and I developed the first version of the Erlang support library and runtime.
I guess I’ve been a bit disappointed Nerves doesn’t run on microcontrollers, though, such as an Arduino or Raspberry Pi Pico. Basically,
once you have Linux, you can run nearly anything already.
It was never intended to. The BEAM is not a good fit for that environment. I find it a bit bewildering that people are disappointed about that but I think it comes from having had the difference between microcontroller and embedded linux device clear to me from the early Pi and Arduino days.
You can look at AtomVM for a way to run Erlang and Elixir on an MCU. It just isn't Nerves. Nerves is a Linux :)
i encourage everyone to watch the linked video [0]. reminds me of the recent non-technical arguments made in the freebsd thread [1].
git mailing lists have such a greybeard IRC vibe to them.
i will, from now on, use "only accepts patches per mail" as a proxy for "not worth suggesting new ideas to" for all projects.
it's a stupid proxy.
correlation and causation and all that.
but it's a very useful one for your sanity.
You have a minority who wants to impose a change, and the concerns outlined in that video by the audience member reflects genuine concerns from many other maintainers and contributors.
That this discussion repeats itself can only be taken to be either:
1) Evil C programmers are stodgy and old, and can't/won't get with the program, boo!
2) The Rust minority has, as of yet, failed to properly answer what happens when C APIs change in either signature or semantics, either of which can break the Rust bindings. Some questions:
* Who tests to avoid this?
* Who's expected to fix it? The one changing the C code, who might not know Rust or a separate bindings team?
* Is there a process ? A person to contact/raise the issue with? To get help or to have the work done?
* What happens if the bindings cannot be fixed in time for the next Kernel release? Put differently, will Rust bindings changes hold back changes to the C code?
If broken bindings indeed can hold back changes, then C changes are held back by Rust and indeed then the onus is on the committer to either forego improving/evolving the C API or pick up Rust and fix the bindings also.
In that case, yes, the Rust bindings will either freeze the C API or force the individual contributor to learn Rust.
That people repeat their concerns isn't an expression of stupidity any more than a result of the people driving Rust into the kernel have yet to properly communicate how they envision this process to work, I suppose.
> You have a minority who wants to impose a change, and the concerns outlined in that video by the audience member reflects genuine concerns from many other maintainers and contributors.
What change exactly is being imposed? Rust has been accepted, so that parts of the kernel can be written in either Rust or C. Nobody is pushing for an entire kernel rewrite in Rust. Nobody is pushing out C maintainers.
> The Rust minority has, as of yet, failed to properly answer what happens when C APIs change in either signature or semantics, either of which can break the Rust bindings.
He answers in the very video: there is a process and it is communication. When a C API change which can break the Rust bindings, you email the maintainer responsible for the Rust bindings. It's as simple as that.
> If broken bindings indeed can hold back changes, then C changes are held back by Rust and indeed then the onus is on the committer to either forego improving/evolving the C API or pick up Rust and fix the bindings also. In that case, yes, the Rust bindings will either freeze the C API or force the individual contributor to learn Rust.
This is already happening with C development anyway, when an API change causes drivers maintained by different people to be updated, but nobody is saying "C changes are held back by C".
> That people repeat their concerns isn't an expression of stupidity any more than a result of the people driving Rust into the kernel have yet to properly communicate how they envision this process to work, I suppose.
But in this video, you see someone driving Rust into the kernel communicating how they envision this process to work, and a guy adopting a hostile tone claiming to be an engineer and calling another language a religion. This isn't concern, this is discrimination.
Theodore Ts'o, the person you are implying is not an engineer, started working on Linux in 1991.
Just look at the MAINTAINERS file of the Linux kernel source tree. You'll find Theo maintaining several critical pieces, including leading the ext4 file system development, but really, take a look.
Just to underline this. You are calling the credibility of a man whose code has most assuredly had a hand in storing your files, whether on your laptops/workstations or servers you've deployed to. A person who has been contributing for nearly *32 years*.
How about we flip this around ? Here's a person who's been a large part of the success of the Linux kernel project for 32 years, and here's this presumptuous group coming in left field, telling him he's doing it all wrong and that it's time to get with the program or buzz off.
People like him, the old guard, the core contributors, the main drivers of maintenance, should absolutely be heard. Linux is what it is today because of them. It's too precious to entrust to a bunch of well-meaning, but somewhat preachy and largely unproven developers.
-----
So he comes off rude. But how come the people driving the Rust integration into the kernel are still ducking the hard discussion?
It is almost as if everything is proceeding under the banner of "just an experiment" until, hopefully, a switch can be flipped and it becomes required, and everyone either has to maintain those bindings or see their patches rejected. Even better, then people who never wanted to pick up Rust, has to, or twiddle their thumbs in the background until some kindly soul decides to provide the updates to the bindings.
Would you labor under such uncertainty and creeping adoption for a year or two, raise the points ad nauseam, get no concrete answers and NOT, at some point, lose your patience ?
> Theodore Ts'o, the person you are implying is not an engineer
Wow slow down there. Where did I imply he wasn't?
I did imply he absolutely didn't act as one. When you're having an engineering discussion and you are being dismissive of actual arguments and reduce that to """religion""" you are not acting as one, you are acting like a fool.
> Would you labor under such uncertainty and creeping adoption for a year or two, raise the points ad nauseam, get no concrete answers and NOT, at some point, lose your patience ?
Whatever the circumstances, I'm not giving a pass to anyone to act like a complete dickhead. Whether that be to Theodore and other toxic kernel devs or to the toxic Rust community. If you lose patience just take a break, don't shit on other people. How is that a controversial take?
> Would you labor under such uncertainty and creeping adoption for a year or two, raise the points ad nauseam, get no concrete answers and NOT, at some point, lose your patience ?
RfL was accepted as an experiment[0], with the understanding that it CAN be ejected again if the evaluation fails. Its mandate was as an opt-in functionality, primarily left for individual maintainers to decide on whether to use and leaf-nodes to use.
It is very likely that this was the very best the RfL project could hope for at that time. Had they pushed for first-class citizenship, other contributors would, sensing the impending impact on their work, likely have revolted and the proposal would have been rejected.
So here we are - this is what the RfL people of the time chose over rejection. No one is changing the game on the RfL devs - if you contribute, you are doing so knowing that this is the official state of affairs.
The problem arises because while individual device drivers and subsystem maintainers indeed can opt-in, bindings provided by RfL impact contributors and maintainers who otherwise wish to avoid using Rust. Namely, if you write Rust bindings for my subsystem and my changes break those bindings, what then ? Am I barred from maintaining my subsystem because you decided to wrap the API for a language I don't know ?
This is not the same as some C code consuming my subsystem breaks on a change, which I can easily fix. This means I now have to read those bindings, understand how they wrap my C API and how their expose API differs from mine (remember: idiomatic (fat) Rust bindings is the goal).
I am now on the hook for bindings I had no say in providing or designing?
If you don't understand how this can seem problematic, or how this can seem like maintainers are being forced into learning Rust and maintaining bindings which may well be a non-trivial layer in between the C API and consuming Rust code, then I don't know how to make the problem easier to grasp.
Essentially, it's a very simple instance of "your freedom to swing your hands ends at the point where my face begins" - someone (the RfL binding writers) are swinging their fists about, hitting some maintainers on the nose, and being surprised that said maintainers are angry about that.
Nobody ever said that a subsystem maintainer needs to fix Rust bindings.
As Ts'o correctly states, that's the problem of the bindings maintainers.
But there is no problem at all. All that the Rust people want is to be informed about breaking changes. Also they said they're happy to get instructions on the semantics of the C APIs. They seem to want to collaborate. The C people just want them out, as it seems looking at this episode.
> He answers in the very video: there is a process and it is communication. When a C API change which can break the Rust bindings, you email the maintainer responsible for the Rust bindings. It's as simple as that.
This is a gross oversimplification. So after emailing, do you wait for the rust bindings to be fixed? Do you just get your changes merged regardless? Does the rust bindings maintainer have a say in what form your change takes? Can this hold back a release?
> This is already happening with C development anyway,...
As I understand it, the rule is if you change something that breaks other code, it is your responsibility to fix it (e.g. callers and such). This is obviously straightforward if you know C.
> This is a gross oversimplification. So after emailing, do you wait for the rust bindings to be fixed? Do you just get your changes merged regardless? Does the rust bindings maintainer have a say in what form your change takes? Can this hold back a release?
I'm pretty sure they are just asking for emailing. Just a short shift to getting changes in advance some of the time rather than none of the time. It didn't sound like they were asking to cross the divide from Partition Tolerance + Availability to Partition Tolerance + Consistency, merely shifting things a step in that direction (I think the CAP theorem applies everywhere).
The concern from those contributors (and we might soon see the same in QEMU) is that these bindings are essentially a weaponization which forces the great majority of contributors to learn Rust or drop out. Essentially a hostile takeover.
If I am contributing to the Linux kernel already, I presumably have a decent grasp of C, the central abstractions in the code I am changing, the email-based patch workflow and so on.
So when my code breaks adjacent code, I should have a good chance of fixing those issues also, and most often, this won't become the main body of work.
If jamming in Rust bindings means the great mass of existing contributors are forced to learn Rust, whether they wish or not, to either maintain bindings or to drop out altogether, then raising the pitchforks is not an unreasonable response.
Well then raise these concerns and find a way to solve them together. Not dismiss a proven solution to real and even dangerous problems like memory unsafety.
It's unreasonable for educated grown men to react like 12yo children and resist change cause "we don't like eating our vegetables even though they are good for our health". If you actually care about the Linux kernel you will find a way forward even if that means communicating with people or even changing habits.
At the end of the day I don't think that the people that are contributing to the Linux Kernel do it out of good will but rather more about than prestige and building a resume. Or else we wouldn't have this resistance to progress.
This is a horrible comment, much like many of the others on this thread. The long-time contributors to the Linux kernel project have been doing so before there was any "prestige" or resume credentials attached. And if it was just about a resume, wouldn't they have moved on already? This is an ill-conceived take and just another example of some of the pro-Rust crowd being far too unknowledgeable to be upset.
You are not convincing me that these people care about the longevity of the project when they are so smug and ready dismiss anything that is not fitting their whatever agenta, even if that is a supposedly passion for contribution and development.
What you don't understand about what you call "pro-Rust crowd" is that there is a reason to push for memory safety and encoding the invariants in the type-system. It's the closer you can get to a mathematically proven system.
If you don't want one of your most core systems to be as robust as possible against security vulnerabilities, even if that means going out your way either learning something unfamiliar or god forbit communicating, like you have more emotional quality than a potato, with other people then you are a horrible person.
"I was expecting updates to be faster, but part of the problem is that old-time kernel developers are used to C and don't know Rust. They're not exactly excited about having to learn a new language that is, in some respects, very different. So there's been some pushback on Rust."
I do wonder if peoples mindset, especially kernels developers, would have a change of tune if Linus himself goes out of his way to learn Rust.
I doubt he is and, likely, has no interest in learning it, either. He is not in the position where he is forced to for the most part. However, from what I remember, he does review a lot of code and makes the final decision what gets merged into the main branch. I wonder how much use he will be when... perhaps in the next 10 years... the lower-level code he review becomes more and more Rust.
I guess by then -- which I covered a little in my comment on here -- is likely to be retiring by then.
I just think Linus, the guy that would says there is "Nothing better than C!" - could change the culture in the kernel world if he becomes decent at Rust programming. In reality, I think he would get annoyed fighting the borrow checker. Maybe I would be proven wrong.
> The concern from those contributors (and we might soon see the same in QEMU) is that these bindings are essentially a weaponization which forces the great majority of contributors to learn Rust or drop out. Essentially a hostile takeover.
No, it just means that when their changes are ready, if they break the Rust bindings then then just need to fire off an email to the Rust people to update the binding. This is no different than having to get an approval before merging a branch. They don't have to code differently at all. It just slows down the merge. That's it.
At present it doesn’t even slow down the merge! The whole point of the experiment is to get experience without interfering with the regular development of the kernel. It’s allowed to be broken by non-Rust work, and as you mentioned the Rust folks are wiling to do the work on that side.
i think we are arguing from different perspectives. my disgust of the video was the tone and hostility displayed by the linux maintainers. even though the presenter made it clear they came to learn and not to tell the C people how wrong their ways are, the linux maintainers kept on pouring.
i understood your argument being a technical one, and not a social one. i have no opinion on this topic from the technical side.
A leader needs to draw a line in the sand around maintenance across changes. The discussions keep going back and forward on "I won't learn rust, so I won't do it" and "we can't have this anywhere real if it's going to be broken". There's no way to arbitrarily solve both of these issues, someone has to draw a line in the sand, say this is the goal everyone has to aim for, and tell everyone they're expected to collaborate. That doesn't mean everyone has to learn rust, nor does it mean rust should be perpetually broken. There needs to be a cut someday where rust becomes used in builds that are not "second class" anymore, and at that time, it will block releases. If that's not a goal, the whole project is pointless, so everyone has to get onboard with the goal, or explicitly say the project should be scrapped, then get on board with the leaders decision or withdraw from the discussion.
Some of the minutae concerns were definitely valid, if a little disruptive in the conversation which could have been a bit more considerate but are ok and not too unusual for these summits.
Ted was IMO extremely rude though. The tropes he came in with, and the tone, were disrespectful, trolly and rude, and they didn't offer any value whatsoever. Here's a breakdown:
Opens with "we're almost out of time here" - aka, I'm gunna make a point, but we're not going to discuss it. Opening statement continued "I suspect part of the problem here is that you're trying to convince everyone to switch over to the religion as promulgated by rust". Kent certainly did spend probably too long talking _prior to examples_ about language features and how they avoid bugs. If they'd have said "here's an API we wrote and here's why we did it this way", that might have come across a little less preachy, but at no point did they actually get overly preachy, and this statement was born much more out of some other set of conversations or fears, and wasn't an appropriate reflection of what they'd been presenting or discussing _at all_. It was a direct challenge against their actions, but actions they hadn't taken, it's almost a personal attack. Ted closes that opener with "and the reality is that ain't gunna happen", which steps this opener which is already bordering on a personal attack into absolutism, dismissal and aggression.
Opening statement still continued "because we have 50 plus filesystems and they will not all be instantly converted over to rust" - no one said or suggested anything of the sort, this is an absurd point and again is extremely disrespectful, because it implies they think otherwise, which is an absurd implication at this level - absurdity to the point of rude and insulting.
Continuing still, Ted barely takes a breath, a strong indicator of excessive emotional content. "before that happens, we will continue to refactor the C code because we wanna make the C code better, if it breaks the rust bindings, at least for the foreseeable future, the rust bindings are a second class citizen and those filesystems that depend on the rust bindings will break and that is the rust bindings problem not the filesystem community at large problem, and that's gunna be true for a long long time". So yes, there's a central point in here which is a somewhat clear statement that the C devs won't fix rust, and rust will break in between. That's fine, everyone essentially agrees, and the thing is this is responding to, well, nothing that was presented, no one presenting said or implied otherwise. The trailing "for a long long time" though is heavily coded, and it combines with the earlier coded implication, the combination of which is: anyone who writes a filesystem in rust will be broken for a long long time. This is again extremely aggressive. If the statement was "until rust becomes a first class citizen" it's extremely reasonable, but that's not what was said, not at all, and given the totality of the tone you can confidently say this was intentional. This was a statement to onlookers "don't do this if you're serious", aka, don't do this. This statement is also closed with, much like the start of the opening remark "and we simply need to accept that", aka, this is as i have stated it and there shall be no more discussion.
Cont. "the answer you're not allowed to refactor to the C code because it would break 5 critical filesystems that distros depend upon is like not a starter", well this isn't at all what he meant to say, he meant to say, and everyone took this as because it would break the rust bindings. Again this refers to some content that was not said in the presentation or the discussion. No one said the C couldn't be refactored. If we were to take the statement as stated, well, if there are 5 critical filesystems that distros depend on, regardless of what language they're implemented in, you don't get to just break them, and yeah, that's not a starter, this statement is useless content, everyone present knows Linux and Linus position on breaking userspace. Essentially this is pointless authority posturing, as it referred to none of the content under discussion.
Part two, not that he stopped other than to breathe and set for the next statement, in fact someone started to respond and he spoke over them, continuing: "okay, we'll see, I suspect the best thing to do is you to continue maintaining your rust bindings over time there will be continued C code refactorings right, maybe we will start using kfree rcu, if that breaks rust, we will find out whether or not this concept of encoding huge amounts of semantics into the type system is a good thing, or a bad thing, and instead of trying to convince us what is actually correct, lets see what happens in a year or two and it will either work, or it wont and we will see, or more likely where does the pain get allocated because with most of these sorts of engineering things its almost always a pain allocation question" so again here more aggressive downtalk, again a time reference saying this is still going to be second class in a year or two, lots of emphasis on bad out outcome alternatives as they're stated clearly implying that this is all a bad path. There's so much misunderstanding here as well, there's not a lot of semantics they encoded into the type system, the method in question had split between a refcounted fully initialized type and an uninitialized type, this isn't crazy, and it is composable. Take the example of switching to kfree rcu, well the uninitialized type would be unaffected, and if rcu was integrated with the existing refcount type, well that wouldn't change either, so this code would be untouched, but if it took over the refcounting sure, the refcount type changes, but none of the implementation code. that's a pretty good outcome - in the C, well for this example you've gotta go look in the content of every caller of the equivalent C function, as noted and agreed through the discussion, as the semantics are encoded at each call site individually, and not reused or composed. A final note on the whole pain side of things, summing this all up it's essentially: here's a bunch of choices that maximize your pain, and if your path is the most painful "we'll see" aka you're toast. Again this is really unnecessarily threatening and rude, it's not a collaborative discussion, it's all downtalk and aggression, and the core points, well everyone knows the core points, so they didn't need to be said at all.
Now the presenters respond, and they're just getting through saying "and while rust is a second class citizen i'm fine if you guys say i don't care about this you guys should look at it", and Ted jumps in, almost talking over the end of that sentence, clearly not hearing it, because he says "here's the thing" (now with a raised voice), "you're not gunna force all of us to learn rust, if i make a change, i will fix all of the c code because that's my responsibility, because i don't know rust i'm not gunna fix the rust bindings" then very sarcastically "sorry". He wasn't listening, he doesn't care to listen, he's angry, he wants these people gone, and well, per this article he got some of his way, but frankly this is disgusting, especially when you also consider Teds social weight.
Repeatedly the actual ask that they had was "can you tell us where the semantics are", and implied "and when they change", and mostly what they got was gall and no actual response to those requests (from key actors). A few others did engage in good faith, and were asking what the semantics are of the Rust code and did offer some semantics inputs. I'm not sure who it was but the FS contributor who spoke a lot to the presenters on the way through, he, while interrupting most of the presentation for at least 15 of the 30 minutes, right at the end had essentially talked himself around to the function signature being pretty good. It'd have been nice if he did a bit more of that in his head, but I know the summits do tend to allow for a lot of this interrupty direct engagement, and so it's mostly within keeping, he took a lot of time but ultimately did engage somewhat productively.
reply