Most modern day exploits are multi-step requiring a multitude of skills to pull off successfully.

That’s a feature of semver, not a bug :)

Long answer: You are right to notice that minor versions within a major release can introduce new APIs and changes but generally, should not break existing APIs until the next major release.

However, this rule only applies to libraries after they reach 1.0.0. Before 1.0.0, one shouldn’t expect any APIs to be frozen really.

Why Swift as a native extension language? A few things people underestimate:

- Swift doesn't have a garbage collector. Like Rust, it uses automatic reference counting (implicit by default) with copy-on-write semantics for safe concurrency you get most of Rust's memory safety guarantees with a much lighter syntax.

- Performance lands around 80% of Rust out of the box, with compiler hints available to close the gap further if you need to tune hot paths.

- Swift 6.3 ships native C++ interop, and the same codebase compiles to iOS, Android, Windows, Linux, and macOS.

For Python developers who want native-speed extensions without writing C or wrestling with Rust's learning curve, Swift is a genuinely underappreciated option. ApplePy tries to make that path practical.

The project is early - feedback and contributions very welcome.

Comments URL: https://news.ycombinator.com/item?id=47739574

Points: 2

# Comments: 2

I disagree - the current levels of income disparity, then Meta and Zuckerberg’s general conduct along with the general sentiment make it extremely hard to say “attaboy” when reading a news like this. I might be saying this for most readers here.

Also I calculated - the approximate worth of those Waymos sitting on that lot was likely upwards of $400M! It doesn't seem much compared to hyperscaler spending but it’s not chump change either. I believe they are going all in.

But what we can’t afford to do is to leave the agents unsupervised. You can never tell when they’ll start acting drunk and do something stupid and unthinkable. Also you absolutely need to do a routine deep audits of random features in your projects, and often you’ll be surprised to discover some awkward (mis)interpretation of instructions despite having a solid test coverage (with all tests passing)!

My interpretation: If the JSIR project can successfully prove bi-directional source to MLIR transformation, it could lead to a new crop of source to source compilers across different languages (as long as they can be lowered to MLIR and back).

Imagine transmorphing Rust to Swift and back. Of course you’d still need to implement or shim any libraries used in the source language. This might help a little bit with C++ to Rust conversions - as more optimizations and analysis would now be possible at the MLIR level. Though I won’t expect unsafe code to magically become safe without some manual intervention.

So judge the content on its merit irrespective of its source.

In other words, we're NO LONGER looking at the scenario where their unit economics was out of whack and lopsided against profitability. The AI frontier behemoths of today (OpenAI, Anthropic and Google) are very well positioned for strong profitability unless Chinese AI companies start gaining more market share in North America.

Yet, I don't think the pace of competition is sustainable. Once there is stronger pressure on them for profitability, we'll see them slow their moonshots, cut costs and focus more on the core business. Maybe that is what we are starting to see now.

OpenAI is most definitely in a position to be profitable. They are spending less than a third of their revenue on compute (all infrastructure costs combined).

    typedef I<((I<((n::val (p::val))>::val) != (I<0>::val))> res;
    };

Update:

Ah, alright - so that evaluation logic is part of the template, not the code that eventually compiles.

It’s basically offloading some of the higher level language compiler logic to the templating engine. Honestly might be a better time investment than spending more time writing this in the parser.

Now I’m sort of intrigued and inspired to use C++ as a lowering target for elevate (a compiler framework I’ve been working on).