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

Archived version: https://archive.is/9d6iG

It looks like it has nullable (nilable) types [0]. So a variable cannot be nil unless it is explicitly marked as having a nilable type.

[0] https://crystal-lang.org/reference/syntax_and_semantics/type...

I do not think your model of threads and processes is correct. Processes have different address spaces whereas threads share an address space. Context switching between threads is much cheaper than context switching between processes because you do not have to swap page tables and do a tlb flush. tlb flushes are extremely expensive. I also think you are misunderstanding how mmap works. mmap is not related to thread spawning.

dune is quite weird compared to many other build tools, but once you learn how it works it's actually quite simple. opam is a pain in the ass but it's definitely being improved steadily and I've had better experiences with it recently. janestreet core seems more stable now than it has in the past but there are occasionally still some breaking changes. They aren't hard to keep up with if you update with each core release though (only like ~1 for my project in the past year or so). There's also a community movement to work a lot more on the ocaml platform and I'm super excited for this work [1] to get through the pipeline! Especially promising is the work on replacing ocamldoc (which sucks) with odoc (which looks great!). While I think work on the ocaml platform will take some time to come to fruition, the approach they are going for is super empathetic and I wholeheartedly agree with their approach for every facet of the ocaml ecosystem -- build tools, doc generation, lsp, editor integration, opam evolution, and all the stability guarantees they're gradually adding. Really exciting time to invest in ocaml!

[1] https://www.youtube.com/watch?v=E8T_4zqWmq8

What do you think about this reply on that thread? https://github.com/bitwarden/server/issues/589#issuecomment-...

Is IgE present in the bloodstream if I have not been exposed to the allergen recently? E.g. will I show as positive for a pet dander allergy if I have not been around pets for many years?

Based on this video [1] linked in the OP, it seems like one of the big benefits is that anaphylaxis is not a side-effect of the drops.

[1] https://www.youtube.com/watch?v=TpP41WQ6pBc

I would recommend toning back some of the emotional language in your treatment comparison table -- things like "confusing terminology", "Busy staff with no time to help", and "Unhelpful Google searches". Your value prop of convenience of no shots is super obvious to me but the biased comparison table is a turn-off. It would give me a lot more confidence if the language in the table were more scientific and clinical. Specifically, I want to be able to look at the table and know for what type of person In-office shots would be better than At-home drops instead of being distracted by the language.

For clarity, is "They" DO or tarsnap?

Scott has written an intro post about this on the new blog: https://astralcodexten.substack.com/p/youre-probably-wonderi...

The about page also has some links to more popular articles on the old blog: https://astralcodexten.substack.com/about

It needs to do a check in order to decide to panic. C/C++ just allow undefined behavior which means they don't need to bounds check because the generated code is allowed to have any behavior in this case (either the read just reads some random memory out of the heap or the kernel kills the process since it tried to access unmapped memory). In rust, panicing involves unwinding the stack. The compiler must generate code to do the bounds check and then also generate code to do the stack unwinding for the panic in the case where the bounds check fails.