  Serverless computing (also known as functions as a service) is a new cloud
computing abstraction that makes it easier to write robust, large-scale web
services. In serverless computing, programmers write what are called serverless
functions, and the cloud platform transparently manages the operating system,
resource allocation, load-balancing, and fault tolerance. When demand for the
service spikes, the platform automatically allocates additional hardware to the
service and manages load-balancing; when demand falls, the platform silently
deallocates idle resources; and when the platform detects a failure, it
transparently retries affected requests. In 2014, Amazon Web Services
introduced the first serverless platform, AWS Lambda, and similar abstractions
are now available on all major cloud computing platforms.
  Unfortunately, the serverless computing abstraction exposes several low-level
operational details that make it hard for programmers to write and reason about
their code. This paper sheds light on this problem by presenting
$\lambda_\Lambda$, an operational semantics of the essence of serverless
computing. Despite being a small (half a page) core calculus, $\lambda_\Lambda$
models all the low-level details that serverless functions can observe. To show
that $\lambda_\Lambda$ is useful, we present three applications. First, to ease
reasoning about code, we present a simplified naive semantics of serverless
execution and precisely characterize when the naive semantics and
$\lambda_\Lambda$ coincide. Second, we augment $\lambda_\Lambda$ with a
key-value store to allow reasoning about stateful serverless functions. Third,
since a handful of serverless platforms support serverless function
composition, we show how to extend $\lambda_\Lambda$ with a composition
language. We have implemented this composition language and show that it
outperforms prior work.
