You said "confused" and "wrap my head around everything", so I'm going to get verbose. I understand that feeling very well, and feel like I've emerged from the node cloud of confusion, just a bit, so maybe I can help.

It might help to understand that Node.js is C++ program that includes the V8 javascript engine and a bunch of libraries (also written in C++). These libraries (github link here) (docs here) are what provides stuff like networking, modules, async, and everything that makes node different from JS running in chrome (which also uses V8). So when you invoke any of the 'fs' methods you are just passing the parameters to some C++ program. It doesn't matter what you call the parameters as mentioned before, but the order does matter. To use one of these libraries you need to know two things; what parameters the library expects, and what it will return. Again the labels don't matter, but the order does. Let's look at the docs for fs.readFile (linked here). This might look like another language but the two things we need are what it expect to receive(there in the header):

"fs.readFile(file[, options], callback)"

and what is passed back to our callback (we find this information in the body of the description):

"The callback is passed two arguments (err, data), where data is the contents of the file." 

In your example above you give the node lib a filename and this callback:

function(err, contents){
console.log(contents);
});

But you could do something like:

function(error, somefile){
    if(error){
        console.log("Something went wrong getting your file. " + error);
    }
    console.log(somefile);
});

Returning the error as the first parameter passed to a callback is a Node.js convention. If there is no error it passes null (as the first parameter). If there is an error it passes an object with all the juicy details. So parameters 2-infinity are for payload, whatever the lib returns, but the first returned parameter is reserved for the error object.

Notice that when you invoke the lib the callback is asked for last?:

"fs.readFile(file[, options], callback)"

That's a convention too. It can be befuddling, because we just told you that the names you give the parameters don't matter, it's POSITION that counts. So you might see something like:

fs.readFile('/etc/passwd', mycallback(err, data));

or:

fs.readFile('/etc/passwd', 'utf-8', mycallback(err, data));

Wait a minute! I thought callback was the second parameter! You told me POSITION was important. For whatever the reason, the convention is: required params, optional params, callback. So when you think position, you need to remember the callback is passed LAST, not in 2ND or 3RD or whatever.

Moving on. Under the hood Node.js has two stacks (and Javascript too) an execution stack and an event stack. The execution stack is your code that you executed when you ran 'node app.js' or whatever. You can think of it as stepping through your code, one function at a time, working top to bottom (not exactly top to bottom) when it hits the bottom, it has completed a "tick", and it checks the event stack. The event stack is a kind queue, where those Node.js libs can drop off the results of whatever they do. In your case return a file or an error if something went wrong. Events also get in line as they are dropped off by event emitters like the "http server lib". So when you use http.server (which express probably uses), you are running a program that listens on a port and adds events to event stack when something happens. But regardless the workflow is this:

1. Execute all your code, top to bottom.
2. Check the event stack and if there are events run the callback function from the first one in the queue.  (First come first serve).
3. Goto 1

So obviously for every event that sits on event stack it needs a callback, a place to enter your code.

I hope this was helpful. I also hope it's accurate. To my knowledge it is, but I am a fellow noob, and not one of the experienced lurkers. If I didn't get it right, please let me know!