Lorenzofox's dev blog

When implementing business cases, you don't want to have to deal with database transactions, low-level telemetry and other technical details. In this series, we will build a small framework around dependency injection to make sure business and technical concerns are separated.

Switch buttons (and alike) are very popular UI widgets. Semantically, they should behave like regular buttons, but with a binary state. Let's see how we can progressively enhance the good old button with web components to get the expected behaviour.

In the previous article we built a template engine that supports streaming. Unfortunately, it did not perform very well when rendering a test page (a blog home page) compared to other popular libraries. In this article, we will look at several techniques that will lead us to a more efficient implementation.

Browsers can render HTML on the fly as chunks of text arrive. This is called HTML streaming, and it is not new. I recently read Chris Haynes' article explaining how you can stream HTML out of order (OOO) without JavaScript. This opens up a lot of possibilities and new patterns at low cost. However, I have not found much in the way of simple yet efficient template engine libraries with streaming support. Let's build one!

Our framework seems complete and well thought out. We went through the process of building on top of a solid foundation. This is how most software is written these days, but we suffered from the common bias and added unnecessary complexity. Here we will see how removing components can actually be better.

We have now at our disposal a way to turn coroutines into web components. We also have a set of higher order functions to manage how a component updates. It is great time to put these small bricks together in an expressive yet simple new UI Framework.

We have previously described a way of modelling custom elements as coroutines (generator functions). We then made sure that they could be updated efficiently. In this post, we will look at different patterns for controlling how (and when) the components are updated: these are what I call controllers.

In the previous article, we finished by providing a function to convert a generator into a custom element. In this post we will iterate by adding reactive attributes to our component definition, and ensuring that updates are performed in batch, using the hidden gem queueMicrotask.

In the previous article we learned what coroutines are and saw some patterns they can help implement. In this article, we will see how coroutines can be used to model web components in a different way, and why you might like it.

A coroutine is a function whose execution can be suspended and resumed, possibly passing some data. They happen to be useful for implementing various patterns involving cooperation between different tasks/functions such as asynchronous flows for example.