that may be repartitioned over time as
the application grows. Design patterns
support sending messages between
these repartitionable pieces of data.
The goal here is to reduce the chal-
lenges faced by people handcrafting
very large scalable applications. Also,
by observing these design patterns,
the industry can perhaps work toward
the creation of platforms to make it
easier to develop scalable applica-
tions. Finally, while this article targets
scalable homogeneous applications,
these techniques are also very use-
ful for supporting scalable heteroge-
neous applications such as support
for mobile devices.
This article focuses on how an application developer can build a successful scalable enterprise application
when he or she has only a local database or transaction system available.
Availability is not addressed, merely
scale and correctness.
Discuss scalable applications.
Most designers of scalable applications understand the business requirements. The problem is that the
issues, concepts, and abstractions for
the interaction of transactions and
scalable systems have no names and
are not crisply understood. They are
inconsistently applied and sometimes
come back to bite the designers. One
goal of this article is to launch a discussion that can increase awareness
of these concepts, leading toward a
common set of terms and an agreed-upon approach to scalable programs.
Think about almost-infinite scal-
ing of applications. The article pres-
ents an informal thought experiment
on the impact of almost-infinite
scaling. Let’s assume the number
of customers, purchasable entities,
orders, shipments, healthcare pa-
tients, taxpayers, bank accounts, and
all other business concepts manipu-
lated by the app grows significantly
over time. Typically, each individual
thing doesn’t get much larger; there
are simply more and more of them. It
really doesn’t matter if CPU, DRAM,
storage, or some other resource gets
saturated first. At some point, the in-
crease in demand leads to spreading
what used to run on a single machine
over a larger number of machines.
This thought experiment makes us
consider tens or hundreds of thou-
sands of machines.
Almost-infinite scaling is a loose,
imprecise, and deliberately amorphous way of motivating the need to
be very clear about when and where
you can know something fits on one
machine and what to do if you cannot
ensure it fits on one machine. Furthermore, you want to scale almost linearly
with the data and computation load. Of
course, scaling at an N-log-N pace with
a big log would be great.
Describe a few common patterns for
scalable apps. What are the impacts of
almost-infinite scaling on the business
logic? I am asserting that scaling im-