# Empty subscribes

I've seen a lot of frontend code recently and what bugs me are empty subscribes. If your framework is using `Observables` instead of `Promises`, subscribing is important. Yet, having empty subscribes is a code smell and should be avoided at all cost.

## Smelly code

```
// Using RxJs in my example :-)
someObservable.pipe(tap(value => this.doSomething(value))).subscribe();
```

This, in my opinion, is an example of poor code. The reason is that the call of the `subscribe` function is necessary. That is exactly the difference between `Observables` and `Promises`: your code is not executed until a subscriber is present. Without subscribers, no value goes through the value stream. This is crucial to how `Observables` work. Sadly enough, not everybody understands this. Some of us are just thrown in the codebase without introduction to any of the frameworks that the frameworks we use are built with.

To be blunt, if I didn't know how `Observables` worked and saw an empty subscribe function, **I would delete it**. Not because I want to break the code, but because there's no callback given. And so there's no callback to be executed, right? That's what my brain would think if I understood only part of it. 

While that might sound dumb, it's ignorant to think everybody understand everything. Also, I haven't witnessed any software project where time was invested in fully understanding the frameworks used once someone joins the project. Of course, you get some time to know your codebase. But do you get to know every aspect? Let me know in the comments, because that sounds like a dream project to me.

If you are not convinced by my argument, here's an interesting exercise. Go to your codebase and find an empty subscribe. Delete it and push your changes. Let's see how long it takes for your team members to find the location of this *bug* without looking at previous commits. My guess is it will take them quite some time.

## The solution

```
// using RxJs in my example again :-)
someObservable.subscribe(value => this.doSomething(value));
```

In my solution for the empty `subscribe` function, I just moved the code that was in the `tap` function to the `subscribe` function. There's a callback, so there's no way someone can remove this by accident. When dealing with empty subscribes, there is **always** something that can be moved to the `subscribe` function. 

## Conclusion

We looked at a code smell concerning `Observables` and *empty subscribes*. When no callback is given to the `subscribe` function, the `Observable` will work as planned but this might not be clear to everyone on the team. There is **always** something that can be put inside the `subscribe` callback. It's best to put it there to avoid misunderstandings and potential future bugs.