robto

This approach is really appealing to me, and it's similar to how I got my start as a software developer. I had applied for a job and been rejected, but they invited me to apply again in six months. And indeed, in six months I had learned enough and grown enough in to go from a marginal candidate to a good one. I was motivated to do it because it was a career change that had a lot of upside, and knowing that the door was potentially open encouraged me to persist.

This is something I'm very interested in, and I've actually found it very difficult to buy these shapes. Do you have a link to a supplier? I've even approached ceramic studios about getting them custom made, but without any real interest.

Bonus points if you have a supplier for einsteins!

Seems like it draws a lot of inspiration from EDN. Tagged literals, commas-as-whitespace (and optional), and anything-can-be-a-key are features I sorely miss when I have to go back to JSON.

Don't know how I feel about optional quotes around strings, that seems like a mistake. And having an immutable set literal would be nice as well.

I think the flocking behavior of birds is one of the most entrancing natural phenomena, it's great to see it play out in such an intuitive way here. Is a quadtree generalizable to three dimensions? This looks like so much fun, thank you for sharing, I'm looking forward to playing with this over the holiday.

I've been meaning to try this out, from my read it's a declarative way to get some structured concurrency. I work in a codebase that heavily uses core.async channels to manage concurrency and you really need to pay close attention to error handling. When you're spawning new threads you need to set up your own custom machinery to re-throw errors on a chans, close chans, and it looks like core.async.flow is a way to do all of this declaratively.

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

I think the RDF standards have produced many useful tools for those that work with graph data. And the W3C is a useful coordination place for new standards like Verifiable Credentials[0] and Decentralized identifiers[1] and JSON Linked Data[2], which are all being used in ActivityPub, Bluesky, and a lot of other decentralizing projects.

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

Haha, I read The Joy of Clojure way back in 2013 and conflated the different reference types with STM. So thanks for mentioning that, I always thought it weird that you'd need STM for vars and atoms too.

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

Clojure atoms use STM, though. I've been writing Clojure for almost a decade now, it's not that STM isn't great, it's just that immutable data will carry you a very long way - you just don't need coordinated mutation except in very narrow circumstances. In those circumstances STM is great! I have no complaints. But it just doesn't come up very often.

One of the fun things about Clojure that reinforces this "trivially true" perspective is that maps and sets are functions:

    ;; "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")

Once you get used to this idiom you naturally start thing of other functions (or applicative functors) the same way. The syntax sugar makes for some very concise and expressive code too.

I wonder if there's any chance of technology like Verifiable Credentials[0] getting any adoption because of these laws. I think there are legitimate use cases where you would want to say, "hey, some third-party authority can vouch for me that ____", and not reveal to the third party who's asking for verification and not reveal to the party requiring verification any other claim besides the specific one that they need (say, age in this case).

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

Is the Cybersecurity Fabric an open standard? I didn't see any licenses in the Github repository. Is Tidecloak just an implementation of an open protocol? Or is it entirely proprietary?

I could see using one of these as a landline replacement. I was lamenting with another parent the expense of a landline and how difficult it is for kids to call each other to arrange a park meetup or other games - this could fill that gap perfectly.

All data is a graph, and so graph query languages work well for this. SPARQL is my tool of choice but cypher and maybe GQL (though that's new).

That looks pretty nice - my youngest lost interest once the stories started, and I think that was partly because the stories weren't particularly engaging. But overall I was extremely impressed with the pedagogy, it was so easy it felt like cheating!

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.

For what it's worth, the oldest got all the way through on his own power, asking to do it each day. The next kid petered out around day 45 and we didn't try to force it, but she's even more advanced than the first one was at her age now. Not stressing about it seems to be a good approach : )

I taught my kids how to read pretty early (4, not 2) using the Teach Your Child to Read in 100 Easy Lessons book, which was astoundingly easy.

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.

This is my goto:

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/

Reminds me of the Minneapolis Skyway[0]. I wonder if other cold-weather cities have similar systems.

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

They say naming is one of the hard problems of computer science, but there's not much concrete work addressing it.

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/

The list of text links is basically what https://pinboard.in is, basically - social bookmarking. I only use it privately, but it does have the exact function you're talking about as well. I don't think I would use it with thumbnail previews, since I like how lightweight it is, but it wouldn't be difficult to build something like that.

The books weren't actually destroyed, there is a shot of Rey with them on Millenium Falcon at the end of the movie when they pick up all the survivors. I was actually really excited about this foreshadowing a Jedi reformation - a rediscovery of true orthodoxy a la Luther and a rejection of the corrupt ediface of the Jedi Order, as seen by its fruits. This was further paralleled by the stable boy at the end using the force to summon his broom - a parallel to turning over of interpretational authority of scripture from the ecclesiastics to the laity.

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

I haven't seen much else that's competing in the same space, and it seems to be progressing as a standard, albeit slowly.

I worked on implementing this last summer in Clojure, is this the same URDNA2015 specification? I got all but three of the tests in the test suite working, but in the end ditched it for a java library that already had it.

This is really useful for signing json-ld, it goes a bit further then regular normalization schemes like JCS by allowing different arrangements of the same data graph to hash to the same thing.

Falling Free is a great place to start, as it has a stand-alone plot and introduces the setting very well. If you like it then I'd also recommend the Vorkosigan saga.

When lispers talk about lists, they are usually speaking about a very specific type of data structure - a linked list of cons cells[0]. Clojure's lists are not actual chains of cons, they are immutable hash array map tries. This means that Common Lisp code can't interoperate with Clojure code.

The precise/pedantic lisper may insist that since Lisp stands for List Processing and Lists are chains of cons cells and since Clojure doesn't have cons cells for the built-in lists, then Clojure is not a Lisp.

If, however, you view lisp (lower case) as a family of homo-iconic languages that use s-expressions, then Clojure happily fits under that umbrella.

The trick is to pay close attention to whether the person is talking about a Lisp (ANSI Common Lisp implementation) or a lisp (the family). Sometimes people say "lisp" when they are talking about "Lisp", which can cause some confusion.

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

I really like the Fastmail calendar because it has months on a giant scroll, so one leads seamlessly into the next. It works quite well for me because I really think on a "weeks" basis but knowing the month is still important.

I imagine the advantage is mainly in cost - getting a chunk of walnut that large is going to be many times more expensive than getting the boards necessary to laminate the same shape.

Tree-sitter[0] came out of Atom performance optimization, I think, and that's a legacy that will live on a long time. Atom was in my view the closest thing to emacs out there, and it's sad to see that sort of user-empowerment not live on.

[0]https://tree-sitter.github.io/tree-sitter/

This may be a lost cause, but I don't think a beginner language should have mutable data at all. The only reason we really need mutability is for speed - our programs have to run on actual machines and for a long time we didn't have efficient ways of working with immutable data structures. It's a lot easier to reason about immutable data. And any non-programmer is not going to expect mutable data - from the beginning when they started learning math all the way up to MS Excel wizards, all the data has been immutable.

Mutation is a deep magic that learners shouldn't start with. It's pure premature optimization. Also everything should be expressions, no statements, why force people to learn extra syntax? Thank you for listening to my TED Talk.

...but thank you for making this tool! I love the IDE - simple, clear, and self-documenting!

Firefox has container tabs if you don't want to leak your Google account to everything else. And it blocks ads perfectly.