skysight-inc/HackerNews huggingface dataset:
Not all that familiar with the specifics of Rust, but I assume it’s “safety” is somewhat similar to Swift’s “safety,” so type safety and memory safety, which does not mean no crashes, just that you will e.g. crash on an array OOB error rather than start writing or reading to random bits of memory.
This is similar to the case, which was successful, over the use of a stolen photograph for Barack Obama's campaign. The artist involved, Shepard Fairey, actually was sentenced for his involvement in the case:

https://www.phaidon.com/agenda/art/articles/2012/september/1...
It could be described as thinly veiled white supremacy.
Why is panicing in the kernel on an error not an option? Like kernels can write a core dump and reboot, right?
A significant portion of people dump everything on their desktop.

But parent is right. Nobody is out here maintaining and pruning their beautiful directory hierarchy, and complaining about how messy applications make their home directory. Because nobody turns on “show hidden files”. Nobody cares.
Turns out foveated rendering is not the panacea it was imagined to be. Eye saccades are so fast that there's just too much motion-to-photon latency to do it well.

https://twitter.com/ID_AA_Carmack/status/1391869530327052291
Same reason most people don't like banner ads. It's extra fluff the user didn't ask for, unrelated to the stuff they actually want to see. It's not the case here, but oftentimes the political messages can be large and distracting, think Notepad++. That's reason enough to dislike them, without getting into any of the "purity" arguments.
I wonder if he'll end up regretting opening this particular Pandora's box or will things stabilize eventually.
What did Android pioneer? Android started life as a Blackberry clone, iOS appeared inspired by Newton, PalmOS, and ideas from FingerWorks and others. Android of course pivoted to copy the iPhone after it was announced. A lot of good ideas that later showed up in both were in Palm's WebOS first. Hard to see 80%.
True- which is why he says to throw a warning first.
The article doesn't quote or link to the policy in question, seems difficult to get a neutral point of view without actually reading the changes to the policy.

Edit: the link was in the sixth paragraph, but it's much less damning than the article frames it.
But I'm telling you, for the third time now, that money is excluded
from the argument I am making. Yet you keep dragging it back to the
same spot again. Are you entrenched in that you are not able to see
the world in any other way than through money?

Yes, money is important. Now, can you forget that? Put it aside and
try to move on to a higher level of thought?

("No" is a perfectly acceptable answer that would satisfy my genuine
curiosity)
I’m a co-author of the paper that the OP’s post discusses. A few clarifications:

