* I think the first implementation in JS land was Flapjax, which was around 2008: https://www.flapjax-lang.org/publications/

* The article didn't discuss glitch-freedom, which I think is fairly important.

* 200g starter, 400g water, 600g flour, 10g salt. Mix together.

* Fold it over itself a few times every hour or so.

* When it looks risen, put it into whatever you want to bake it in, let it rise for another 30 minutes or so, bake at around 200C for about 30 minutes.

It's easier than fast yeast bread, as there is less kneading.

Comments URL: https://news.ycombinator.com/item?id=47334380

Points: 2

# Comments: 0

https://functionalprogrammingstrategies.com/

Also, this is a very operational description: how it works. It's also possible to give a denotational description: what it means. Having both is very useful. I find that people tend to start with the operational and then move to the denotational.

If you want sentences without capitalization to be your thing, then go for it. It's just a weird hill to die on, taking away from the readability of your posts for no real reason.

Low-key hate the lack of capitalization on the blog, which made me stumble over every sentence start. Great blog post a bit marred by unnecessary divergence from standard written English.

- Purely on the JVM, you probably want ZGC (or Shenandoah) because latency is more important than throughput.

- On Erlang / the BEAM VM, each thread gets its own private heap, so GC is a per thread operation. If the request doesn't spill over the heap then GC would never need to run during a request handler and all memory could be reclaimed when the handler finishes.

- There can still be cases where a request handler allocates memory that is no solely owned by it. E.g. if it causes a new database connection to be allocated in a connection pool, that connection is not owned by the request handler and should not be deallocated when the handler finishes.

- The general idea you're getting at is often called "memory regions": you can point to a scope in the code and say "all the memory can be freed when this scope exits". In this case the scope is the request handler. It's the same idea behind arena or slab memory allocation. There are languages that can encode this, and do safe automatic memory management without GC. Rust is an obvious example, but I don't find it very ergonomic. I think the OxCaml [1] and Scala 3 [2] approaches are better.

[1]: https://oxcaml.org/documentation/stack-allocation/reference/

[2]: https://docs.scala-lang.org/scala3/reference/experimental/cc...

It's an unfortunate truth that decisions to attend a given university are often made based on an image in the student's (or their parents) head about what a university should look like, rather than things like academics.

Might want to check the cites for more recent work ("Efficiency in sequential testing" looks relevant) and also the literature on "bandit best arm identification", which seems to be distinct from this line of work but tackles broadly the same problem.

In other words, why is one particular abstraction (e.g. Javscript, or the web browser) ok, but another abstraction (e.g. React) not? This attitude doesn't make sense to me.