escherize

I wrote a book about setting up a small gleam project, covers organization of the project in general. A draft is live at https://escherize.com/gleam-katas

Author here. TL;DR: 10 domain-expert subagents, one per major backend area. Happy to talk about why we shaped them this way, what's worked, what hasn't (e.g. routing on overlapping domains is tricky).

Experimenting with exhaustive tagged-union support based on Clojure's defmulti.

I think it might be better to go the other way, and have a pattern-matchey form generate the defmethods instead, but I need to gain tacit knowledge about it first.

https://github.com/escherize/clj-multimatch

I might be wrong, but: What has science got to say about who should be admitted to schools, or more broadly what the priority of civilization should be? I think you're trying to universalize some of y(our) internalized beliefs into axioms.

Is there something like this for Java?

Babashka has saved me a lot of time. I actually think it is the quickest and easiest way to get started learning Clojure, to a point. No startup time didn't seem like a big deal for my workflow until I got instant startup time when running script, and starting repls -- The kind of repl where you can inspect and act on anything in your program.

Babashka tasks is fantastic too! Multi-threaded, simple, and very few surprises.

Case and cond are nice, but they suffer from the expression problem. When you want to let other people add methods to your code without modifying the source you need to use multimethods (or protocols).

If your method only needs 1 argument then why should the other ones matter? I don't see a problem here. clj-kondo will guide people to name them as _ or _thing anyway so you don't even need to think about it.

It's not a book, but I think the most high quality introduction to Godot is by HeartBeast on youtube. I went through his "Pixel Platformer" video "Godot action RPG" playlist. These were quick and got me everything I needed to get started.

Here are some games I made as a hobbyist with godot, in increasing complexity:

- https://escherize.com/works/magnet - https://escherize.com/evermeet - https://escherize.com/works/vampire

Me too! I wrote this little site years ago to help explain what hiccup is: https://escherize.com/works/hiccup.space/

Was there something about Joker [0] that you didn't find suitable?

[0] - https://github.com/candid82/joker

Good to see people coming to the same conclusions we have had for a while using Clojure. There's an up and coming runtime data validation framework called Malli that I use for these sorts of files.

You can get many of the benefits but also run custom validations (dictate how two keys in a map relate to eachother, or force a be of a certain shape instead of just a string).

Here's the example from the script: [0]

[0] - https://malli.io/?value=%7B%20%3Alocale%20%22en-US%22%0A%20%...

I use lineage os for microG [0] myself, but can't find a good foss android keyboard. Is there such a thing?

[0] - https://lineage.microg.org/

There is a new thing, and it's kind of a toy [0]. But it lets you load clojurescript from a script tag, so there is practically no setup needed!!

[0] - https://borkdude.github.io/sci-script-tag/index.html

Same here. Good stuff

I've been using logseq.com and it is great.

It has bidirectional references like you discussed, and sentence level referencing, and embedding.

I believe logseq.com fulfills those needs. Using the "properties" feature, you can tag any block or page.

What's more you can even write queries [0] to ask interesting questions about your notes, like what TODOS were written within a time period, etc.

Could you explain quick-linking a little more?

[0] https://logseq.github.io/page/Queries

I am a logseq user. The nice things about it include:

- all your usual backlinks, graph views, etc.

- saves files as plaintext

- md or org mode files

- operates on / syncs / saves plaintext files

- edit locally, or sync with a git repo

- accessible from mobile (via your github repo)

So I use this with org-mode files, and on my laptop I edit files locally (I have it pointed at a git repo), which is very reliable. Then the phone simply reads from (and writes to) the same git repo.

Since it runs on git, the interoperability of the notes is really nice. If I edit the same page on 2 machines or delete a file, it's just a simple merge conflict that I can use my favorite git merge tool to fix.

Not to mention the developer is extremely active and helpful.

We do basically this. [0][1]

[0] escherize.com/w/hiccup.space

[1] escherize.com/w/cljsfiddle

Well, not sure about that exactly. Consider a map like:

    {:all {:a 2} :foo {:a 4}}

Maybe namespaced keys would fit that usecase

Ok, but how do you know that a change (possibly a bugfix) in your code will break something (maybe a weird, broken thing) that I depend on?

The language Unison has an elegant solution: hashing the ast as the version.

Reminds me of the time I wrote an eavt (entity, attribute, value, transaction-time) store on top of rethink db with a friend of mine.

One of the best features of draw.io is embedding the graph information into exported pngs. So if I save a version of a document as a png, and you open it with the Draw.io app, then you can edit the png as if you had opened the project file itself!

I know pico-8 also does this png embedding (where you can export a cart as a png, and others can load the png into their pico-8 machine).

Are there other apps that do this? It's really a cool hack!

Clojure has while loops, but I think I see where you're coming from: It is a significantly different approach to programming, and if an engineer is not willing to re-jigger their style Clojure is not going to be a good fit for them.

There's a pretty good firebase cljs library that would let you keep most of those benefits.

Using the JVM on aws lambda isn't such a good fit due to startup time.

This page might showcase the effect a little better: https://escherize.com/#/post/neumorph

I've been playing a great factorio-like called Mindustry. It is less resources+logistics and a little more starcraft. It is relaxing and satisfying to rebalance resource lines and optimize production.

https://anuke.itch.io/mindustry

If you can "submit" your change back to the original datastructure then the original datastructure is not immutable, right? Here's a nice explaination about how the persistant immutable datastructures work: https://hypirion.com/musings/understanding-persistent-vector...

I thought this was an interesting take: https://tonsky.me/blog/the-web-after-tomorrow/

I'm late to the thread, but I've felt the same pain and wrote a library to help deal with the cognitive load of working on "shapes" of data [1].

[1] https://github.com/escherize/tracks