What is the difference between \let and \edef?

\edef expands the argument, whereas \let doesn't. Here is an example to illustrate the difference:

\def\txt{a}
\def\foo{\txt}
\let\bar\foo
\bar -> a
\def\txt{b}
\bar -> b

However,

\def\txt{a}
\def\foo{\txt}
\edef\bar{\foo}
\bar -> a
\def\txt{b}
\bar -> a

There are also other differences, say, the arguments and so on. But how to expansion may be the most important(?).

This is an interesting question. May I expand the question further more?

What is the difference between \let and \expandafter\def\expandafter\foo\expandafter ? Do they always behave the same?

\def\txt{bar}
\def\foo{\txt}
\expandafter\def\expandafter\bar\expandafter{\foo}
\let\BAR\foo

{\tt \string\bar = \meaning\bar}\par
{\tt \string\BAR = \meaning\bar}

Sneaky inline answer to this rhetorical question, since I wrote the original question :)

If you are doing this on macros that take no arguments, then the difference between them is negligible. OTOH, you cannot use the \expandafter\def... construct if you're trying to copy the definition of a macro that takes arguments.

In fact, this brings to light one of the aspects that I was hoping people would discuss here. \let creates a literal copy of a macro at the instant that it is executed, whereas \edef will take the contents of the macro and expand it recursively to create a new macro entirely. When you are only using the macros as places to store data (such as \def\name{Will}) then the differences are largely inconsequential, but when the macros are being used as ‘functions’ that take arguments or have contents that have various expansion restrictions applied to it (with \protected, \noexpand, and so on) then the differences can be very important indeed.

As already has been said \edef expands its argument. This not only mean that the content will be different to a definition with \let, it also means that the argument must be expandable. You can always do a \let\a\b but e.g. \edef\a{\tableofcontents} will break. Also \edef expands its argument, it doesn't execute them. So things like this will not work:

\def\my{\def\myinner{c}} 
\edef\test{\my}

The main difference is that \let creates a new reference (a.k.a. name) to an existing value while \def (and friends) creates a completely new value and name pair. If you can get yourself to think of names and values as separate things, then the difference between the two primitives is fairly easy to understand (in my opinion).