Question: I'm a bit new to Blender, and in trying to learn more, I've stumbled across nodes.

What are nodes, and how do I use them?

Answer: 
### Understanding of nodes

Nodes are a visual expression of mathematical operations.

The concept of nodes should help users to solve complex tasks by providing "packs" that transform inputs into outputs. In general, complex operations are splitted up into basic nodes to give the **most possible freedom to the user**. It's a kind of interface, which is flexible to work with and combines the best of both worlds (programming and use).

It's just a [visual programming language](https://en.wikipedia.org/wiki/Visual_programming_language), so in Blender it's useful for complex purposes like:

### Built-in

* Creating shaders for objects, world and line styles (Freestyle)
* Textures
* Image Compositing

### Add-ons

But the range of operations they are capable to do is it is not limited to the **built-in nodetree types**. There are add-ons that integrate other functions like:

* [Parametric Modeling](https://en.wikipedia.org/wiki/Solid_modeling#Parametric_modeling) via [Sverchok](https://github.com/nortikin/sverchok)

[![enter image description here](https://i.stack.imgur.com/6WWmy.png)](https://i.stack.imgur.com/6WWmy.png)

where you can use nodes to operate with vertex/edge/faces and also manage data lists (that gives you access ...to **everything!**).
* Node based animation via [Animation Nodes](https://github.com/JacquesLucke/animation_nodes)

[![enter image description here](https://i.stack.imgur.com/kg5U4.jpg)](https://i.stack.imgur.com/kg5U4.jpg)
*Image from <http://www.blendernation.com/2015/03/17/review-animation-nodes-addon/>*

### Node-based compositing

You are referring to [Composite Node tree](https://www.blender.org/manual/composite_nodes/introduction.html) type in your question. From [Wikipedia](https://en.wikipedia.org/wiki/Digital_compositing):

> 
> Node-based compositing represents an entire composite as a tree graph, linking media objects and effects in a procedural map, intuitively laying out the progression from source input to final output, and is in fact the way all compositing applications internally handle composites.
> 
> 
> 

Between the *starting inputs* (usually [Render layers](https://www.blender.org/manual/render/post_process/layers.html?highlight=render%20layers)) and the *final output* image you can add nodes to: 

* Tweak the brightness,
* Overlay images with alpha,
* Separate rgb channels,
* apply filters,
* **etc.**

Well, the list can be long and there are dozen of nodes, which can combined in infinite number of ways. The main advantage of image compositing in Blender is that it will **automatically run through the node's operations after rendering the 3d image**, so you'll not have to re-tweak the image manually *(as Photoshop's Adjustment levels, they are operation done "after" the base image, in a non destructive way).*
Nodes are a way to build materials and compositing setups in what some would call a more natural way (though this is just opinion, not everyone agrees). Instead of having a list of properties for a material, we can instead use nodes to visualise how properties are used, how information can be re-used and what processes are happening to values we input.

**Modularity**

Connections between a node mean information is being passed from one node to another. Each node has a specific job; for example, in the case of a 'Math' node it would be to perform some mathematical calculation to the data being passed to it. Because nodes are modular, even with a few basic nodes there will be hundreds of different ways to combine them to give different results.

We might have a bump map texture and want to reduce its effect (see image below). We can pass the 'Color' output of an image texture bump map to the 'Math' node and set it to 'multiply' the data it gets. Because it is multiplying by less than one, the output will be reduced. The data is then passed onto the next process via the 'Value' output on the right: 

[![enter image description here](https://i.stack.imgur.com/KjpMf.png)](https://i.stack.imgur.com/KjpMf.png)

**Data types**

The colour of the node inputs (the 2 grey circles on the left edge of the 'Math' node) is an indicator of the type of data it is and what type of data it expects. Grey inputs or outputs means a 'number' data type, yellow a 'colour', blue/purple a 'vector' and green a 'shader'. As a basic rule you generally stick to passing one colour/data type to the same data type (though as you can see from the image above, there are exceptions to this) and there are some nodes which convert from one type to another like the 'RGB to BW' node below which converts from colour to number:

[![enter image description here](https://i.stack.imgur.com/5kWc9.png)](https://i.stack.imgur.com/5kWc9.png)

**Re-using data**

You can also more easily re-use or link pieces of data. Below, I am able to use the same RGB colour and have its output connected to two different nodes, which might be difficult or impossible in a non-nodal interface:

[![enter image description here](https://i.stack.imgur.com/7nPc6.png)](https://i.stack.imgur.com/7nPc6.png)

Nodes are a very large topic, but this should give you an intro as to what they are.