Just like `core.async` itself was a frontrunner of Virtual Threads on the JVM, I view `core.async.flow` as the Clojure version of the upcoming [0]Structured Concurrency JEP. I do wonder if it will use that under the hood once it becomes stable, the same way `core.async` is planning to move away from the `go` macro to just have it dispatch a virtual thread.

[0]https://openjdk.org/jeps/453

[0]https://en.wikipedia.org/wiki/Verifiable_credentials [1]https://en.wikipedia.org/wiki/Decentralized_identifier [2]https://en.wikipedia.org/wiki/JSON-LD

That said, I have never used a ref, nor seen one in use outside of a demo blogpost.

    ;; "maps" the keys to the values
    (map {1 "a" 2 "b"} (take 5 (cycle 1 2))) ;;=> '("a" "b" "a" "b" "a")
    ;; acts as a predicate that tests for membership
    (filter #{"a" "b" "c"} ["a" "b" "c" "d" "e" "f"]) ;;=> '("a" "b" "c")

[0]https://en.wikipedia.org/wiki/Verifiable_credentials

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

Points: 1

# Comments: 0

Now I need to figure out a fun way to do spelling, since both of the kids like to write but English is really tricky to spell.

Both kids are now in school and reading significantly above grade level and I have different concern - their ability far outstrips their experience. So even though they can read large unfamiliar words, the subject matter of the stories that are challenging enough to be interesting to them deal with themes and experiences that are pretty foreign. Books that deal more with their experiences and interests are written at a much more basic reading level and are not interesting to them.

They seem to really enjoy reading but sometimes I wonder if early reading is really beneficial in the long run. On the other hand, I certainly read some books too young, but I don't really regret that, so maybe I'm just making up problems to worry about.

webserver: ring-jetty9-adapter[0]

routing: reitit[1]

html templates: hiccup[2]

never used an ORM, but happily used HugSQL for making composable queries[3].

[0]https://github.com/sunng87/ring-jetty9-adapter [1]https://github.com/metosin/reitit [2]https://github.com/weavejester/hiccup [3]https://www.hugsql.org/

[0]https://www.skywaymyway.com/

I'd recommend Elements of Clojure[0].

Don't be fooled by the title, it's not really about Clojure, it just uses Clojure as an illustration as it discusses a very subtle general problem. From the website:

> The first chapter, Names, explains why names define the structure of our software, and how to judge whether a name is any good.

> The second chapter, Idioms, provides specific, syntactic advice for writing Clojure which is clean and readable.

> The third chapter, Indirection, looks at how code can be made simpler and more robust through separation.

> The final chapter, Composition, explores how the constituent pieces of our code can be combined into an effective whole.

I find it a thoughtful and considerate overview of an area that everybody has some implicit knowledge of, and something that leads to a more abstract concept of quality.

[0]https://elementsofclojure.com/

Of course, all this was thrown away in the next installment, so it turns out I'm the fool!