coolsunglasses
not any more, eh?
Do you mean the coupled dies on stuff like the B200? An NVidia chip die has many SMs if so.
Do you mean TMEM MMA cooperative execution? I'm guessing that must be it given what the paper is about.
I _really_ want an alternative but the architecture churn imposed by targeting ROCm for say an MI350X is brutal. The way their wavefronts and everything work is significantly different enough that if you're trying to get last-mile perf (which for GPUs unfortunately yawns back into the 2-5x stretch) you're eating a lot of pain to get the same cost-efficiency out of AMD hardware.
FPGAs aren't really any more cost effective unless the $/kwh goes into the stratosphere which is a hypothetical I don't care to contemplate.
Not really no. I work on an interpreted language runtime in Rust professionally and it's still a huge help even if you're still eating perf pain on the interpreted language itself for the same reasons everyone else does. There's more benefit to Rust than you're really capturing here but that's to be expected, it's a short comment.
Here are some other things we get from using Rust for interpreted languages:
- The `unsafe` parts are relatively limited in scope and we have much better and more automated verification tools for `unsafe`, especially WRT undefined behavior
- Being able to make large architectural changes and work through them mechanically/quickly because of the type-checking and borrow-checking is absurdly powerful for any project, all the more so in this context.
- The library ecosystem for Rust has been fantastic for all kinds of projects but it's especially good for PL runtimes.
- LLMs are a lot better at Rust than other programming languages. I have a lot of experience using LLMs in a variety of domains and programming languages and it's far better at Rust than anything else that's expressly about programming. Arguably it's even better at Terraform and Ansible but I consider that a different category. Controversial point maybe but I get tremendous yield out of it.
- It's not just that Rust is fast. It is on par w/ C/C++ all else being equal. What's significant here is that it is a _lot_ quicker/easier to hit the 80/20 perf targets as well as the bleeding edge performance frontier in a Rust application than it is in C and C++. A lot of C and C++ projects leave performance on the table either because it's too hard to make the ownership model human-maintainable/correct or because it would be too much work to refactor for the hoped-for perf yield. Not as much an issue in Rust. You can gin up hypothetical perf improvements in Rust with gpt-5 lickety-split and the types/borrowck will catch most problems while the agent is iterating.
Shared, mutable data aren't really banned, we use it strategically in our Rust interpreter, it's just not default-permitted. Aliasing is precisely the distinction between a safe reference and an unsafe pointer in Rust. Aliasing a mutable pointer in Rust isn't UB, it's just `unsafe`. OTOH, aliasing a mutable reference _is_ UB and not allowed in Rust. Miri will catch you if you do this.
On top of all that, you have some nice kit for experimenting with JIT like Cranelift.
https://github.com/Guake/guake
https://babbagefiles.xyz/quake-drop-down-terminal-history/
Yakuake, Kuake (2003), etc.
https://bitemyapp.com/blog/rebuilding-rust-leptos-quickly/
https://old.reddit.com/r/rust/comments/1i2pr2e/improve_rust_...
https://old.reddit.com/r/rust/comments/ua09tc/experimental_f...
https://old.reddit.com/r/rust/comments/1k9ihhn/does_breaking...
https://old.reddit.com/r/rust/comments/x9z4cm/speeding_up_in...
https://old.reddit.com/r/rust/comments/rlszeq/the_best_cpu_f...
https://old.reddit.com/r/rust/comments/1hpuy01/why_you_need_...
https://old.reddit.com/r/rust/comments/1h9bdbr/rust_llvm_by_...
https://old.reddit.com/r/rust/comments/1j1rvy1/help_me_under...
Anyhoodle, I'm looking forward to testing the compile times again when Zig says the build times are fast now.
But if we're talking about incrementality, I look forward to testing that too when it's ready. I've got a Bazel build for work that pulls together Rust along with a custom (very slow) compiler and the cached successful pipelines take 2-3 minutes (mostly the benchmark run) and the ones that churned the non-rust take 15-18 minutes, of which about 10-11 minutes is just compiling the non-rust.
I understand why you'd feel that way but classics departments aren't what they used to be. It's pretty common for even elite universities these days to not require grad students to understand the languages of the cultures they purportedly study across the board, let alone for Latin.
https://blogicarian.blogspot.com/2019/03/argumentum-ad-ignor...
Striking contrast with the most well known classicist in the UK being unable, by their own admission, to comfortably read Latin text basically at all.
Abandoning the old ways has cost us a lot in almost every area of human endeavour. Especially in pedagogy.
What he's saying here doesn't make any sense. It sounds like they threw in someone who doesn't know Rust at all, didn't bother to ask any questions, didn't reference any existing code, into trying to write custom memory management strategies and data structures and then bounced off the surface. That isn't how you do things in any language, it's bizarre and sounds like Rust was set up to fail. I wouldn't expect this scenario to succeed in any language on a non-trivial project like the TypeScript compiler.
What's even more bizarre is TypeScript actually has better support for ADTs than Golang (which is especially impactful when writing things like type checkers and compilers). I don't even _like_ TypeScript and I can see that. I've written 5-figures-ish of Golang for some work projects like a custom Terraform provider and it's horrific to model just a JSON schema in Golang's type system. Some of the problem is Hashicorp's terrible SDK but not all of it by any means.
Usually the problem is someone just not knowing how to write Rust. The modal subjective experience of writing Rust code as an experienced user is "Python with nice types, async, and executes fast." If you need to handle stuff with weird non-deterministic lifetimes you can use stuff like `slotmap`. If you need DAGs, use `petgraph`. I think pitching Rust as a "low-level systems language" might be misleading some people on how ~95% of Rust users are actually working in the language.
As near as I can tell, patrons, village leaders, barons, and kings were very intentionally a part of the schema of a typical original D&D campaign. They used 1:1 time, players had multiple PCs, and you often led mercenaries into battle (cf. Chainmail rules being incorporated for this purpose)
What's weird is the author appears to be au fait with some of original D&D (they mention Chainmail), but then they make claims like:
>While you can create a barony, there is no way to level up and become a duke or King
I mean, you definitely could, but it's a question of what the scope of the campaign is meant to be. That's between the DM and the players. Just because Gary Gygax didn't address every possibility explicitly doesn't mean it was considered and assumed to happen in some campaigns.
>There’s no evidence for (or against) the idea that OD&D takes place in a dark age after a fallen Roman Empire analogue or during the death throes of a feudal kingdom.
The magic system of D&D is largely based on Jack Vance's Dying Earth series which is a post-apocalyptic and exhausted Earth set in the far future. Between that and the _sheer number of ruins littered all over the landscape_, I would tend to think that there's plenty of room for a DM to weave a background history of a fallen empire into their setting.
The author seems to expect Gary Gygax to have played the role of someone like Tolkien rather than what Gary Gygax actually was: a systems builder who was interested in designing systems for interactive games humans play together.
>The monster descriptions of “men”, “elves”, and “dwarves” don’t suggest that the game is set in a European culture.
What? Just because there are corsairs doesn't mean there isn't a strong Old World flavor to the elements of D&D's cast of cultures. Barbary pirates were a relevant force in European history.
>OD&D is meant to be setting-free. The game’s referee is to create his or her own campaign, ranging in milieu from the “prehistoric to the imagined future” (with emphasis on the medieval, especially for beginners).
This is an accurate statement.
What the author's saying here fits better for AD&D than it does OD&D. There's some insight and reasonable points about D&D not being Feudalism Simulator 2024 (play Dark Albion if you want that) but they take the idea further than the facts on the ground can bear.
Here's a simple example out of many I could draw on: if women didn't have souls they wouldn't be able to receive the sacraments. That means no baptism, no chrismation, no Eucharist, no marriage, no reconciliation, and no extreme unction. It would be metaphysically impossible to be sacramentally married to a woman. C'mon. There would be no need to distinguish between sacramental and natural marriages if women were soulless because they'd be unable to confect the sacrament with their espoused.
The misreading of St. Augustine here has to do with a distinction he was making regarding Imago Dei. He pretty clearly believes women and men are spiritually/metaphysically equal, including as it relates to their spiritual dignity deriving from being made in the image and likeness of God. The passage that gets misread has to do with physical nature and its derivation from Imago Dei. I don't think it was a particularly important point and it's not something I've seen repeated elsewhere.
This is a notorious enough myth about Christian belief that First Things has a multiple articles addressing it: https://www.firstthings.com/article/1997/04/the-myth-of-soul...
Super high gasoline production today doesn't change the fact that it was so cheap in the past they would burn it off to get rid of it.
"Lao Gan Ma Spicy Chili Crisp (Chili Oil Sauce)"
I can start/stop, take drug holidays, etc. with amphetamine (adderall in my case) at will with no ill effects. Caffeine on the other hard, is brutally unpleasant to miss a day of. Been on the same dose of adderall for a few years now. I was able to reduce my caffeine intake significantly after starting adderall.
Planning to setup a fresh air intake with an ERV to mitigate this.
I do not say this as someone who believes this represents healthy behavior or that wants to write C++ for a living. They've been like this since #C on EFNet and FreeNode were a thing 30+/25+ years ago. My guess is they got the behavior from Usenet or something but I didn't hang out there so I don't know first-hand.
If I had to guess, they looked at the landscape a bit like I do and regarded Cap'n Proto, flatbuffers, SBE, etc. as being in one category apart from other data formats like Avro, protobuf, and the like.
So once you're committed to record'ish shaped (rather than columnar like Parquet) data that has an upfront parse time of zero (nominally, there could be marshalling if you transmogrify the field values on read), the list gets pretty short.
https://capnproto.org/news/2014-06-17-capnproto-flatbuffers-... goes into some of the trade-offs here.
Cap'n Proto was originally made for https://sandstorm.io/. That work (which Kenton has presumably done at Cloudflare since he's been employed there) eventually turned into Cloudflare workers.
Another consideration: https://github.com/google/flatbuffers/issues/2#issuecomment-...