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..