PLDI and co-located events are pleased to offer a number of lectures by distinguished invited speakers.
The “Cloud” is a wonderfully expansive phrase used to denote computation and data storage centralized in a large datacenter and elastically accessed across a network. The concept is not new; web sites and business servers have run in datacenters for a long time. These, however, were specialized applications, outside of the mainstream of desktop programs. The past few years has seen enormous change as the mainstream shifts from a single computer to mobile devices and clusters of computers. Three factors are driving this change. 1) Mobile computing, where apps run on a size- and power-constrained device and would be far less interesting without backend systems to augment computation and storage capacity. 2) Big data, which uses clusters of computers to extract valuable information from vast amounts of unstructured data. 3) Inexpensive, elastic computing, pioneered by Amazon Web Services, which enables everyone to rapidly obtain and use many servers.
As a researcher from the language and compiler community, I firmly believe this sea change is at heart a programming problem.1 Cloud computing is far different from the environment in which most of today’s languages and tools were developed, and few programmers have mastered its complexity. New challenges include pervasive parallelism, partial failure, high and variable communication latency, and replication for reliability and throughput.
The Cloud is an intrinsically parallel and distributed world in which computation runs across many processors on many computers. The workload, fortunately, is inherently parallel, as a single server can be shared by hundreds or thousands of simultaneous and independent users. Moreover, the Cloud is built on inexpensive, commodity hardware that fails in perverse ways. Because of scale, failures are common and software must treat failure as normal. At the same time, services in the cloud face stringent requirements to handle large and unpredictable loads while providing consistent response latency and to maintain high availability and reliability. Redundancy and replication are the principal tools to achieve these ends. And, of course, all of these new demands are layered on the familiar challenges of constructing secure, reliable, scalable, elastic, and efficient software! If this is not a programming problem, what is it?
Language designers and implementers have a remarkable opportunity to contribute by providing first-class support and tools to address these new challenges. Languages such as Erlang, C#, Javascript, and Scala have started down this path by supporting asynchronous communication. But, much more can be done. Shared memory and message passing concurrency needs to be integrated into a single, easy-to-use model with an appropriate balance among performance, usability, consistency, and reliability. Richer data models that embrace replication, consistency, partitioning, and persistence would greatly aid software development. And life cycle issues, such as updating continuously running systems and monitoring and controlling large configurations, are appropriate as elements of a language’s runtime system.
I will briefly describe Orleans, a software framework developed at Microsoft Research for building reliable, scalable, and elastic cloud applications. Its programming model encourages the use of simple concurrency patterns that are easy to understand and employ correctly. It is based on distributed actor-like components called grains, which are isolated units of state and computation that communicate through asynchronous messages. Within a grain, promises are the mechanism for managing both asynchronous messages and local task-based concurrency. Isolated state and a constrained execution model allow Orleans to persist, migrate, replicate, and reconcile grain state. In addition, Orleans provides lightweight transactions that support a consistent view of state and provide a foundation for automatic error handling and failure recovery. Orleans enables a developer to concentrate on application logic, while the Orleans runtime provides scalability, availability, and reliability. The system is in use by Microsoft, supporting production services.
James Larus is a Principal Researcher in Microsoft Research. Larus has been an active contributor to the programming languages, compiler, software engineering, and computer architecture communities. He published many papers, received 30 US patents, and served on numerous program committees and NSF and NRC panels. His book, Transactional Memory (Morgan Claypool) appeared in 2007. Larus became an ACM Fellow in 2006.
Larus joined Microsoft Research in 1998 to start and lead the Software Productivity Tools (SPT) group, which developed and applied a variety of innovative program analysis techniques to build tools to find software defects. This group's ground-breaking research in program analysis and software defect detection is widely recognized by the research community, as well as being shipped in Microsoft products such as the Static Driver Verifier, FX/Cop, and other software development tools. Larus became a MSR Research Area Manager for programming languages and tools and started the Singularity research project, which demonstrated that modern programming languages and software engineering techniques can fundamentally improve software architectures. Subsequently, he helped start XCG, an effort in MSR to develop hardware and software support for cloud computing. In XCG, Larus led groups developing the Orleans framework for cloud programming and computer hardware projects.
Before joining Microsoft, Larus was an Assistant and Associate Professor of Computer Science at the University of Wisconsin-Madison, where he published approximately 60 research papers and co-led the Wisconsin Wind Tunnel (WWT) research project with Professors Mark Hill and David Wood. WWT was a DARPA and NSF-funded project investigated new approaches to simulating, building, and programming parallel shared-memory computers. Larus’s research spanned a number of areas: including new and efficient techniques for measuring and recording executing programs’ behavior, tools for analyzing and manipulating compiled and linked programs, programming languages for parallel computing, tools for verifying program correctness, and techniques for compiler analysis and optimization.
Larus received his MS and PhD in Computer Science from the University of California, Berkeley in 1989, and an AB in Applied Mathematics from Harvard in 1980. At Berkeley, Larus developed one of the first systems to analyze Lisp programs and determine how to best execute them on a parallel computer.
Are programming languages part of the problem or are they part of the solution for building secure systems? We explore this question, starting with the roles that programming languages currently do play in building secure systems and roles that they could play. But to focus on language details misses some key opportunities. Progress in programming languages is an exemplar for a discipline's transition from an art to a craft to a science that informs engineering. Moreover, evidence mounts that the same science base developed within the programming languages community is also useful for building a science of security. We will explore the similarities and discuss how a science of security is likely to be different.
FRED B. SCHNEIDER is Samuel B. Eckert Professor of Computer Science at Cornell and also serves as the Chief Scientist for the NSF-funded TRUST Science and Technology Center, which brings together researchers at U.C. Berkeley, Carnegie-Mellon, Cornell, Stanford, and Vanderbilt. He is a a fellow of AAAS, ACM, and IEEE, was awarded a Doctor of Science honoris causa by the University of NewCastle-upon-Tyne, and received the 2012 IEEE Emanuel R. Piore Award for "contributions to trustworthy computing through novel approaches to security, fault-tolerance and formal methods for concurrent and distributed systems". The U.S. National Academy of Engineering elected Schneider to membership in 2011, and the Norges Tekniske Vitenskapsakademi (Norwegian Academy of Technological Sciences) named him a foreign member in 2010. Schneider has testified about cybersecurity research at hearings of the US House of Representatives and co-chairs Microsoft's Trustworthy Computing Academic Advisory Board.
Dynamic Programming Languages, such as Java, JavaScript, PHP, etc., are dominating languages for programming the web. HW/SW co-designed virtual machine can significantly accelerate their executions by transparently leveraging both high level language info and internal HW features via an internal compiler. We also argue for a common API to interface dynamic languages with the HW/SW co-designed virtual machine, so that a single internal compiler can accelerate all major dynamic languages.
Youfeng Wu is a principal engineer and director of Programming Systems Lab at Intel Labs. He has been with Intel labs for more than 15 years, with extensive publications and patents in compiler technology and HW/SW co-design for efficient optimizations.
Contrary to predictions of its demise, C remains a dominant programming language, especially in embedded systems. Speed and transparency dictate that it will be so for the next decade, despite its supposed unsuitability for programming parallel architectures. A flexible compiler development system is a unique vehicle to bend the C language and its implementation to the developers' will. Using hard-won experience in applying extended versions of C to diverse parallel architectures, C's potential in the dark ages of multi-core programming is examined.
Marcel Beemster is a Senior Software Engineer at ACE Associated Compiler Experts. He received his PhD from the University of Amsterdam for work on fine-grained parallelism in functional languages and lectured on general programming techniques, compilers and computer architectures at universities and conferences. At ACE his work has included design, implementation and management for projects in the areas of Java compilation, compilation for reconfigurable arrays, SIMD and multi-core architectures, all in the context of the CoSy compiler development system.
A safe programming language is one that protects its abstractions. For instance, a type-safe language provides the abstraction of memory as a collection of disjoint entities by ensuring that programming errors, such as buffer overflows, do not break the abstraction. The programmability benefits of safety are obvious.
Surprisingly, two fundamental programming abstractions are not protected in modern languages today: (a) program order: which allows the programmer to assume in a program { a;b } that instruction a is executed before b, and (b) shared memory: which allows the programmer treat memory as a map from addresses to value with lookups and updates happening instantly.
Sequential consistency (SC) is a memory consistency model that preserves these two abstractions for multithreaded programs that communicate through shared memory. Recent standards of C++ and Java provide SC only for programs that appropriately annotate all their data races. Simple annotations errors can break the SC abstraction exposing the programmer to the complexities of compiler and hardware optimizations - very much like simple errors breaking type-safety in unsafe languages.
In this talk, I will argue that modern languages can and should protect the SC abstraction. I will describe research, both old and new, that shows that SC can be implemented efficiently. To further motivate the problem, I will explain why data-race-free programs are not correct programs and vice versa. Finally, I will describe recent trends in hardware and programming languages that will continue to reduce the performance gap between SC and weaker memory consistency models available today, and research challenges that can seal this gap.
Madan Musuvathi is a Senior Researcher at Microsoft Research where he has been a researcher since 2004. His research interests are in concurrency and parallelism as they relate to program analyses, algorithms, verification, model checking, and memory consistency models. His research focuses on improving the software quality and programmer productivity through scalable analysis tools. He received his Ph.D. from Stanford University in 2004, and B.Tech. from Indian Institute of Technology (IIT), Chennai in 1996.