Question: I'm looking for a clear, concise and accurate answer. 

Ideally as the actual answer, although links to good explanations welcome.

Answer: 
Boxing & unboxing is the process of converting a primitive value into an object oriented wrapper class (boxing), or converting a value from an object oriented wrapper class back to the primitive value (unboxing).

For example, in java, you may need to convert an `int` value into an `Integer` (boxing) if you want to store it in a `Collection` because primitives can't be stored in a `Collection`, only objects. But when you want to get it back out of the `Collection` you may want to get the value as an `int` and not an `Integer` so you would unbox it.

Boxing and unboxing is not inherently *bad*, but it is a tradeoff. Depending on the language implementation, it can be slower and more memory intensive than just using primitives. However, it may also allow you to use higher level data structures and achieve greater flexibility in your code.

These days, it is most commonly discussed in the context of Java's (and other language's) "autoboxing/autounboxing" feature. Here is a [java centric explanation of autoboxing](http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html).
Like anything else, autoboxing can be problematic if not used carefully. The classic is to end up with a NullPointerException and not be able to track it down. Even with a debugger. Try this:

```
public class TestAutoboxNPE
{
    public static void main(String[] args)
    {
        Integer i = null;

        // .. do some other stuff and forget to initialise i

        i = addOne(i);           // Whoa! NPE!
    }

    public static int addOne(int i)
    {
        return i + 1;
    }
}

```