"As you see from the implementation of #memoized this message returns a 
new block that only evaluates the original block if the single argument input 
was not yet processed (in this case the result was not yet cached in a dictionary).

So the 'outer memoized block' caches the results of previous evaluations of the
'original inner block' and is therefore faster when the blocks argument comes in
several times. 

To make it more transparent look here:"

"Using the cached version with #memoized"
|squareBlock memoizedBlock |
Transcript open.
squareBlock := [:x | Transcript show: 'We compute square only when necessary'. x * x  ].
memoizedBlock := squareBlock memoized.  "Returns a new outer block around the inner squareBlock. The outer block is caching results of the inner in a dictionary"
memoizedBlock value: 2.   "We call the outer memoized block with 2. The inner squeakBlock is evaluated first time for the input value 2. Result is cached in the memoizedBlock"
memoizedBlock value: 3.   "We call the outer memoized block with 3. The inner squeakBlock is evaluated second time with the input value 3. Result is cached in the memoizedBlock"
memoizedBlock value: 2.   "We call the outer memoized block with 2"


"=> The Transcript shows 'We compute square only when necessary' ONLY 2 TIMES INSTEAD OF 3 times as the result
      of the first computation is already known (and cached in the dictionary).
 
So if you do a heavy (performancewise costly) computation in a block,
but the result would be the same for the same block input (block argument)
then a memoized block (who caches previously calculated results) should
in most casesl perform better. "