Modern chat systems, whether direct, group, or community, fail to capture the joy of 90s IM systems for me.
The inherently synchronous experience, knowing that the other person was also sitting at their PC on the other end, made it much more like hanging out in person than any modern system.
IRC, though dying, still captures some of that feeling. But I miss sitting down in the evening, seeing which of my friends were also online, and striking up a casual conversation.
every compiler project expands until it creates its own version of TableGen. after that it is swiftly replaced with something that is "not as difficult to use", and the cycle continues
I've never fully worked out how best to articulate my dissatisfaction with the usual way people talk about pluggable allocators in systems programming. Sure, I'd like to have some standard for fallible, pluggable allocation at the lower level of a language's standard library. But the entire mindset of plugging together allocators and data structures is something I find dubious and at best it feels like a poor compromise.
@pervognsen I think this view doesn't sufficiently consider the fact that requirements change, and that a system may need to have its allocation strategy changed without a complete rearchitecting due to that.
uarch shower thought: Register windows, which have more or less died out, trade area (and specifically on-die storage) for latency (fast subroutine return).
Techniques that trade on-die storage area for bandwidth (vectorization, register renaming, many forms of OOO, SMT, etc) are still going strong, especially if you think of GPUs as big vector SMT machines.
Is it fundamental that area-for-latency is a bad uarch tradeoff in the long run?
@pervognsen Probably well on its way to being eaten by RISC-V in most places, but I'm sure there's a lot of LEONs in weird places that will keep ticking away for a long time.
@whitequark Do you know if anyone has written about best practices for designs in Amaranth (or maybe just HDL in general)? I feel like I'm at a point where I can write HDL that does the job, but rapidly devolves into spaghetti as it gets bigger.
an LLVM developer and I weren't seeing eye to eye on a miscompilation, and it turns out the AArch64 backend is doing different codegen when invoked via clang vs invoked via llc 🤯
After months (years, really) of preparation and build up, we’re pushing off to leave the Americas in our wake tomorrow, bound for the Marquesa Islands in French Polynesia. A solid month at sea, and then a whole new side of the world. Excited and nervous at the same time…
For C++ library folks -- should const on containers propagate to the elements in the container? why? (or why not?)
And if "yes", why should span (or equivalent) not take the same path? Or should it?
(To be clear, I have lots of my own thoughts on all of these questions. I'm not asking because I'm unaware of any possible answers, but to see how others think about them.)
