Welcome

Serverless Computing (Serverless) is emerging as a new and compelling paradigm for the deployment of cloud applications, and is enabled by the recent shift of enterprise application architectures to containers and micro services. Many of the major cloud vendors, have released serverless platforms within the last two years, including Amazon Lambda, Google Cloud Functions, Microsoft Azure Functions, IBM Cloud Functions. There is, however, little attention from the research community. This workshop brings together researchers and practitioners to discuss their experiences and thoughts on future directions.

Serverless architectures offer different tradeoffs in terms of control, cost, and flexibility. For example, this requires developers to more carefully consider the resources used by their code (time to execute, memory used, etc.) when modularizing their applications. This is in contrast to concerns around latency, scalability, and elasticity, which is where significant development effort has traditionally been spent when building cloud services. In addition, tools and techniques to monitor and debug applications aren't applicable in serverless architectures, and new approaches are needed. As well, test and development pipelines may need to be adapted. Another decision that developers face are the appropriateness of the serverless ecosystem to their application requirements. A rich ecosystem of services built into the platform is typically easier to compose and would offer better performance. However, composing external services may be unavoidable, and in such cases, many of the benefits of serverless disappear, including performance and availability guarantees. This presents an important research challenge, and it is not clear how existing results and best practices, such as workflow composition research, can be applied to composition in a serverless environment.

Introduction

Please post questions Google doc (anybody should be able to edit) and discuss in #wosc3 slack channel (to get invite open wosc-tutorial-invite dot mybluemix.net then open slack server https://future-compute.slack.com and join #wosc3 channel)

Invited speakers

Serverless: Where Have We Come? Where Are We Going?

Abstract: Since Amazon Lambda arrived in November 2014, serverless technologies have taken the industry by storm,
ascending quickly towards the summit of the hype cycle. As we approach the summit, let's look
at where we've come with serverless technology so far, in the context of larger industry trends.
Then, let's discuss how the technology might evolve, identifying the most promising
directions to help drive serverless into the mainstream.

How Microservices and Serverless Computing Enable the Next Generation of Machine Intelligence

Abstract: We'll discuss why AI and machine learning are a natural fit for serverless computing and a general architecture for scalable and serverless machine learning in production. We'll discuss issues encountered during implementing our own on-demand scaling over GPU clusters, show how these apply to more general solutions, and present one possible vision for the future of cloud-based machine learning.

NumPyWren: Storage-enabled Scaling of Serverless Supercomputing

Eric Jonas, UC Berkeley EECS and RISELab

Abstract: The rise of serverless platforms has enabled transparent massive-scale parallelism via platforms such as PyWren. But PyWren is optimized for tasks that are embarrassingly parallel. Traditional supercomputing tasks, such as dense, large-scale linear algebra, are often thought to be dominated by inter-node communication performance. Here we will present NumPyWren, a platform for scalable large-scale dense linear algebra (analogous to packages such as SCALAPACK), which uses high-latency high-throughput scalable object storage (like S3) as its only means of communication. NumPyWren takes simple numpy-like expressions and compiles them to an intermediate representation and then transparently executes them entirely via stateless cloud functions, achieving performance comparable with MPI-based solutions while being much more compute (and thus cost)-efficient. We will discuss ongoing work to support a larger collection of mathematical primitives, how this fits into the larger PyWren project, and more.
Joint work with Vaishaal Shankar, Karl Krauth, Qifan Pu, Jonathan Regan-Kelly, Ion Stoica, Ben Recht, and Shivaram Ventkataraman

Bio: Eric Jonas is currently a postdoctoral scientist in computer science at UC Berkeley working with Ben Recht on machine learning for accelerating scientific discovery. He earned his PhD in Computational Neuroscience, M. Eng in Electrical Engineering, BS in Electrical Engineering and Computer Science, and BS in Neurobiology, all from MIT. Prior to his return to academia, he was founder and CEO of Prior Knowledge, a predictive database company which was acquired in 2012 by Salesforce.com, where he was Chief Predictive Scientist until 2014. In 2015 he was named one of the top rising stars in bioengineering by the Defense Department’s Advanced Research Projects Agency (DARPA).

Conquering serverless: Solutions For Organizations

Chase Douglas, Co-founder and CTO of Stackery.io

Abstract: You get serverless. Your team gets serverless. But does your organization get serverless?
You know a serverless architecture is the right solution for a project, but your VP of Engineering is pushing back. They are probably doing this because it's not obvious how a serverless architecture will fit into the organization's existing development, testing, and release processes. Their intuition that new techniques are needed to effectively maintain and extend serverless architectures is spot-on. But they can be convinced serverless is the right approach if you show them successful patterns.
With patterns and examples from this talk, you will be able to convince everyone in your organization that serverless architectures are not only easier to build, but are also easier to maintain through the entire development life-cycle.

Bio: Chase Douglas is the co-founder and CTO of Stackery.io, which helps enterprises standardize their development of serverless applications. His experience spans the gamut of technical and managerial, specifically focused on how teams of developers build products collaboratively. In prior roles he has been a VP of engineering at a web application security company, technical architect of the New Relic Browser product, and an architect of the multitouch implementation for the Linux desktop.

Building and Teaching a Complete Serverless Solution

Abstract: There are many definitions for and interpretations of the term "serverless computing." This presentation provides an architecture overview and delves into architecture
details for a complete serverless application that a small startup has been developing since 2015. The presentation will cover Function-as-a-Service, security, data access
and management, orchestration and workflow, content delivery and other topics. The complete application exploits approximately 25 core cloud services and environments.
The presentation will discuss a set of best practices that have emerged and cover lessons learned. We will also discuss technical and research challenges and opportunities.
The solution forms the basis for a course at the Dept. of Computer Science at Columbia University. We will also cover issues and topics that have emerged in educating
seniors and masters on how to build a simplified version of the application.

