iTokio

This is NOT a slop linker, Mold is a reference in the world of linkers and this port is official.

It’s pretty obvious that they are trying to lock in consumers.

They are trying to build an ecosystem that can capture the value of AI, whereas LLMs are quickly becoming a commodity.

Where is the moat? How can they convert users?

If you were sitting on a rocket burning cash to not crash you would do that too.

The trillon dollars question is more, will the current GPUs still be relevant in 3 years? 5? 10?

Will incredibly efficient new GPUs appear? will custom ASIC, models burned in silicons, take off? Will unified memory systems become usable?

The datacenter bets are that things will mostly continue like now, and that these GPUs won’t depreciate too much.

For now theses bets are self-fulfilling, causing hardware to even appreciate.

Type confusion, leads to using an object in memory with the wrong type, that means accessing memory with a different layout, like an out of bounds buffer.

So I think memory safety does matter in that case.

Thank you, I will watch these interviews!

It’s like principal component analysis, the main axis, I don’t mean reduction in a negative way.

Numbers

Algebra

Geometry

Probability

Analysis

Dynamics

I loved this talk, but these concepts are like an attempt at dimensional reduction of math research, science, the academics knowledge.

I would have loved to have his thoughts on the mathematical mind, the process, how to reason, infer vs deduct, abstract, prove..

I don’t really know, what are the primitives, essential concepts of math reasoning?

It’s fascinating to live through a the emergence of a new technology and to see people trying to make sense of it as they go.

I personally think that a lot of the words used around AI, harness, SKILLS, agents, RAG.. are make up words or close to it, words that do not have profound semantics, even though people are trying to, often after the fact, make sense of them.

It’s just popular words that are different enough that people like to use them to claim a new knowledge, or to market a product.

But we could use AI tooling instead of harness in the abstract, and it would be better to use more precise terms for more concrete use cases, agent loop, CLI, IDE..

It was a fun game at a time where papers were competing for attention, but now that it has become a proven technology, I hope we can find more precise and meaningful words.

I love to combine assertions with « restartability ».

If you’re program has entered an unknown, failed state, just restart it from a known state.

Even better if you can divide a complex system in sub modules that can recover independently without bringing down the entire system.

Something like Erlang supervision tree. Or at least a systemd Restart=always service.

if your program is mostly stateless, and « restartable », it becomes fault tolerant, and you can use assertions liberally and easily avoid unknown/bad states.

Invariants can be enforced, and correctness preserved. But an important question remains when an assertion is triggered, why invariants were violated?

We need to preserve context, and decide to handle or not this case. That is easy to forget in code that is assertions oriented.

That’s a hn filter to avoid clickbait titles I think

It’s also an old devops trick to put some GB files on the FS of critical systems (databases, ..) when there are no way to dynamically add more space/volumes and monitoring is not trusted.

Bit hard to explain though.

That’s a good point.

Usually when people say to prefer composition over inheritance, that does not apply to the inheritance found in GUI, but as an alternative way to share behaviors as a property, « has a » instead of « is a », like has a role instead of being a user, admin..

That do not work well with GUI, where hundreds of of components are reusing common containers, widget behavior, it would be very verbose and painful to always declare common behaviors, data.

I think, React is cheating because it’s based on the web which already provide DOM node components and JavaScript, a GC language where most rust issues do not apply, there is already an underlying composition framework, the problem is that it is not easy to reproduce in rust.

I did have a look at bevy ECS approach and find it very verbose and really foreign, it’s in « not rust anymore» territory. Macros are a dangerous tool in terms of long term maintainability and are hurting compilation times.

But it’s still really fresh, they are conscious of the issues and I hope bevy maintainers came up with an elegant design

I almost never use inheritance beside using some kind of interfaces/traits to declare a contract.

However, the only time where I’m missing code/data reuse through inheritance is with GUI. Some mostly flat hierarchies of widgets are really powerful ways to declare and compose UI components with shared behaviors.

In rust, the DX for GUI components is always lacking compared to web, C#. With maybe the exception of Slint which is really not Rust anymore.

Is there a way to have good DX for GUI components in Rust?

No, IPO pops, and honey moon periods are common.

And there are plenty of ways to manipulate the price, such as issuing a low float to a hyper hyped stock..

Feature flags are often ridiculously over engineered.

Check a config, bdd value, env var to dynamically go one path or the other.

That’s all, you must either have a small feature or refactor the code to easily switch at a high level.

If you are not able to do so easily, then yes, complex feature flags implementations might help you, to coordinate feature activation between micro services.

Or if you have many features then a dashboard might be useful.

But I would argue that both are serious indicators that you should avoid feature flags, they are better for local and temporary changes, otherwise the complexity compounds and it become hard to manage and maintain.

Well, maybe for simple web apps, but for complex applications there is a noticeable slowdown, I am not even talking about monsters such as jira, but well optimized apps such as vs code, there is a performance ceiling which is lower than for native apps.

On complex problems with lengthy proofs, the first step that I would have done is to ask 5.5 pro in a new, unrelated, session, to be very critical, to try to find flaws in the arguments.

And certainly not to send it to a fellow colleague to ask its opinion first.

LLMs are certainly becoming capable to code, find vulnerabilities, solve mathematical problems, but we need to avoid putting their works in production, or in front of other humans, without assessing it by any possible mean.

Otherwise tech leads, maintainers, experts get overwhelmed and this is how the « AI slop » fatigue begins.

To be clear I’m talking about this step:

> That preprint would have been hard for me to read, as that would have meant carefully reading Rajagopal’s paper first, but I sent it to Nathanson, who forwarded it to Rajagopal, who said he thought it looked correct.

The most interesting exchange, related to disclosure, is this one:

https://www.openwall.com/lists/oss-security/2026/05/01/3

> Nope, sorry, we are NOT allowed to notify anyone about anything "ahead of time" otherwise we will have to tell everyone about everything. That's the only policy by which all the legal/governmental agencies have agreed to allow us to operate in, so we are stuck with it.

greg k-h

Indeed, but the author left a note:

> there are newer GPU-accelerated font rendering systems that use the vectors. I have not yet explored these.

That’s because React started as a small, focused library and evolved as even more than a framework, a whole ecosystem, complete with its own best practices

You just have to read his blog, it is short and he answered everything.

> he used python and xelatex

> https://github.com/ttmc/hello-world-ways

OpenAI definition:

> a highly autonomous system that outperforms humans at most economically valuable work

Mounting Volume and dealing with FS permissions.

They are many different workarounds but it’s a known pain point.

That’s very interesting, but as a counter point, it seems that the major spain blackout was partially caused by such a voltage increase that was not mitigated properly.

So yes there are mitigations but it still is a major cause of concern I think

Well yes, but this is not a competing technology but a complementary one.

You can use this to improve the efficiency of a regular solar panel and as a way to still produce electricity when there is less direct light but enough temperature difference.

Cars are an obvious application.

Some parts get very hot, and any electricity produced without engine or fuel add to range / efficiency.

Yes I wonder if with the current trend, solar might become the real alternative, less expensive, less risky.

But to be fair, you have to consider your « aside », because nuclear has the tremendous advantage of working when it’s cloudy, dark and you need the energy the most in the winter.

I do not think that we can just compare the prices, or maybe we should also add the cost of storage (that is going down too) for solar.

But currently a mix is probably the pragmatic approach.

Sorry I didn’t mean implementing a raw http server like nginx, but just writing a backend.

Go has transparent async io and a very nice M:N threading model that makes writing http servers using epoll very simple and efficient.

The ergonomics for this use case are better than in any language I ever used.