self_awareness

You make your own pigments? I hope you didn't re-use already existing atoms for that

Android (phones, tv boxes) doesn't respect DHCPv6 IA_NA, but it should respect DHCPv6 IA_PD. Unless you have some other system that doesn't respect DHCP? Linuxes, Windowses, Playstation 5's support DHCPv6 IA_NA without problems.

But also, even if a device doens't support DHCPv6 IA_NA, you can always also have a DNS server in your network, and you can bind SLAAC-generated Android addresses to simple subdomains. This seems better than DHCP anyway.

In Poland, Play.pl sets up IPv6 by default. One phone call to ISP to disable the hidden firewall on their router gives us full IPv6 network transparency, no NATs are needed anymore. I highly recommend after installing a firewall appliance (for example OPNsense, but probably Mikrotik should have it as well). IPv6 "feels" like how networks should work since the beginning. IPv4 feels like a legacy technology.

They of course also have a DS-Lite AFTR gateways to tunnel the IPv4 traffic. In practice, everything works (for me at least).

Police exists to enforce the policy set by legislations.

Legislations define rules to protect "us" from harm, but police is for policing only.

They do not protect people. They protect the law.

I don't buy the argumentation.

Am I not allowed to say that hammer is just a tool and it matters how you use it? Because it makes all classic sculpture art meaningless? No it doesn't.

The "car is just a tool" doesn't make oil waste problem any less problematic.

I am one of those people who say AI is just a tool and it matters how you use it. But also, GCC/Clang/Rust are just tools and it matters how you use them. Your mouth is a tool and it matters how you use it. When thinking about ANY tool you should think about the best way to use it.

But for AI specifically this saying is most important, because a lot of people treat AI as another person. "He's like a junior employee" is what I've heard in my company on meetings. It's not a he, it's not a junior, it's not an employee. It's a tool!

It's not really about piracy in general, it's mostly about What.CD.

Equivalent of what.cd today is RED.

But, TBH, most of the pirated music today is on YouTube anyway.

