In RxJS, a popular library for reactive programming, observables can be categorized into two types: cold observables and hot observables. The key difference between these two types lies in how they handle the emission and subscription of values. 1. Cold Observables: A cold observable starts emitting values when a subscription is made. Each subscription to a cold observable triggers a separate execution of the observable's logic. In other words, the data stream is independent for each subscriber, and each subscriber receives the full sequence of emitted values from the beginning. For example: 

import { Observable } from 'rxjs';

const coldObservable = new Observable(observer => {
  console.log('Observable logic');
  observer.next(1);
  observer.next(2);
  observer.next(3);
});

coldObservable.subscribe(value => console.log('Subscriber 1:', value));
coldObservable.subscribe(value => console.log('Subscriber 2:', value));
Output: 

Observable logic
Subscriber 1: 1
Subscriber 1: 2
Subscriber 1: 3
Observable logic
Subscriber 2: 1
Subscriber 2: 2
Subscriber 2: 3
In the example above, each subscriber triggers the execution of the observable logic separately, and both subscribers receive the complete sequence of emitted values. 2. Hot Observables: A hot observable, on the other hand, emits values regardless of subscriptions. It starts emitting values immediately upon creation, and subscribers receive only values emitted after they subscribe. The data stream is shared among subscribers, and late subscribers may miss previously emitted values. For example: 

import { Subject } from 'rxjs';

const hotObservable = new Subject<number>();

hotObservable.next(1);
hotObservable.next(2);
hotObservable.next(3);

hotObservable.subscribe(value => console.log('Subscriber 1:', value));

hotObservable.next(4);
hotObservable.next(5);

hotObservable.subscribe(value => console.log('Subscriber 2:', value));

hotObservable.next(6);
hotObservable.next(7);
</number>
Output: 


Subscriber 1: 4
Subscriber 1: 5
Subscriber 1: 6
Subscriber 1: 7
Subscriber 2: 6
Subscriber 2: 7
In the example above, the hot observable starts emitting values immediately. Subscriber 1 subscribes after the first three values have been emitted and receives subsequent values. Subscriber 2 subscribes later and only receives values emitted after its subscription. Hot observables are commonly used for events or continuous data streams, where the values are being produced independently of subscriptions. In summary, the main difference between cold observables and hot observables is that cold observables start emitting values upon subscription and each subscription triggers a separate execution, while hot observables emit values regardless of subscriptions and late subscribers may miss previously emitted values.