English for SolidJS Developers

SolidJS has attracted attention as a reactive UI framework that compiles away much of the overhead found in virtual-DOM-based libraries, but its reactivity model uses terminology that differs meaningfully from React or Vue. Developers moving to Solid, or explaining its performance benefits to a team evaluating frameworks, need precise English to describe concepts like signals and fine-grained updates without falling back on imprecise analogies. This guide walks through the vocabulary you’ll actually use in code reviews, RFCs, and technical interviews involving SolidJS.

Key Vocabulary

Signal — a reactive primitive that holds a value and automatically notifies any code that reads it whenever that value changes. “We wrapped the counter in a signal so the UI updates automatically whenever it changes.”

Fine-grained reactivity — an update model where only the specific DOM nodes that depend on changed data are updated, without re-rendering entire components. “Solid’s fine-grained reactivity means updating one row in a table doesn’t re-render the whole list.”

Derived value (computed) — a value calculated from one or more signals that automatically recalculates whenever its dependencies change. “The total price is a derived value that recomputes whenever the quantity signal updates.”

Effect — a function that runs automatically in response to changes in the signals it reads, typically used for side effects like logging or fetching data. “We used an effect to sync the signal’s value to local storage every time it changes.”

Store — a reactive object for managing structured, nested state, offering fine-grained tracking of individual properties rather than the whole object. “Instead of one big signal, we used a store so updating a single field doesn’t invalidate the entire object.”

JSX compilation — the process by which Solid’s compiler transforms JSX templates directly into efficient DOM-manipulation code at build time, rather than using a virtual DOM diff at runtime. “Because of JSX compilation, there’s no virtual DOM diffing step slowing things down at runtime.”

Reactive primitive — any of Solid’s core building blocks — signals, effects, and memos — used to construct reactive behaviour. “Once you understand the core reactive primitives, most of the rest of the API falls into place.”

Memo — a cached derived value that only recomputes when its underlying signals actually change, avoiding redundant recalculation. “We wrapped the expensive filtering logic in a memo so it doesn’t re-run on every unrelated re-render.”

Common Phrases

• “This component keeps re-rendering — did we forget to wrap that calculation in a memo?”
• “Solid doesn’t re-run the whole component function on updates, just the reactive parts that changed.”
• “Let’s move this into a store since we’re tracking several nested fields.”
• “That effect is firing more than expected — check which signals it’s actually reading.”
• “The compiler handles the DOM updates directly, so there’s no virtual DOM overhead here.”
• “We picked Solid partly for the smaller bundle size and partly for the fine-grained reactivity model.”

Example Sentences

When explaining SolidJS to a non-technical stakeholder: “Solid updates only the exact parts of the page that actually changed, instead of recalculating the whole screen, which makes the app feel noticeably faster.”

When filing a support ticket: “Our effect appears to run twice on initial load when wrapped around a derived signal inside a store. Is this expected behaviour, or a sign we’re tracking a dependency incorrectly?”

When discussing architecture in a team meeting: “I’d suggest we model the shopping cart as a store rather than individual signals, since we need fine-grained updates across several nested properties like item quantity and price.”

Professional Tips

• Say “component functions run once” when explaining Solid to React developers — it’s the single biggest mental model shift and worth stating explicitly to avoid confusion.
• Use “reactive dependency” rather than “variable” when discussing what triggers an effect or memo to rerun — it clarifies that the relationship is being tracked, not just referenced.
• When reporting a bug involving unexpected reruns, always mention whether the value in question is a signal, a memo, or a plain JavaScript variable, since only the first two are tracked.
• Clarify whether you mean the DOM update or the component function execution when describing performance — in Solid these are usually not the same event.

Practice Exercise

1. A React developer joins your team and asks why their SolidJS component only logs once instead of on every state change. Write two to three sentences explaining why in plain English.
2. Explain in one sentence the difference between a signal and a memo.
3. Draft a short code review comment suggesting a teammate convert several related signals into a single store.