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

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

Answer: 
Boxed values are [data structures](http://en.wikipedia.org/wiki/Data_structure) that are minimal wrappers around [primitive types](http://en.wikipedia.org/wiki/Primitive_type)\*. Boxed values are typically stored as pointers to objects on [the heap](http://en.wikipedia.org/wiki/Dynamic_memory_allocation).

Thus, boxed values use more memory and take at minimum two memory lookups to access: once to get the pointer, and another to follow that pointer to the primitive. Obviously this isn't the kind of thing you want in your inner loops. On the other hand, boxed values typically play better with other types in the system. Since they are first-class data structures in the language, they have the expected metadata and structure that other data structures have.

In Java and Haskell generic collections can't contain unboxed values. Generic collections in .NET can hold unboxed values with no penalties. Where Java's generics are only used for compile-time type checking, .NET will [generate specific classes for each generic type instantiated at run time](http://msdn.microsoft.com/en-us/library/f4a6ta2h.aspx).

Java and Haskell have unboxed arrays, but they're distinctly less convenient than the other collections. However, when peak performance is needed it's worth a little inconvenience to avoid the overhead of boxing and unboxing.

\* For this discussion, a primitive value is any that can be stored on [the call stack](http://en.wikipedia.org/wiki/Call_stack), rather than stored as a pointer to a value on the heap. Frequently that's just the machine types (ints, floats, etc), structs, and sometimes static sized arrays. .NET-land calls them value types (as opposed to reference types). Java folks call them primitive types. Haskellions just call them unboxed.

\*\* I'm also focusing on Java, Haskell, and C# in this answer, because that's what I know. For what it's worth, Python, Ruby, and Javascript all have exclusively boxed values. This is also known as the "Everything is an object" approach\*\*\*. 

\*\*\* Caveat: A sufficiently advanced compiler / JIT can in some cases actually detect that a value which is semantically boxed when looking at the source, can safely be an unboxed value at runtime. In essence, thanks to brilliant language implementors your boxes are sometimes free.
The .NET FCL generic collections:

```
List<T>
Dictionary<TKey, UValue>
SortedDictionary<TKey, UValue>
Stack<T>
Queue<T>
LinkedList<T>

```

were all designed to overcome the performance issues of boxing and unboxing in previous collection implementations.

For more, see chapter 16, [*CLR via C# (2nd Edition)*](http://books.google.com/books?id=C-V_AAAACAAJ&dq=clr+via+c%23&ei=tyKnSPqSI5T2iQHzwJTECQ).