Numbers everyone should know

Numbers everyone should know from Jeff Dean's talk at Stanford:

L1 cache reference 0.5 ns
Branch mispredict 5 ns
L2 cache reference 7 ns
Mutex lock/unlock 100 ns
Main memory reference 100 ns
Compress 1K bytes with Zippy 10,000 ns
Send 2K bytes over 1 Gbps network 20,000 ns [.02 ms]
Read 1 MB sequentially from memory 250,000 ns
Round trip within same datacenter 500,000 ns
Disk seek 10,000,000 ns
Read 1 MB sequentially from network 10,000,000 ns [10 ms]
Read 1 MB sequentially from disk 30,000,000 ns
Send packet CA to Netherlands to CA 150,000,000 ns

From Cuong Do's Youtube Scalability talk:

Page rendering time: keep less than 100 ms

There are also some interesting number on Wikipedia's Google platform page.

The Computer Revolution Hasn't Happened Yet

Notes of Alan Kay's 1997 OOPSLA talk via Lambda-the-Ultimate.

Alan Kay On OOP

As things become more and more complex,
the architecture will dominate material.

Learning is an act of creation.
Something happens to you that
wasn't there before.

When encountering a creative, novel idea.
Reaction by the user.
Metaphor

Joke -- ha ha.
Science -- Aha!
Art -- ahhh...

You need to have something
blue, to have blue thoughts.

23:00
HTML pre-supposes that there
should be a browser that should
understand its format.
(worst ideas since ms-dos!)
+ He is talking about executable
programs? Like lisp images.
You should read it in. It should
travel with the things it needs.

Why study of Biology is interesting?
Build a dog house. Now build something
similar, but 100 times larger.
Propotions will be unwieldly and
the thing collapes.
Not so for cells.
They can even grow by factors
of 1 millions. And so how do
they do this is important?
Because we want to build
complex computer systems --
which we haven't been able
to do.

39:00
Object can act as anything.
So they encapsulate a computer.
Useful: take a powerful thing
and not lose it but partitioning
it up.
[Java, C++ think that they are helping
the programmer by making this new
thing (oop) look like the old thing,
but they are hurting the programmer,
but making it difficult for the programmer
to understand what's really powerful
about this metaphor.]

45:00
Building Complex Systems.

59:00 We still don't know how to design,
build systems.

Let's not make what we don't know
into a religion!

We need to constantly think, think and
think about what's important.
And we have to our systems let us get
to the next levels of abstractions
as we come to them. (Earlier he
was talking about how there were
many different implementation of
Smalltalk when at Xerox. The old
implementation were good at bootstrapping
new implementations -- these new
implementations were built to support
the new abstractions Alan and his
collegues came to know about. And I
guess the dynamicsm of Smalltalk made
this possible.)

Squeak -- not an attempt to give the world
a free Smalltalk -- but an attempt to give
the world a bootstrapping mechanism much
better that smalltalk. SO when you play
with squeak -- think of how you can
obselete the damn thing!

Look for blue thoughts.
Play your system grand than what they
seem to be right now.