- In safety- or security-critical systems, you may want to define a small trusted base, or to be able to audit the system to be confident that certain failures won’t occur (https://groups.csail.mit.edu/sdg/pubs/2009/dnj-cacm-4-09.pdf). Reasoning about such things requires being able to say when one part depends on another. Existing definitions of dependency are too vague or incomplete to support such reasoning, let alone to build tools.

- The puzzles are our attempt to distill issues that arise in practice to the simplest possible examples, so if they sound obvious, so much the better. The fallback case is important in critical systems. Suppose you build a component X and you’ve reasoned that it meets a spec S required by a client C. But then you’re not completely confident in your reasoning, so you build a simpler fallback version X’ that you switch to if X fails to meet some property at runtime. Presumably when you reason about C you’ll want to account for X’ as well. This is a basic engineering issue and not a linguistic nicety.

- The problem is to account for systems the way they’re actually built, not to propose a new way to build them. Even if your code was built with objects, the Liskov Substitution Principle wouldn’t be enough because it only addresses subtyping. Global variables, for example, can’t be ignored. They were pervasive in the car code that JPL analyzed as part of a study I was involved in (https://nap.nationalacademies.org/catalog/13342/trb-special-...), and they arise implicitly in OO code whenever you have static features. Another example: if you’re designing a Mars rover, you’d want to account for failures in a battery maintenance module even for modules that make no calls to it. Interfaces can’t account for this kind of thing.

- @layer8 offers a nice formulation of dependence in terms of reasoning and properties. This was a starting point for our work, and I’d previously suggested a model like this in a 2002 paper (https://groups.csail.mit.edu/sdg/pubs/2002/monterey.pdf) and Eunsuk Kang and I suggested a diagrammatic notation for it in a later paper (https://eskang.github.io/assets/papers/mj_workshop_09.pdf). One key limitation of this approach is (as @csours notes) that it doesn’t let you account explicitly for all the assumptions you typically make in such reasoning. It’s not clear, for example, how such an approach could account for Log4Shell.

- A historical note: I first learned about making dependences explicit from Barbara Liskov and John Guttag from TAing their class (https://mitpress.mit.edu/9780262121125/abstraction-and-speci...). Even back then, we realized that the dependence model was only an approximation, and that it couldn’t be derived from the code. Long after Barbara developed her substitution principle, when we taught the same class together (in 1997) we continued to use dependence diagrams, because they address a different problem.
> I am the only one [...] ?

Have you missed the years and years of people criticizing Linus for his communication style?
> Even "safe" rust code in user space will do things like panic when
things go wrong (overflows, allocation failures, etc). If you don't
realize that that is NOT some kind of true safely, I don't know what
to say.

When people say "safe" there's a pretty precise meaning and it's not this.

Yes, anyone who believes rust is 100% "safe" (by any definition) is wrong. That's not something you learn in Kindergarten though, it's actually about understanding that Rice's Theorem is a generalization of the Halting Problem.

> o this is something that I really need the Rust people to understand. That whole reality of "safe" not being some absolute thing

The irony of Linus lecturing anyone on safety lol anyway "the Rust people" know this already, when they say "safe" they mean "memory safe" - https://en.wikipedia.org/wiki/Memory_safety

Anyway, dumb shit like this is why I've always been quietly dreading Rust in the kernel.

a) The kernel will never be safe software because the mainline developers don't want it to be or even know what safe means

b) It just invites more posts like this and puts Rust closer to one of the most annoying software communities

> Or, you know, if you can't deal with the rules that the kernel requires, then just don't do kernel programming.

Agreed on this point. I was very interested in kernel dev earlier in my career until I actually started to engage with it.
UIs are way harder. Back in the day, you could drag and drop form controls in VB and bind the data to a database without writing a single line of code. Today, every step of that requires boilerplate. Backend, fronted, rest api, and so on.

Distributing native apps has gotten harder in some ways with code signing required in order to share binaries without scary pop ups or the OS blocking outright.
I am probably wrong but I understood that “safety meaning panic” is noeither “safe” not allowed in the Linux kernel because the kernel must not panic when an error arises.
> The best the GNU philosophy gave us is "don't use Cloud," which is head-in-sand ignorant of how modern developers value things.

Lol wut? I feel like this comment is willfully ignoring hugely popular projects such as Nextcloud! There are lots of GPL web services that are available which provide 'Cloud' functionality without being crazy invasive proprietary data-mining platforms....

It seems to me that these services certainly reflect a good portion of 'GNU Philosophy'...
One might respond along the lines of: "why are we investing in ways to operationalize a concept of 'superiority' in the first place?"

The long lesson from the history of this research is that it produces garbage wrapped in a thin veneer of credibility, and becomes a weapon to justify or deepen real existing problems. It doesn't matter if it gets debunked eventually, the problem is how it is used now."

edit: (I don't know that I'm happy with either pole in this debate, but it seems like a good thing to worry about)
Weird phrasing: "The telos of the order is to ...".

When did this phrasing become at all common? That's a theological term, isn't it?
Germany spends quite a lot more than England. Depends how you measure (per capita there's a big difference; percentage of GDP the difference is smaller).

Another thing that's really affecting the English NHS at the moment is Brexit - it's making it very difficult to recruit and retain staff, which has pushed up staff costs because of the spend on locum doctors and agency nursing staff.

But, really, the main problem is 12 years of a Conservative government that does not believe in tax-funded public services. Cameron and May were bad, but Johnson and Truss have been catastrophic for the NHS.
I mean if it is a cosmetic thing sure. If it has substantial meaning I would rather have that 5 ton robotic welding arm not move than have it move through my skill.

It is sometimes acceptable to get wrong output. But is nearly always better to know it is wrong.
You’re of course not the only one. That being said, it’s probably not that big of a deal for most people: there are countless other open source kernels, but Linux is by far the most popular, including in number of contributors.
my big question is:
what frequency (or should I say spectrum) is smell.

and more new from one man's prophecy that said that whole cities will get their energy from a device as small as matchbox... how can that huge energy come out even because ou need thick wires..
Op-Ed – The Rare Earth Ripple Effect of Russia’s War on Ukraine
I mean have everything I have but using a different email address, a GMail one. Your solution doesn't solve moving purchases from the Play store over nor any shared photo albums, etc.
Programming is enormously more complicated today because modern development environments aren't designed for simplicity.

When I first started programming all of my tools had a simple workflow:

* Write a single text file

* run a single command to build (cc thing.c)

* Run the resulting file as a standalone command

People learning to program are often new in general. They're figuring out their text editors. Figuring out how to run programs. Figuring out so many basic things seasoned developers take for granted.

I became quite fluent in C, writing many, many useful programs with just a single text file. By the time I had a need to learn about linking multiple files in large projects I was already fluent and comfortable with the language basics.

Contrast this with modern environments: I need to learn whole sets of tools for managing development environments (venv, bundle, cargo, etc etc etc). These development harnesses all change rapidly and I am constantly googling various sets of commands and starter configs to get things running. These are all things that a seasoned developer will be constantly dealing with on a complex project, but it seems like little effort has been put into creating basic defaults to simplify things for beginners.
Rust's "safety" is memory safety. It's relatively well defined for a technical term: https://en.wikipedia.org/wiki/Memory_safety

edit:

> Yeah I was just trying to provide a clear definition, I didn't think you were implying it was BS.

(would have replied but I'm rate limited on HN - thanks dang!)
Wow. Apple please a million times.
Expectations. If you look back at software 20 years ago, even the most popular websites had relatively low complexity, both in terms of UI and functionality. A single person could have built most of them and value came primarily from content. Even early versions of Google were not that complex to build. Now the entry barrier for a minimum valuable product has dramatically increased to the point where it takes a big team and years to develop a program/website that passes the expectations of a user for their primary website/program.
Iy's easy to lay it all at the feet of Disney. But, yeah, there are plenty of relatively small-time writers who support their families by cranking out some genre fiction book once a year (or whatever) who aren't all that anxious to just casually cut off some level of already modest back catalog sales.

I don't care for myself. My writing translates into money through other paths. But there are a fair number of people for whom writing is their primary income source and it's not a huge one as it is.
if you panic and you're a kernel you very likely corrupt your filesystem, at the very least.
People: can't live with them; can't live with 'em.
If you must have compatibility with tvOS and Apple watchOS as well as macOS and iOS/iPadOS, NE certainly will do the job. (Can’t say that I’ve seen it work with ad blockers, but I’ll take your word for it.) As for other parsers, I’m guessing most NE users stick with its default settings, but have no data on which to base that guess.
> My professional codebase actually really upsets me - sometimes I dread going on holidays purely because I know when I return to it, it’ll take me a week to get over the feeling of just wanting to quit.

This is pretty much the exact set of circumstances that I find myself in, to the point of wanting to write a webapp in a weekend or two, that'd let me keep a log of when and why I wanted to submit my resignation, with descriptions/images and so on.

It is also kind of why I have a slightly ranty section on my blog, that attempts to document the interesting ways how the variety of software that I've used can fail (either in the literal sense, or just with how it hinders my attempts to get things done), called "Everything is Broken": https://blog.kronis.dev/everything%20is%20broken

I just realize that there are so many "broken" things out there, that I literally don't have enough time to write everything down - e.g. describing how hard exporting data from an Oracle instance and then re-creating a similar setup inside of a local Oracle XE container was, with everything that broke along the way (text encoding, export formats, SQLPlus refusing to read files with empty lines, SQLPlus having a problem with the SQL Developer export format, there not being easy to use CLI exporters for Oracle data, there being problems with the init scripts of the Oracle XE 18 images, there being problems with certain DDL being exported but refusing to be imported, certain features that are not available in XE, tablespaces not being automatically extended by default) all just so I could test applications locally with decent performance.

Of course, there are also certain behaviors or mindsets that result in the experience with certain codebases becoming miserable; I'd also like to write more about how to develop software for a more positive outcome, so props to the author for expressing her thoughts along those lines!
If everyone who wrote a blogpost about how rewriting thing x in Rust would be amazing actually rewrote x in Rust it would already be the most popular language ever.
this has now been addressed :)

https://news.ycombinator.com/item?id=33053180
That's the paradox of tolerance.

https://en.wikipedia.org/wiki/Paradox_of_tolerance
Linus is not a “collaborator”.

Sometimes you need to stress the difference betwen “my opinion” (as in “Kernel development requires greater safety standards”) and “facts” (“safety does not exist in software because it does not control the hardware aspect”).
All rights are artifical rights.
I just use 80% hydration, it makes things easier and tastier.
> Spending months to get the basics up and running in their React frontends just to be able to think independently of hand-holding tutorials for the most basic operations.

Frontend devs who were present before the advent of the major web frameworks, and worked with the simplicity of js script + DOM (or perhaps jquery as a somewhat transparent wrapper) benefited from seeing the evolution of these frameworks, understanding the motivations behind the problem they solve, and knowing what DOM operations must be going on behind the curtain of these libraries. Approaching it today not from the 'ground up' but from high level down is imo responsible for a lot of jr web devs have surprising lack of knowledge on basic website features. Some, probably a minority, of student web devs may get conditioned to reach for libraries for every problem they encounter, until the kludge of libraries starts to cause bugs in and of itself or they reach a problem that no library is solving for them. I feel like this is particularly bad outcome for web devs because web I feel is uniquely accessible for aspiring developers. You can achieve a ton just piggybacking off the browser and DOM and it's API, the developer tools in the browser etc. But not if you are convinced or otherwise forced to only approach it from the other side -- running before you crawl, or trying to setup a webpack config before you even understand script loading, etc.
Sure, but it seems like the latter isn't hurt by 1 indexing either, especially if the "names" are arbitrary, and if not, use associative?
I recommend researching the “Dichotomy of Control”. There are some things in life that you have control over and some things that you don’t. Rationally it doesn’t make sense to worry about the things that aren’t under your control. If you have a correct understanding of what things are in your control and which aren’t, and focus only on what’s in your control, it can really help you to stop caring so much about things that aren’t important.
The weight of user expectations, and the tools created to meet them. In between this, the big tech companies have leveraged this situation to put large segments of software developers on a treadmill, by using open source projects and excellent marketing, to impose a 'soft' form of standardisation on common practices (best demonstrated by React / Typescript).

My tongue is in my cheek, but I often wonder.
You do know that these new psychedelic-like drugs are going to be patented and probably quite expensive, right?
It certainly should be, as this guy explains https://www.youtube.com/watch?v=wMFGv6wd5Y8
https://en.m.wikipedia.org/wiki/Neville_Chamberlain
Eye trackers typically require 2-4 additional cameras trained on the eyes. The algorithms for eye tracking are typically pretty involved, but maybe you know some very lower power algorithm to track the eye at 120 hz?
I'm not sure how dedicated hardware will reduce the power consumption for 2 cameras and an ML pipeline to almost nothing.

Northern Europeans have very light irises. It makes it easier to track the pupil from a single signal-to-noise perspective. But there are a ton of weird ethnic challenges for eye tracking. Things like reflectivity and moisture of eyes varies a lot across different across different ethnic groups. Personalization add complexity and will only take you so far when you are dealing with physical sensing challenges.
When I started out, there was DOS. It came with a command you could type in: QBASIC.

Typing this one magic word brought up an IDE, including an editor with highlighting, an interactive help system, samples, an in-editor REPL, and single-key shortcut to run the program. I can't remember if it also came with a debugger and a way to create stand-alone executable, or if that came later.

It had built in commands for drawing, input and sound, all well documented. And the UI was straightforward and intuitive.

This doesn't really exist anymore.
That is a decision taken by Linus. It might have been different but life is choice. This one has been made while Linus is the boss.
Sadly no, you can disable an AWS provided rule but that may have other issues like you lose all detection for that attack vector. With AWS WAFv2 you can have custom rules with logic that lives in lambdas, the lambda is invoked every WAF request for evaluation based on the logic in the lambda.

There are few options on AWS marketplace such as Fortinet and F5 WAF rules. Fortinet is the better of the 2 and newer.
One of my Marine NCOs would say, "there is no such thing as safe."

You aren't safe on the FOB, in your car, in your barracks, or in your house. There are only degrees of safety. Very wise almost globally applicable words.
Complexity of the platforms and packages.
The kernel can’t fail to complete its operations, because then the entire system crashes and no logs are created. Instead, you can finish the operation and check the result.
Yeah ... Just reboot the machine and make me loose all my work, bro.
First of all you need to stop with the personal attacks, it weakens your argument.

Second, we’re not talking about unskilled players. We’re talking about players who intentionally seek to grief others. Players who want the game to end prematurely, or who use unfair assistive programs (cheats).

Your second point is a feature not a bug, IMO.

I want a mechanism that uniquely identifies players to prevent them from circumventing bans they’ve received for their bad behavior.

You keep turning this into a privacy problem. For you that may be the case, but for myself I want my multiplayer games to be able to uniquely identify players. You suddenly bringing to the extreme of “police state”, etc, does not help your argument.

Finally, you insist these problems are “over represented” yet don’t provide anything that addresses the problem I actually stated. Players using hacks/cheats are typically over represented, in games like Overwatch, League of Legends, DotA2, any team strategy game, there are a significant amount of selfish players who will grief there team because they did not get their way. The answer “well then play ranked”, is a non-answer because it implies that we should not be allowed to enjoy casual gameplay.

You seem quite adamant that people should be able to behave poorly, and bypass restrictions applied to them for their poor behavior. I’m curious why.

And lastly, I’ve never had to change a phone number because it was “blocked by something out of my control”. I’ve changed a users DID because they made the mistake of giving the number out to customers.
It's only harder if you make it so, the buzzword / abstraction fog has gotten quite thick, I feel lots of shops lose sight of the basics.

Advances in automation and tooling make it easier than ever to develop complex projects with lean teams but it can't be done if your org opts to inherit a brittle dependency chain every time "I don't want to reinvent the wheel" surfaces.
By this definition, every access to a shared resource is a race condition, e.g. even when properly acquiring a lock. It is common knowledge that you introduce locks to remove race conditions so I would say something is definitely missing from the definition.
There is certainly a lot of choice, but when is the last time you had to:

- really worry about disk space or memory size

- check if something would work on IE

- worry about version control

- manually scale something
I don't think non-free _firmeare_ has ever referred to kernel modules.

All _firmware_ in the Debian repos refers to stuff that does not run in the main CPU but on the CPU embedded in various peripherals.

Binary kernel modules such as the Nvidia driver are not generally considered firmware and are not covered by this vote as I understand it.