coolsunglasses

Hacker News

not any more, eh?

I do CUDA for a living (not inference) and for the life of me (and a couple of LLMs for that matter) I cannot figure out what you mean by "SM pairs".

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.

cryptography

I'd love for someone to give me an alternative to CUDA but I don't primarily use GPUs for inference, I do 64-bit unsigned integer workloads and the only people who seem to care even a little about this currently are NVidia, if imperfectly.

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.

*ghostty

If you wanted to build a "scripting language" version of Rust, you could probably lose (2).

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.

Debugging the Rust is the easy part. I write vanilla CUDA code that integrates with Rust and that one is the hard part. Abstracting over the GPU backend w/ more Rust isn't a big deal, most of it's SPIR-V anyway. I'm planning to stick with vanilla CUDA integrating with Rust via FFI for now but I'm eyeing this project as it could give me some options for a more maintainable and testable stack.

"Quake terminal" has been a term of art for a regular terminal that drops down from the top of the screen like the terminal in Quake did for the last 20-22 years. I remember this being a thing when I started using Linux back then.

https://github.com/Guake/guake

https://babbagefiles.xyz/quake-drop-down-terminal-history/

Yakuake, Kuake (2003), etc.

I was comparing end-to-end builds. I pay more attention to build times than someone who doesn't do it for a living typically does.

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'm also curious because I've (recently) compiled more or less identical programs in Zig and Rust and they took the same amount of time to compile. I'm guessing people are just making Zig programs with less code and fewer dependencies and not really comparing apples to apples.

I'm a fan but Bill Clinton was sweeping away a lot of cold war apparatus that no longer seemed necessary. It's going to be a lot harder to do anything sustainable or worthwhile with our current system without entitlement reform.

That's hard to believe.

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

Foster was basically the rallying point for people opposed to the grammarian methods of teaching languages that started in Classics but ended up taking over how foreign language is taught in most schools and contexts. Virtually everyone actually fluent in Latin today (reading, listening, or speaking) either learned directly from his a tutor using Ossa Latinitatis Sola or was downstream of that.

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.

I've written parsers and compilers in Rust. I used DAGs in a fairly standard way for stuff that needs it like references. I also work on a complicated VM with a custom memory allocation strategy professionally. Some of my other Rust projects include: a frontend web application that runs in the browser, a client library that has facades for Node, Python, and Ruby, and a Kafka Consumer that handles ~20 GiB/second of data throughput with relatively modest resourcing.

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.

Mega Drive is probably earliest that was capable of it really, but Namco System 21 and especially Sega Model 1 (1990) were designed with 3d/polygons in mind but have relatively old chips in them. Programming for those things could not have been easy.

I just finished posting a comment disagreeing with the author and I think you've nailed the problem with their argument more succinctly than I did. They're assuming "Forgotten Realms" and AD&D, not OD&D.

This post takes the way D&D is played today to be how Gary and his contemporaries played D&D and it leads them to the conclusion that D&D is the opposite of medieval.

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.

This isn't even remotely accurate to Christian belief in either the Catholic or Orthodox churches. There isn't a single church father who believed women didn't have souls, that's facially ludicrous if you know anything about church teaching which means the person writing this did not.

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

Gluttony is definitely a sin in the Catholic Church and is one of the well known seven deadly sins.

Higher demand leads to higher prices and doesn't lead to anything become net-net cheaper. That's a supply-side thing entirely and usually requires a massive regulatory or technological change.

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.

There's no difference, you can go look at an Amazon listing for Lao Gan Ma and it says this:

"Lao Gan Ma Spicy Chili Crisp (Chili Oil Sauce)"

iOS version refuses to run on my Apple Silicon Mac because I have the security thingy disabled for debugging :\

Not what I've seen in strength training or among people doing physical labor (including my wife who used to be a carpenter).

Ditto, 100% same story. I kinda knew I had ADHD and was able to investigate some childhood stuff that suddenly made more sense, but I waited until I had a crisis that was compromising my ability to function at work before finally talking to a shrink. Wish I'd done so a lot sooner.

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.

You'd be surprised (if you have ADHD)

https://www.astralcodexten.com/p/know-your-amphetamines

Using the house as a thermal battery (heat or cold, dealer's choice) works great in my house but my house is so well insulated that we have CO2 problems.

Planning to setup a fresh air intake with an ERV to mitigate this.

tbqh kazinator is manifesting the bare minimum of Caring to be trusted with C++ code as a developer. If you aren't prepared to get into bizarre pseudo-legal arguments with collaborators about language specifications you are going to be happier somewhere else in the software industry.

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.

I don't work at Cloudflare but follow their work and occasionally work on performance sensitive projects.

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

I've been working as a programmer for almost 15 years and I work on fairly touchy (perf, reliability-wise) networked systems in a programming language with a good type system. I find Copilot to be very valuable even if I have to give it a little bump or edit what it produces sometimes.

Not being from Washington myself, which is it?