For thirty years
there was a rescue plan,
and nobody had to write it down.
Ship it slow.
Wait eighteen months.
The machines got faster,
and your code got faster with them,
for free,
without anyone touching it.
A generation learned to build
inside that promise.
Clarity before speed,
which was right.
Do not optimise early,
which was also right.
And underneath both,
an assumption nobody stated:
if it is too slow this year
it will be fine by next year.
That part quit.
Single core speed flattened out
more than a decade ago.
The cores multiplied instead,
which helps only the code
that was written to use them,
and most code was not.
So the free ride ended,
and the bill did not.
It changed shape.
Inefficiency is not paid now
in a slow desktop
that somebody replaces.
It is paid every month,
in instances rented by the hour,
in a function invoked
ninety million times,
in bandwidth,
in the battery of a phone
belonging to someone
who will uninstall you over it.
Waste used to be a moment.
Now it is a subscription.
And the newest layer
we have all started building on
is the most expensive per unit of work
that computing has had in years.
A sloppy loop was cheap.
A sloppy call to a model,
inside a loop,
inside a request path,
has a price per thousand
and a queue behind it.
None of this means
go and hand tune everything.
That advice was wrong before
and it is wrong now.
It means a thing
that has been optional
for most of a career
is moving back to the middle of the job.
Knowing what your code costs.
Being able to measure it
before someone in finance does.
Understanding what actually happens
one layer below
the abstraction you picked,
at least one layer.
That skill went quiet
because the hardware covered for us.
The hardware has stopped covering for us.
It is about to be worth money again.
– Serguey Asael Shinder
