 Resources from Tomasz Ducin in 2024

Learn how the latest JavaScript features can help you improve your codebase. 

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Learn the Latest ECMAScript Features (ES2024, ES2023, ...)

Learn the fundamentals of React Query by going through the basic API and then implementing search in an employee tracking app.

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

Simplify State Management with React Query

You've seen that Angular signals are here, and know that signal-components are coming up.

This marks a paradigm-shift towards reactive programming in Angular.

Are you ready?

What if you could start learning signals and feel pleased with your progress? And reach a point where you feel confident when using signals in production?

And feel ready when signal-based components come?

Changes are coming, and you can get ahead of them.

By taking this cousre you will learn how to:

- Create computed signals
- Share your signals in services
- Use and cleanup signal effects
- Turn signals into observables and vice versa
- ... and more

In 52 minutes over the course of 20 bite-sized lessons, you'll learn everything you need to know to take advantage of signals now and be prepared for signal-based components!

Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

angular

Modernize State Management in Angular with Signals

Bite-size video tutorials for badass web developers.

egghead

Create a computed signal in modern Angular

Use reactive primitives in React and Angular

Signal values can be updated using the `set` or `update` methods. When updating signal values, it's crucial to follow immutable practices.

Key points to keep in mind:
* Use the `set` method for updating primitive values like strings or numbers
* Use the `update` method with a callback that returns a new object or array when updating complex values
* Avoid mutating signal values directly

Failure to follow immutable practices can result in stale data being displayed in the template.

Update an Angular Signal's Value and Make Computed Signal Emit Updates

Using Angular's `toSignal` function with the HTTP client enables components to reactively fetch and display data from external services. 

This approach simplifies code and handles undefined initial values, but note that `toSignal` immediately subscribes and makes the HTTP request when used. So, keep in mind if you're using it in a component or some root level service.

Fetch Data via HTTP Using RxJS Observables and toSignal

The `toSignal` function in Angular enables the conversion of an RxJS observable into a signal. 

It allows you to wrap an observable and handle the initial value of the resulting signal. You can explicitly define the initial value, require a synchronous emission from the observable, and more! 

Turn an RxJS Observable Into an Angular Signal With toSignal

Angular's `toObservable` function enables converting signals to RxJS observables. This allows creating observable properties that stay synchronized with signal values. 

Whenever the signal value changes, the corresponding observable emits a notification, facilitating the interoperability between signals and observables.

Turn an Angular Signal Into an RxJS Observable

In Angular, effects are often assigned to class properties during the constructor phase. However, there may be cases where the effect needs to be parameterized with values from parent components, which are not available during construction.

When running effects outside the constructor, such as in the `ngOnInit` lifecycle hook, you need to manually provide the `injector` instance to the `effect` configuration.

Bind an Angular Signal Effect to an Injector for Automatic Cleanup

Angular provides a `manualCleanup` configuration option for effects, preventing automatic cleanup when the owner component/service is destroyed. 

With `manualCleanup: true`, you gain control but must manually call `.destroy()` on the `EffectRef` that is returned by your `effect` to release resources like intervals or subscriptions. 

Remember, with great power comes great responsibility!

Destroy an Angular Signal Effect Automatically or Manually

Sometimes you will need to properly clean up your effects to prevent memory leaks. Like if you use timeouts or intervals. 

Implement cleanup logic using the `onCleanup` callback. In your effect you can call `onCleanup`, pass it a callback, and define actions like clearing intervals or unsubscribing from observables when effects are no longer needed. 

Set up an Angular Signal Effect Cleanup Handler

You may find that you need to implement similar effects across multiple components or services. To avoid code duplication, you can create reusable effect functions.

A reusable effect function should:

1. Accept any necessary configuration parameters (e.g., a key for local storage synchronization).
2. Accept a function that retrieves the reactive value(s) to track (e.g., a signal getter).
3. Set up and return the effect, using the provided configuration and reactive value getter.

Create a Reusable Angular Effect

Angular's reactive signals provide a way to manage state, but you may also want to persist that state across page refreshes or browser sessions. 

This can be achieved by synchronizing the signal's value with the browser's local storage using an `effect`

Synchronize Angular Signal or Computed Value With LocalStorage Using Effect

Angular's reactive signals provide a way to manage state and automatically update the view when the signal value changes. However, you can customize how Angular determines if a signal's value has changed by configuring the signal's `equal` property.

For example, you can use the `lodash.isEqual` function to perform a deep equality check, ignoring changes in object or array references if the contents remain the same. 

Make an Angular Signal Compare Object Values Instead of References

The `untracked` function in Angular allows you to read a signal's value without causing the effect or computed signal to re-evaluate when that signal changes.

Effects will only re-evaluate when tracked dependencies change.

`untracked` always accepts a callback function that returns the value of the underlying signal. Outside `untracked`, reading the signal is reactive, but inside `untracked`, the same read becomes non-reactive.

Read an Angular Signal Value While Being Untracked

The `effect` function in Angular runs a callback when a signal value it depends on changes. The callback is also invoked when the component first renders.

An `effect` can depend on multiple signals or computed signals. When any of these signals change, the `effect` callback executes.

Instead of running `effect` in the constructor, it's best to assign it to a component property. This allows for manual interaction with the `EffectRef` if needed.

Create an Angular Signal Effect

Moving a signal and related methods to an Angular service allows sharing between components. 

The service we create will expose a read-only property for the signal and methods to update it.

Share Angular Signal State Using Services

Read-only signals in Angular let you share values between components safely. They update automatically when the original signal changes. 

They can't be changed directly, like computed signals. And, they are useful in services.

Make an Angular Signal Readonly

Computed signals in Angular allow for the creation of derived values based on other signals, including other computed signals. This enables the composition of complex calculations and transformations by building upon existing signals.

When creating computed signals that depend on other computed signals, it's crucial to:
* Ensure that there are no cyclic dependencies, where two or more computed signals directly or indirectly depend on each other
* Consume the computed signal by a live consumer, such as a template, to trigger re-evaluation when dependencies change

Angular's reactivity system automatically detects and prevents cyclic dependencies in computed signals, throwing an error if such a scenario is encountered. 


Create an Angular Computed Signal on Top of Another Computed

Computed signals in Angular allow for the creation of derived values based on existing signals. By defining a new property and assigning it a computed signal, you can perform calculations or transformations on top of an existing signal's value.

To create a computed signal that remains responsive to changes in its dependencies, it's essential to:
* Define the computed signal's callback function, which calculates the derived value based on other signals
* Ensure that the computed signal is consumed by a live consumer, such as a template, to trigger re-evaluation when dependencies change

The reactivity flow in Angular ensures that whenever a dependency of a computed signal changes, the computed value is automatically re-evaluated. This re-evaluation only occurs if there is a live consumer, such as a template, that depends on the computed signal.



Topics

Instructors

Content Type

Tomasz Ducin