Powered by
2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH Companion 2015),
October 25–30, 2015,
Pittsburgh, PA, USA
Keynotes
Tomorrow's Network Operators Will Be Programmers (Keynote)
Nick Feamster
(Princeton University, USA)
Communications networks remain incredibly difficult to manage, troubleshoot, and secure. Network management challenges exist in all kinds of networks. In this talk, I will describe how Software Defined Networking (SDN), which decouples logical network control from the underlying network infrastructure, can simplify many network management tasks in different types of networks and may ultimately provide a means by which network operators (and home users) can make their networks more predictable, manageable, and secure. I will first present Kinetic, a new programming language and runtime for SDNs that we have developed, implemented, and deployed (in both home networks and on a large campus network) and describe how it allows network operators to express and implement complex policies in a simple and high-level control framework. Current SDN controller platforms typically offer little domain-specific support for programming changes to data-plane policy over time (dynamic policy). Links are provisioned and fail; users arrive and depart; traffic demands change; and hosts are compromised and patched. Today’s controller platforms offer SDN programmers little guidance on how to encode dynamic policies, which makes the resulting programs difficult to write and analyze. Kinetic encodes dynamic policies and realizes them in the underlying network. It offers novel Finite State Machine (FSM)-based abstractions for encoding dynamic policies that are expressive and intuitive, efficient for programmers to write, and amenable to automated verification. To prevent state explosion, we develop a new type of runtime policy that reactively generates only the required portions of the FSM abstractions that correspond to received events. I will then describe how we are applying new SDN abstractions and control to help approach longstanding problems in interdomain routing in a framework called SDN. To date, SDN has not affected how we interconnect separately administered networks as we do today through BGP. Because many of the current failings of the Internet are due to BGP’s poor performance and limited functionality, it behooves us to explore incrementally deployable ways to leverage SDN’s power to improve interdomain routing. Towards this goal, this project exploits the re-emergence of Internet eXchange Points (IXPs) to create Software Defined eXchanges (SDXs). Although the SDX approach does involve deploying SDN technology at IXPs, the improvements we describe involve fundamental changes to network control. I will describe how improved network control can realize the potential of SDN-capable functions at Internet exchange points.
@InProceedings{SPLASH Companion15p1,
author = {Nick Feamster},
title = {Tomorrow's Network Operators Will Be Programmers (Keynote)},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {1--2},
doi = {},
year = {2015},
}
How Dart Learned from Past Object-Oriented Systems (Keynote)
Lars Bak
(Google, USA)
The design of the Dart programming language is heavily based on syntax, features, and performance characteristics from past object-oriented systems. This intentional choice has resulted in a productive and yet simple to learn programming language with clear semantics. It can even be implemented efficiently on a wide variety of platforms. We will in this talk discuss several important design decisions, including: constructor semantics, the optional type system, and support for incremental execution and fast application startup. Finally, we will evaluate where the language should be improved.
@InProceedings{SPLASH Companion15p3,
author = {Lars Bak},
title = {How Dart Learned from Past Object-Oriented Systems (Keynote)},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {3--3},
doi = {},
year = {2015},
}
Modern Software Is All about Data. Development Environments Should Be, Too. (Keynote)
Rob DeLine
(Microsoft Research, USA)
The value of software is no longer just about the logic of its algorithms, but also about the data flowing through that logic. Think of popular services like Google search, Bing search, Yelp, Facebook, and Instagram. These services are useful because of a combination of user-generated data (restaurant reviews, status posts) and the algorithms that surface that data (rankings and recommendations based on machine learning). Even software that is valued for its logic, like games, often have data-driven features, like matching up players. Behind the scenes, software companies are also using data to make engineering and business decisions. For instance, some product teams monitor real-time metrics to troubleshoot problems and to decide when to scale out to more servers. Other teams analyze usage data to triage bugs and to brainstorm new features. Whether inside the product or behind the scenes, today, software = logic + data. Sadly, programming tools have not kept up and are still designed for authoring logic. Indeed, the popular languages and tools for analyzing data, like R, MATLAB, and the IPython Notebook, are a separate world from development environments, like Visual Studio, XCode and Eclipse. This separation creates awkward and inefficient workflows. For example, a data scientist might use one language and tool (say, R) to explore new recommendation algorithms; then, to deploy the final algorithm into the service, a programmer will entirely re-implement it, using a different language and tool (say, C# and Visual Studio). This problem gets worse as companies switch their focus from stored data to real-time streaming data, like live service telemetry and sensor data from wearable devices and the Internet of Things. In this talk, I’ll describe how data is changing the nature of professional software development and demonstrate new programming tools that make it easier for the user to work with both data and logic together.
@InProceedings{SPLASH Companion15p4,
author = {Rob DeLine},
title = {Modern Software Is All about Data. Development Environments Should Be, Too. (Keynote)},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {4--4},
doi = {},
year = {2015},
}
proc time: 1.03