Angular Signals English: Reactive Primitives Vocabulary

Introduction

Angular Signals represent the most significant shift in Angular’s reactivity model since the introduction of RxJS observables. If your team is upgrading to Angular 17 or later, you are navigating a new vocabulary alongside new APIs. The way engineers talk about signals in pull requests, stand-ups, and design reviews is specific and consistent. Learning this vocabulary will help you understand discussions about reactivity, change detection, and state management — and contribute to them confidently.

Signals, WritableSignals, and Reading Values

A signal in Angular is a reactive value — a value that notifies consumers when it changes. Engineers describe signals with a distinctive vocabulary:

• “We read the signal in the template” — accessing the signal’s value by calling it as a function
• “We write to the signal” — updating the value with .set() or .update()
• “The signal holds the count of unread messages” — describing what value the signal stores
• “We expose a read-only signal to the template” — using asReadonly() to prevent child components from modifying the value

A WritableSignal is a signal that components can modify. Engineers often distinguish: “We keep the writable signal private to the service and expose only the read-only version to consumers.” This pattern is frequently mentioned in architecture discussions about encapsulation.

The verb “notify” is important here. A signal “notifies” its dependents when its value changes. You will hear: “When the cart signal changes, all computed values that depend on it are automatically notified.”

Computed Signals

A computed signal derives its value from other signals. The key vocabulary:

• “We derive the total price as a computed signal” — computed(() => items().reduce(...))
• “Computed signals are lazy” — the value is only recalculated when it is read and a dependency has changed
• “The computation is memoised” — Angular caches the result and only re-runs when dependencies change
• “This computed depends on two signals” — the computed automatically tracks which signals it reads

In code reviews, you might see the comment: “This should be a computed signal rather than a property — it depends on reactive state and should update automatically.” The phrase “reactive state” signals (no pun intended) that a value is managed through the signals system.

Effects

An effect is a side-effect that runs when signals it reads change. The vocabulary around effects is careful because overuse is an anti-pattern:

• “We use an effect to sync signal state to localStorage” — a legitimate use case
• “Avoid writing to signals inside effects” — a common code review warning
• “The effect runs once initially, then reruns when dependencies change”
• “Clean up the effect in onDestroy” — effects need to be cleaned up to avoid memory leaks

Engineers frequently caution: “Effects are for synchronisation with external systems — not for deriving values. Use computed for derivations.” This phrase appears in team coding standards and design documents.

Change Detection Integration

One of the main reasons Angular adopted signals is to improve change detection performance. The vocabulary:

• zoneless — an Angular application that does not use Zone.js, relying on signals for change detection
• “Mark the component as OnPush” — a change detection strategy compatible with signals
• “Signal-based components” — components that use signals for all reactive state, enabling future zoneless operation
• “We eliminate unnecessary change detection cycles” — a common stated goal when migrating to signals

You might hear in a planning meeting: “By migrating our components to signals, we can eventually go zoneless and eliminate Zone.js entirely, which removes a significant source of overhead.”

Interoperability with RxJS

Many teams use signals alongside RxJS. Angular provides utilities for interoperability:

• toSignal — converts an Observable to a signal; “we wrap the HTTP observable in toSignal to use it in a computed”
• toObservable — converts a signal to an Observable; “we pipe the signal through toObservable to debounce it”
• “Bridge between signals and observables” — the general concept of using these utilities

Engineers say: “We use toSignal at the boundary — the HTTP layer stays observable-based, but the template consumes signals.”

Key Vocabulary

Term	Definition
signal	A reactive primitive that holds a value and notifies dependents on change
WritableSignal	A signal whose value can be updated with .set() or .update()
computed	A signal whose value is derived from other signals, lazily evaluated
effect	A side-effect function that reruns when its signal dependencies change
memoised	Cached and only recalculated when dependencies change
zoneless	An Angular app that removes Zone.js in favour of signals for change detection
toSignal	Utility to convert an RxJS Observable into a signal
toObservable	Utility to convert a signal into an RxJS Observable
notify	When a signal informs its dependents that its value has changed
asReadonly	Method that returns a read-only view of a WritableSignal

Practice Tips

1. Read Angular’s official RFC and design documents. The Angular team published detailed design documents for signals. Reading these in English exposes you to how the team frames trade-offs and explains reactive primitives.

2. Write migration notes in English. If you convert a component from BehaviorSubject to signals, write a short comment explaining the change: “Replaced the BehaviorSubject with a WritableSignal to simplify change detection and remove the manual subscription.”

3. Practise explaining computed vs effect. A common interview and code review question is when to use each. Practise this explanation: “Use computed when you want to derive a value from other signals. Use effect only for synchronising with external systems like localStorage or analytics.”

4. Use the word ‘reactive’ precisely. In Angular discussions, “reactive” has a specific meaning related to signals and observables. Avoid using it as a vague synonym for “dynamic” — instead, say “this value is managed as reactive state through a signal.”

Conclusion

Angular Signals bring a clear vocabulary — signal, computed, effect, WritableSignal, zoneless — that is rapidly becoming the standard way Angular teams discuss reactivity. As your team adopts signals, practising these terms in code comments, pull request descriptions, and design documents will help you communicate more precisely. The shift from observables to signals is as much a conceptual shift as a code change, and the vocabulary reflects that.