How to cache? It depends of the context: push vs pull and owned vs user.

Push means that the asset is pushed to a central server and then distributed.
Pull means the asset is referenced and the central server has to “pull” the content.
Owned means it’s owned by the central server.
User means it’s user-submitted content.

Push + owned

Make everything push + owned content if possible. "It turns out, however, that you can make a shit ton of other stuff push + owned if you try a little harder. "

How does the client check if they're expired?
Use “stale while re-validate”. Ur welc’

In summary:

• store asset
• use stale-while-re-validate access patterns
• should work offline

Push + User & Pull + Owned

Handle these with hash URLs. Hash the URL and treat it immutably.
Push + User: Forum comment -> hash URL
Pull + Owned: "in-content" assets. That’s where it’s user generated content, but not owned by the server.

Summary:

• Load asset
• Use infinite TTL + hashed URLs
• Should not re-fetch across page/app reloads

Pull + User

That’s where it’s user generated content, but not owned by the server. Posting gifs into the chat is a prime example; linking a blog post and generating a media upload for that is another.

Guess what: this pattern fits for highly dynamic user-generated content, which means it’s the content users link to each other in-platform.

Stable URL, short TTL. YES, SHORT TTL. [...] Debounce + throttle? Sure. Micro-TTL? Yes. Cache? Never.

Shift is_active to something more generic: a status field, so we can expand it down the line for other parts of the state space.

Honestly, 80% of the time in these meetings I just tell people to either use an enum instead of a boolean or to make it more clear which data is events and which is state. I'm always right, it's always useful, and there's never that much fuss about it.

How to build the local-first software with the most interoperable data system: files.
How to avoid conflict while syncing them on cloud providers? Tonsky relates some strategy.

About OOP.
Notice a faisable comparison with the current AI

• IdType trait: a trait that marks a type used for database identifiers
• the read-only/read-write transaction pattern (and create two SQLite connections: a read-only and a write-only)

Composition let you implement, hand pick and choose what you need when you need it.
It allows to build to thing that fits, in opposition to inheritance. Inheritance forces to predict the future.

The key is transmitted via the hash of the URL. Smart ! The rest is encrypted on the client side.

An example is provided with the crypto API, especially subtle.

A collection of resources such as guides, blog posts, advocacy, how to's

How to create a good project architecture? Here's a feedback.

Mann kann erst skalieren, dann optimieren, wenn es ein Drittels des Tages dauert. Der erste Prozess, um PDFs zu erzeugen, ist total innefizient. Es zeigt auch, dass Optimierungen der letzte Schritt des Produkts ist. Sie haben damit lange gelebt. Die Architektur ist eine gute Beispiel für horizontale Skalierung.

Parsing increases the information in the type system. A list can be of type NonEmpty, i.e. there is at least one element.

Use a data structure that makes illegal states unrepresentable.
Push the burden of proof upward as far as possible, but no further.

and awesome guidelines to follow.

So parse "data" and return the closest type instead of only validate them.

It states that every method should either be a command that performs an action, or a query that returns data to the caller, but not both.

More formally, methods should return a value only if they are referentially transparent and hence possess no side effects.

Even in single-threaded programs, it is sometimes arguably significantly more convenient to have a method that is a combined query and command. Martin Fowler cites the pop() method of a stack as an example.

Safari is using the web to create a desktop app in a very convenient way!

There’s a HTML file and a Service Worker that keeps it working offline

More about it on https://adactio.com/journal/20716

It explains the Writer monad and the Option monad.

This pattern is used for future or promise by the way.

A way to represent the either/or in JSON. Using enums that leads to empty objects. These empty objects can then be extended as needed.

Compilers are pipelines with a serie of step. Each step transform the input and provides data to the next.

Each step has then a contract with the input provided and its output 😃

The author goes in depth.

We can completely segment one component of the compiler from another by having the right form of data structure in between them. To build that data structure, you don’t need to know anything that happens to it afterwards, you just need to know what it means.