Still DRM can revoke rights, depends on what form we download it as, but yeah, downloading locally is generally much better than keeping it "in the cloud" (which is just someone else's computer).

A bitter reminder for all of us that we don't own digital content at all.

To perform a stupid action is one thing. We all make mistakes.

But to write about it publicly, manifesting our ignorance and lack of critical thinking skill? It's an entirely different matter.

And what is even the point of saying that Andrew dislikes how Jarred acts and works?

Let's say the supervisor wants you to write a new microservice. Do you refuse to do it because the supervisor smokes cigarettes and you're an anti-smoker? I think that if you have objections, you should refuse only on technical grounds, not personal.

It would be easier for you to argument that the user is expected to have discipline to NOT use "unsafe" keyword in all functions.

Because a lot of mechanisms actually still have guards in runtime. And using .clone() on Rc/Arc is actually the idiomatic/preferred way of evading the borrow checker if we can't design the data structure in a different way.

It's a big difference between cases when you need to spend brain energy to find ways to "out-smart" the compiler, and spend brain energy to "fit into the proper set of assumptions" of a programming language.

Very true. Rust prevents some good code as well.

Also it doesn't guarantee that the code is always 100% correct.

But I think this is the correct direction of programming language evolution.

I mean, there's an easier way of doing that than rewriting to another language, just make the repo private.

Yeah, but argumenting that "Bun codebase is a mess" is anti-Zig in itself.

The whole point of the borrow checker is to make it impossible to write wrong code. If Zig accepts bad code, but assumes people will have self-discipline to maintain it, how is that different from C?

C assumes good discipline, as well as C++. But it will happily accept bad code. So I'm not even sure what Zig is even improving on.

Rust was designed to answer this exact problem (among a few others of course).

So the argument "your code is fscking sheet" is very 1990's. In 2026 we need guarantees that we can't produce invalid code.

Ironically, the 'no hidden control flow' was one of the arguments against Zig in the recent Bun rewrite to Rust.

https://bun.sh/blog/bun-in-rust

So sometimes hidden control flow is needed.

moi2389 should research the market and create a new value, not replace someone else by providing the same value.

Free and communal knowledge means you're easily replaceble by someone else.

I wonder what communal answer you have for someone who would say, "moi2388, your work will be now done by moi2389. Thanks and good bye."

I think licensing will have to be re-invented, because now it's trivial to just say: claude, do a "clean-room implementation", so that noone can accuse me of stealing code.

That's what LLM companies have done for years anyway. Inline completions are trained on licensed code. And nobody cares! ;)

If you have a messy room, you don't throw a grenade in hopes that after explosion things will end up in "better" places than before.

Well, if people would prefer physical discs over digital distribution and would insist of having a proof of ownership, I guess Sony wouldn't have a choice but to prefer physical distribution.

But since customers don't care, who else should care?

I always prefered physical disks. That was my #1 pro-console argument. Without those disks, I simply won't buy anything console related. I vote with my wallet, simple as that.

Of course I know that people will still buy digital disks and then cry when Sony will do something unthinkable like revoking access, but I guess that won't be my problem.

It seems awesome, but I'm having a problem with figuring out how can a "normal" person use it. How would YOU use it, reader of this comment?

Follow-up question: why upvote an article that you probably can't read?

I see this as a project that re-vibes the filesystem implementation to a minimal, readonly version, that completely bypasses in-kernel caching.

Is it really faster than normal filesystem? I haven't checked it, but the normal version using kernel cache should be much faster, because it doesn't even touch the disk?

Does official Apple security framework ("Apple EndpointSecurity") targeted at AV vendors serious enough for you? They themselves built an OS subsystem specifically for AVs to use, and Microsoft has done the exact same with AMSI.

There are actually very few techniques that are 99.999% effective. Cryptography when considered per se maybe is, but the wide topic of heuristic analysis is much lesser than that. Even if we consider some imagined, mythical 99.999% effectiveness, it's always measured in the specific boundaries we set during our analysis. Permission rights in the OS are 100% secure if we assume the authentication for sysop is secure. If we store the password for root in a public git repo, then OS permissions are 0% effective even if the system code hasn't changed at all. Your percent value is very fragile and relative to the boundaries we set. The unbreakable wall you think of can turn into a sheet of paper in the blink of an eye.

The cheap port-changing trick can even be 100% effective against generic massive port scanning attacks. But it's 0% effective against a targeted attack. It depends entirely on the surface area we want to defend against. If we define our protection to work against generic automated bots, then changing the port is an entirely effective solution. If we want to ensure our systems are globally "unbreakable" (whatever that means), then it's a weak security solution. In other words, effectiveness is not absolute; it's relative to the threat model.

It's not possible to inspect all the code we use. There's too much of it changing every second. The idea that developers have the time or ability to manually inspect every line of open-source code they import is an economic fantasy. In an era where frontier AI models like Mythos are finding and chaining 0-days in minutes, human review is simply outpaced. But even if we somehow did it, something would already change by the time you finish reading this paragraph. Everything needs to be reanalyzed because we don't know what shifted. And sometimes, the vulnerability manifests in the parts of the code that DIDN'T change.

By the way, I think you might not be aware that current, "next-gen" security solutions offered by Crowdstrike or SentinelOne are actually old antivirus techniques marketed as something new. EDRs are 'just' log aggregators and routers for signatures to be matched on.

Also, please don't think about programmers as someone immune to attacks, as this is not true at all. The fact that programmers invented a method of installation for programmer tools based on piping curl output directly to bash is direct proof that some programmers have absolutely no idea how security works. Especially web developers. If anything, programmers can be more dangerous than normal users because they assume they are better, and then they make the exact same mistakes as everyone else. They are just plain computer users who need to be defended from their own carelessness.

With root, malware can reach out to UEFI anyway, and can do whatever it likes.

And how a malware can use this if it's configured globally in a root:root owned config file?

These are not 2000 approaches, these are approaches used today (signature based detection).

The difference is that in 2000s the signatures were written by hand and described static file info, today they're often autogenerated and describe the system behavior, either by looking at one executable, or a whole network of computers. But it is still signature based detection. Since they describe the program behavior, not the program structure, then if the program itself stayed the same (the sequence of system api calls stayed the same), no runtime packing/obfuscation makes a difference to a signature. Unless obfuscation changes the behavior.

Also security is not binary, it's layered. Sometimes we can address an attack vector by using multiple levels. And sometimes it's simply worth checking for low hanging fruits if only to make the attack more expensive. The "cat and mouse" game is always about the cost of attack and cost of defense, if we raise one then we win in this area, unless the other party finds a way of lowering the cost of their side. Or unless they pay an unexpected amount of cost, for example in state sponsored malware.

By the way, some security solutions also have actual parsers for example for PowerShell, so they can actually detect string concatenation that constructs the URL.

Prepare for hard landing in 3... 2... 1...

It would be like writing english words using cyrylic letters claiming you know Russian.

American HN crowd knows better.