From 5bc33a038af959738acf7d8a0eb98f5b411a4ec6 Mon Sep 17 00:00:00 2001
From: Greg Johnston <greg.johnston@gmail.com>
Date: Thu, 13 Oct 2022 16:23:44 -0400
Subject: [PATCH] Update README.md

---
 README.md | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/README.md b/README.md
index 35d282850..82424c718 100644
--- a/README.md
+++ b/README.md
@@ -60,3 +60,34 @@ Here are some resources for learning more about Leptos:
 - [Examples](https://github.com/gbj/leptos/tree/main/examples)
 - [API Documentation](https://docs.rs/leptos/latest/leptos/) (in progress)
 - Leptos Guide (in progress)
+
+## FAQs
+
+### How is this different from Yew?
+On the surface level, these two libraries may seem similar. Yew is, of course, the most mature Rust library for web UI development and has a huge ecosystem. Here are some conceptual differences:
+- **VDOM vs. fine-grained:** Yew is built on the virtual DOM (VDOM) model: state changes cause components to re-render, generating a new virtual DOM tree. Yew diffs this against the previous VDOM, and applies those patches to the actual DOM. Component functions rerun whenever state changes. Leptos takes an entirely different approach. Components run once, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
+- **Performance:** This has huge performance implications: Leptos is simply *much* faster at both creating and updating the UI than Yew is.
+- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising components re-renders because there are no re-renders. Your app can be divided into components based on what makes sense for your app, because they have no performance implications.
+
+### How is this different from Sycamore?
+Conceptually, these two frameworks are very similar: because both are built on fine-grained reactivity, most apps will end up looking very similar between the two, and Sycamore or Leptos apps will both look a lot like SolidJS apps, in the same way that Yew or Dioxus can look a lot like React.
+
+There are some practical differences that make a significant difference:
+- **Maturity:** Sycamore is obviously a much more mature and stable library with a larger ecosystem.
+- **Templating:** Leptos uses a JSX-like template format (built on [syn-rsx](https://github.com/stoically/syn-rsx)) for its `view` macro. Sycamore offers the choice of its own templating DSL or a builder syntax.
+- **Template node cloning:** Leptos's `view` macro compiles to a static HTML string and a set of instructions of how to assign its reactive values. This means that at runtime, Leptos can clone a `<template>` node rather than calling `document.createElement()` to create DOM nodes. This is a *significantly* faster way of rendering components.
+- **Read-write segregation:** Leptos, like Sycamore, enforces read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);`
+- **Signals are functions:** In Leptos, you can call a signal to access it rather than calling a specific method (so, `count()` instead of `count.get()`) This creates a more consistent mental model: accessing a reactive value is always a matter of calling a function. For example:
+```rust
+let (count, set_count) = create_signal(cx, 0); // a signal
+let double_count = move || count() * 2; // a derived signal
+let memoized_count = create_memo(cx, move |_| count() * 3); // a memo
+// all are accessed by calling them
+assert_eq!(count(), 0);
+assert_eq!(double_count(), 0);
+assert_eq!(memoized_count(), 0);
+
+// this function can accept any of those signals
+fn do_work_on_signal(my_signal: impl Fn() -> i32) { ... }
+```
+- **Signals and scopes are `'static`:** Both Leptos and Sycamore ease the pain of moving signals in closures (in particular, event listeners) by making them `Copy`, to avoid the `{ let count = count.clone(); move |_| ... }` that's very familiar in Rust UI code. Sycamore does this by using bump allocation to tie the lifetimes of its signals to its scopes: since references are `Copy`, `&'a Signal<T>` can be moved into a closure. Leptos does this by using arena allocation and passing around indices: types like `ReadSignal<T>`, `WriteSignal<T>`, and `Memo<T>` are actually wrapper for indices into an arena. This means that both scopes and signals are both `Copy` and `'static` in Leptos, which means that they can be moved easily into closures without adding lifetime complexity.