At A Glance
Twenty years ago, Steve Jobs set forth an unlikely definition of developer productivity: the ability to achieve more by doing less.
Modern serverless architectures are the culmination of a series of efforts to shrink what developers and IT teams must manage.
When commodified work fades away, developers are able to deliver new functionality with differentiated business value much faster.
This piece looks at the history of application development and how emerging serverless approaches deliver on the productivity promise.
Twenty years ago, standing before a decidedly technical audience at Apple’s Worldwide Developers Conference, Steve Jobs turned his intense gaze to the floor the way he often would when considering the nuances of the tech industry. After a dramatic pause to reflect on what was clearly a grave matter, he offered:
“Here’s the deal. The way you get programmer productivity is not by increasing the lines of code per programmer per day. That doesn’t work. The way you get programmer productivity is by eliminating lines of code you have to write. The line of code that’s the fastest to write, that never breaks, that doesn’t need maintenance, is the line you never had to write.”
Long before Jobs made his appeal in 1997, the IT industry grappled with using abstraction to get more output from less input. The Unix philosophy centered around a modular set of tools that could be mixed and matched into efficient workflows. Object-oriented languages later went mainstream and reduced complexity by promoting code reuse and the disciplined componentization of software.
Jobs’ appeal to get to more by doing less is provocative — not just as the definition of productivity, but also as the reason for using technology in the first place. Serverless computing is the industry’s latest try. Fundamentally, the goal of serverless computing is to eliminate commodified work, like server maintenance, so IT teams can focus on what matters to the business. Serverless draws a sharp distinction between commodified IT — the mundane maintenance work that looks roughly the same at every company — and differentiated work that elevates IT to a direct provider of business value.
Shrinking the surface area
The surface area of responsibility that developers and IT professionals have to worry about has been shrinking deliberately over the past two decades. Having to deal with bare metal servers in on-prem data centers meant a lot of commodified work, from upgrading hardware to air conditioning the server room to physically securing the premises.
Outsourcing the management of bare metal servers to co-location centers greatly reduced the surface area IT had to manage, moving infrastructure out of sight (if not out of mind). This early move toward “serverless” computing illustrates the end-goal of cloud computing: to move IT away from undifferentiated work and toward value creation for the business.
Simplifying the environment: the move from physical to virtual
Whether the physical data center resided locally or remotely in a co-location center, IT was still tasked with mapping business applications to each physical server individually. This mapping process of provisioning servers and trying to forecast utilization levels was complex and plagued with uncertainty.
Virtual machines (VMs) simplified the operating environment and marked a pivotal step toward serverless computing. With VMs, IT could treat its physical servers as a pool of virtual resources to be shared across all the different applications and operating systems needed to support the business. As a result, IT could again reduce its commodified responsibilities to focus on delivering business value.
Complexity finds its way up the stack
While VMs attacked the complexities of managing server hardware, software complexity soon proved even more vexing for IT teams and developers. IT quickly became — and remains today — ensnared in a complex mix of software. Commercial vendor software, open-source, middleware, and custom integration projects all piled in to create a management and dependency nightmare for IT. VMs helped with the hardware piece, but they didn’t solve the problem of increasingly complex software stacks.
Containers simplify software
The emerging solution to this complexity lies with containers. Containers provide a logical boundary between developers who build applications and the IT teams that deploy them. With containers, a developer can package her application along with its software dependencies and run them anywhere — in the company’s on-prem data center, in a co-location center, in the public cloud, even on her personal laptop.
This encapsulation provided by containers is what allows both developers and IT teams to reduce scope and move faster. Developers building on top of containers are shielded from the deployment environment. Their applications are isolated from others, giving them the freedom to choose programming languages and tools without the fear of clashing with incompatible code. As a result, developers no longer need to waste time wondering what version of what software awaits their app once deployed — common debugging drudgery that can chew days and sometimes weeks out of a sprint. Meanwhile, IT can focus on deploying the containers into any desired environment. This separation of concerns allows both stakeholders to make environmental assumptions previously impossible, dramatically reducing complexity for both sides.
The way you get programmer productivity
This brief evolution reveals what it takes for teams to move fast: there must be a conscious effort to reduce the scope not only of what teams need to manage, but also what they even need to be aware of. Jobs’ appeal to shrink the surface area of what IT must manage is corroborated as we move “up the stack” toward serverless computing.
Beyond containers, a profound jump occurs for programmer productivity. Servers, infrastructure management, operating systems maintenance — anything that doesn’t directly relate to delivering new business functionality for stakeholders — gets completely abstracted away, leaving only value-additive activities.
With serverless computing, developers can finally reason in terms of what should happen rather than how to make it happen. Commodified work is delegated away, leaving only differentiated activities that provide value to the business. In software, this amounts to:
The end-user experience
Domain or business logic specific to the app
Data manipulated by the app
By focusing on these three pieces, programmers can add business value, faster.
Approaching business value: Apps & Functions
Within the serverless part of the compute spectrum, two approaches allow developers to focus on what matters: Apps (Platform as a Service) and Functions.
In the Apps rung of the compute spectrum, a developer reasons at the level of an individual application, completely offloading infrastructure and deployment concerns like scaling the app up and down to handle demand, configuring the runtime environment, load balancing traffic, health-checking the application, patching and maintaining the underlying OS — in other words, commodified work.
The Functions rung of the compute spectrum takes serverless computing to the logical extreme. A developer reasons not at the level of a monolithic application but at the level of a single piece of logic: Process a credit card. Resize an image thumbnail. Look up an employee’s org number. Send a text message. Validate a registration form. Transform data read from an IoT sensor. Each bite-sized piece of logic can be finely provisioned down to 100ms (1/10 of one second) with billing accrued only while the snippet of code is actually running.
Millions of these small snippets, or functions, can be spun up in parallel, triggered by any event of interest in the cloud. As this occurs, the developer is completely unaware of the underlying infrastructure that makes this fine-grained provisioning, billing, and massively distributed computing possible. Customers, employees, and partners see only the tip of the iceberg that matters: new business functionality continuously delivered and iterated upon as needs change.
Toward an era of productivity
Serverless computing is the modern conclusion to Steve Jobs’ appeal to achieve more by doing less. While abstraction and modular design are not new, what is new today is the near-instantaneous speed at which new business functionality can be built and provisioned in the cloud.
The cloud revolution has always been about serving users more nimbly, masking IT complexity as companies begin to serve their stakeholders at the speed and scale of the web. Beyond the compute spectrum, serverless is a design approach that extends to data management, DevOps, and the growing ecosystem of services in the cloud being made available to businesses. These extensions of serverless principles create a flywheel of productivity across the industry. The goal is to continue to shrink the surface area of responsibility that developers and IT must manage. This is the way you get programmer productivity: by focusing on what matters and by doing less.