Shoop

I think robustness is helped a lot by the fact that it’s the production compiler used at Jane Street

Yes! https://arxiv.org/abs/2502.17424

> I suspect this is the real reason Clojure was created, I bet Rich was just really bored.

Rich has written about the history and motivation behind Clojure here: https://dl.acm.org/doi/pdf/10.1145/3386321

What are the consistency semantics?

What are some examples of those tasks? It’s difficult for me to tell what problems this is intended to solve

Puzzmo Typeshift is a similar game: https://www.puzzmo.com/play/typeshift/

Didn’t 538 give Trump an ~1-in-3 chance of winning?

I’m guessing that the synchronous update architecture they’re using only really only makes sense for persistent memory and that this couldn’t easily be adapted to conventional hard drives or SSDs?

Can anyone summarize the major differences between this and Scaling Monosemanticity?

How does two way isolation work? How do you prevent the host kernel (which presumably has full control of the hardware?) from inspecting the guest VM?

OCaml has a separate language for module interfaces where types are required. Even better, it allows you to abstract over types and make them entirely opaque, so that users of an interface never have to look at any of the implementation details.

Related email by John Carmack: http://number-none.com/blow/blog/programming/2014/09/26/carm...

Discussion: https://news.ycombinator.com/item?id=12120752

I believe the paper handles this case with the LastUsed offset in the implementation of cons.

> During the consing of (9) the pointer offset is compared with the last used offset, LastUsed. If it is the same and less than the block size then it is simply incremented, the new entry made and LastUsed updated. This would have occurred as the integers (6), (7), (8) were added. If on the other-hand the pointer offset is less than the LastUsed a cons is being applied to the tail of a longer list, as is the case with the (9). In this case a new list block must be allocated and its Base-Offset pointer set to the tail contained in the original list.

If I'm understanding correctly, cells are only mutated in place if they are not the tails of other lists (meaning they aren't shared). If the cell is already the tail of another list, the consing is accomplished by creating a new cell to avoid modifying the other list.

For reference:

Tracking issue for overall progress on the self-hosted compiler: https://github.com/ziglang/zig/issues/89

Zig's New Relationship with LLVM: https://kristoff.it/blog/zig-new-relationship-llvm/

Functional reactive programming?

"The GNU Affero General Public License is a modified version of the ordinary GNU GPL version 3. It has one added requirement: if you run a modified program on a server and let other users communicate with it there, your server must also allow them to download the source code corresponding to the modified version running there." https://www.gnu.org/licenses/why-affero-gpl.html

Scott stopped working on HN about 18 months ago. https://news.ycombinator.com/item?id=25055115

Archived link: https://archive.is/UOENL

Could you change the title to "The Joel Test: 12 Steps to Better Code (2000)"? The guidelines [0] ask that you use the original title and not editorialize. Usually people append the year in parentheses for older posts.

https://news.ycombinator.com/newsguidelines.html