Question: I realise this is more of a general question, but I've read through similar answers on here but I can't find more of an overview. I'm new to callbacks and I'm trying to understand when they should be used.

The MDN web docs has this example;

```
function greeting(name) {
  alert('Hello ' + name);
}

function processUserInput(callback) {
  var name = prompt('Please enter your name.');
  callback(name);
}

processUserInput(greeting);

```

However I'm struggling to see how this is more beneficial than the following, where I'm not passing the greeting function as a parameter?

```
function greeting(name) {
  alert('Hello ' + name);
}

function processUserInput() {
  var name = prompt('Please enter your name.');
  greeting(name);
}

processUserInput();

```

Answer: 
In simple terms you can say a callback is a way of asking a question (or requesting a task) in advance, i.e. when you're done with this do this (usually with the result). The whole point is to set aside functions that are to be done later, usually because you don't have the required inputs to do them now. 
The 2 main differences between your implementation and the MDN one is that yours is harder to maintain and harder to reason about hence test. 

**1. Maintanance / Reusability**

Imagine you're a few thousand lines of code into a code base then you're required to change what processUserInput() does. Its much easier to change or write a new callback function instead of changing the function processUserInput(). This would be evident if processUserInput was a bit more complicated. This also means the MDN one is much more useful in various scenarios unlike your implementation. You can reuse it in different situations like saying good bye, capitalizing names etc simply by writing different callbacks to plug into processUserInput().

**2. Testing / Easier to reason about**

The MDN implementation is much more easier to understand. Its easier to assume that the function processUserInput(greeting) will probably return a greeting than it is to assume what processUserInput() does. This makes it easier to test because you can always be sure the MDN implementation will always return the same output given an input.
This example is not appropriate for understanding callbacks

In simple Language callbacks functions are used when we have to do some stuff **after** or in response of some other event or function or expression.
i.e when the parent function completes its execution then callback gets executed. 

simple Example

```
function hungerStatus(status,cb){
    return cb(status)
}
function whatToDo(status){
    return status ? "order Pizza" : "lets play"
}

hungerStatus(false,whatToDo)

```

Another example 

```
// global variable​
​var allUserData = [];
​
​// generic logStuff function that prints to console​
​function logStuff (userData) {
    if ( typeof userData === "string")
    {
        console.log(userData);
    }
    else if ( typeof userData === "object")
    {
        for (var item in userData) {
            console.log(item + ": " + userData[item]);
        }
​
    }
​
}
​
​// A function that takes two parameters, the last one a callback function​
​function getInput (options, callback) {
    allUserData.push (options);
    callback (options);
​
}
​
​// When we call the getInput function, we pass logStuff as a parameter.​
​// So logStuff will be the function that will called back (or executed) inside the getInput function​
getInput ({name:"Rich", speciality:"JavaScript"}, logStuff);

```

refer [callback exaplanation](http://javascriptissexy.com/understand-javascript-callback-functions-and-use-them/)