Bio: Donald Ferguson is the first professor of professional practice in the Dept. of Computer Science at Columbia University. Don joined academia after 35 year in the IT industry. Don earned Ph.D. in Computer Science at Columbia in 1989 and subsequently work at IBM for 20 years. IBM appointed Don an IBM Fellow in 1981. Don has also been a Microsoft Technical Fellow, CTO for CA Technologies and Senior Technical Fellow at Dell. Don is co-founder and CTO for Seeka TV, a startup developing solutions in web series delivery and online content management. Most of Don's technical contributions and leadership have been in the areas of distributed systems, web applications and web services, application development technology and transaction/data management.
Don is the proud father of two wonderful young adults. Hobbies include Kenpo karate, road bicycling and astronomy. Don is an officer in the NY Guard, part of the Division of Military and Naval Affairs for the State of New York.

Challenges for Serverless Native Cloud Applications

Ben Kehoe, Cloud Robotics Research Scientist iRobot

Abstract: Serverless computing, including the use of ephemeral compute like Functions as a Service (FaaS) and 3rd party managed services in preference to self-hosted solutions, has the power to reduce development effort, increase application robustness, and decrease operating expenses. While today it is common to use serverless architecture as part of a broader application that uses traditional architecture, "serverless native" applications already exist, and will become increasingly common in the future. iRobot supports its fleet of cloud-connected robots with an entirely serverless architecture, which has involved an extensive learning and exploration process. This talk will review the challenge of serverless native applications, including development, operations, and security.

Bio: Ben Kehoe is a Cloud Robotics Research Scientist at iRobot, and uses the internet to enable robots to do more and better things. He completed his PhD in December 2014 at UC Berkeley, with a dissertation on cloud-based robot grasping. His interests include the Internet of Things, the Connected Home, scalable, developer-friendly cloud architecture, and stamping out the scourge of servers.

Paper abstracts

Evaluation of Production Serverless Computing Environments

Abstract:
Serverless computing provides a small runtime container to execute lines of codes without a management of infrastructure which is similar to Platform as a Service but a functional level. Amazon started the event-driven compute named Lambda functions in 2014 with a 25 concurrent limitation but it now supports at least a thousand of concurrent invocation to process event messages generated by resources like databases, storage and system logs. Other providers i.e. Google, Microsoft and IBM offer a dynamic scaling manager to handle parallel requests of stateless functions in which additional containers are provisioning on new compute nodes for distribution. However, while functions are often developed for microservices and lightweight workload, they are associated with distributed data processing using the concurrent invocations. We claim that the current serverless computing environments are able to support dynamic applications in parallel when a partitioned task is executable on a small function instance. We present results of throughput, network bandwidth, a file I/O and compute performance regarding to the concurrent invocations. We deployed a series of functions for large distributed data processing to address the elasticity and scalability and then demonstrate the differences between serverless computing and virtual machines for cost efficiency and resource utilization.

Serverless Data Analytics with Flint

Presenter: Youngbin Kim

Youngbin Kim and Jimmy Lin, University of Waterloo, Canada

Abstract:
Serverless architectures organized around loosely-coupled function
invocations represent an emerging design for many applications.
Recent work mostly focuses on user-facing products and
event-driven processing pipelines. In this paper, we explore
a completely different part of the application space and examine the
feasibility of analytical processing on big data using a serverless
architecture. We present Flint, a prototype Spark execution engine
that takes advantage of AWS Lambda to provide a pure pay-as-you-go
cost model. With Flint, a developer uses PySpark exactly as before,
but without needing an actual Spark cluster.
We describe the design, implementation,
and performance of Flint, along with the challenges associated with
serverless analytics.

Making Serverless Computing More Serverless

Abstract:
In serverless computing, developers define a function
to handle an event, and the serverless framework horizontally scales the
application as needed. The downside of this function-based abstraction is it
limits the type of application supported and
places a bound on the function to be within the physical resource limitations of
the server the function executes on.
In this paper we propose a new abstraction for serverless computing. We propose a developer
supplies a process and the serverless framework seamlessly scale out its resource usage across the datacenter.
This abstraction enables processing to not only be
more general purpose, but also break out of the
limitations of a single server -- making serverless computing more serverless.
To realize this abstraction, we propose ServerlessOS,
comprised of three key components: (i) a new disaggregation model, which leverages disaggregation for abstraction,
but enables resources to move fluidly between servers for performance;
(ii) a cloud orchestration layer which manages fine-grained resource allocation and placement throughout
the application's lifetime via local and global decision making; and
(iii) an isolation capability that enforces data and resource isolation across disaggregation, effectively
extending Linux cgroup functionality to span servers.

Challenges for Scheduling Scientific Workflows on Cloud Functions

Abstract:
Serverless computing model, also known as Function-as-a-Service (FaaS) or Cloud Functions, is a new method of running distributed applications by executing functions on the infrastructure of cloud providers. Although it frees the developers from configuring and maintaining servers, there are still decisions to make regarding selection of function based on the performance and cost. The billing model of this approach considers time of execution, measured in 100ms units, as well as size of the memory allocated per function. In the talk we look into the problem of scheduling scientific workflows, which are applications consisting of multiple tasks connected into a dependency graph. We discuss challenges related to workflow scheduling on the example of Serverless Deadline-Budget Workflow Scheduling (SDBWS) algorithm and preliminary experiments with a Montage astronomical workflow on AWS Lambda.