It would also seem that a callback is also used as an umbrella term for any function that is passed as an argument to another function that is used at some point or place inside the body of that outer function that is called. So there might be some overlap here with other terms that might come up such as higher order functions, and closures.
The basic idea of a call back is that it is a function that will fire at a later time. This allows for additional code to execute in the mean time. For example say I have a function that accepts two arguments one is a delay, and another is a function to fire once that delay has elapsed.
One of the most common examples of a callback in node.js examples might be with a method in the node.js file system module. Many of these methods have to do with reading or writing something to a local file system. These kinds of tasks can take a little time compared to doing something that involves just doing a little math. So one way or another it is necessary to define some code that will run which the task completes so that anything else that needs to happen is not put on pause while waiting for that to happen. So a callback is one way to go about doing that.
There are other ways of going about handling these kinds of situations such as with promises. When using callbacks all the time in more complex node.js projects this can quickly result in callback hell, a term which refers to situations in which there are many nesed callbacks.
Complex tasks like this can be done with the node.js file system module alone, but it often involves the use of more than one file system method each requiring a callback resulting in the so called callback hell.
There are ways of resolving this that involve the use of promises. In late versions of node.js (11.x) there is what is at the time of this writing experimental support for promises. For older versions of node.js there is npm packages like fs-extra that add promise support to the fs module.
However I do still find myself using closures all the time with many of my projects when it comes to defining a callback as just simply a function that is passed as an argument. Sure that is something that comes up all the time, and will continue to do so. Every time I use the Array.map prototype method or any similar method I pass a function as an argument to the map method that contains logic that is called for each element in an array that is used to create a new corresponding value for that array element. I work out option objects for arguments that take one or more properties that are functions that are used inside the body of the function that makes use of that said options object. So callbacks are hear to stay of course depending on how you go about what it is that you are labeling them I suppose.