TutorialsSPLASH 2013

This tutorial will provide an introduction to capsule-oriented programming and introduce the Panini programming language and infrastructure.

It is often difficult but necessary to read, write, and reason about concurrent programs, a process which can benefit from better abstractions for concurrency. One promising approach to addressing this problem is the combination of state and control within a linguistic mechanism, as well as the use of asynchronous messages to enable communication between system entities. However, this approach requires programmers adapt to the asynchronous style of programming. Capsule-oriented programming, a new approach to addressing these concerns, focuses on providing sequentially trained programmers with actor-like abstractions via a familiar synchronous model. The programs look similar to sequential programs and maintain sequential semantics, but are implicitly concurrent.

This tutorial will begin by discussing capsule-oriented programming. We will then proceed to define the Panini language, a capsule-oriented extension of Java, and work through several hands-on examples which demonstrate the benefits of the language. We will conclude with pointers to the ongoing design and implementation work of the language.

The Spoofax language workbench is a platform for the development of textual software languages with state-of-the-art IDE support. Spoofax provides a comprehensive environment that integrates syntax definition, name binding, program transformation, code generation, and declarative specification of IDE components. It supports agile development of languages by allowing incremental, iterative development of languages and showing editors for the language under development alongside its definition.

This tech talk presents principles and techniques for the design and implementation of software languages in Spoofax, illustrated using a subset of Java. These techniques are explained using Spoofax’s high-level DSLs for language engineering. Spoofax’s testing language enables test-driven language engineering. The syntax definition formalism SDF supports modular definition of (composite) languages. The name binding language NaBL enables declarative definitions of name binding and scope rules of software languages. The Stratego transformation language unifies model transformation and code generation. The use of concrete object syntax allows structured transformation patterns to be phrased in the syntax of the source language.

The R language and runtime was released in 1995 and quickly gained its popularity as a tool for scientific computing. Over the last decade it has become a key platform for implementing data analysis algorithms. Today R has over 5000 open-source packages, an estimated base of 2000 package developers and 2 million end users. For computer scientists, R is a useful tool for analyzing and visualizing experimental results. But most of all it is a challenge for researchers in programming languages and virtual machines. R has function closures with lexical scoping, but also lazy evaluation of function arguments. R allows to reflectively access code as text and to turn text into code and evaluate it in any scope. R code can run in synthetically created scopes, e.g. in data sets. R has rich support for vector arithmetics, including arithmetics with missing data. The talk includes a tutorial on R for computer scientists based on a running example of summarizing results of a DaCapo benchmark and it is intended for anyone who needs to analyze experimental results - no prior knowledge of R is expected. The second part of the talk covers interesting features of the R language which make R a distinctive language but also a challenge for fast execution.

Functional requirements refer to how a piece of a system functions or what it does given specific inputs. Nonfunctional requirements refer to such business and engineering needs as performance, reliability, availability, stability, usability, compatibility with interfaces, and security. Performance requirements are one of the main drivers of architectural decisions. They may also play a role in the choice of programming languages and environments to be used. Because many performance problems have their roots in architectural decisions, and since poor performance is a principal cause of software project risk, it is essential that performance requirements be developed early in the software lifecycle, and that they be clearly formulated. In this tutorial, we shall look at criteria for high-quality performance requirements, including algebraic consistency, measurability, testability, and linkage to business and engineering needs. While focus of this tutorial is on practice, we shall show how the drafting of performance requirements can be aided by performance modeling. We shall show methods for presenting and managing performance requirements that will improve their chances of being accepted by architects, developers, testers, contract negotiators, and purchasers; and of their being successfully implemented and tested.

Presentation Slides are available.

This tutorial is concerned with software languages in a broad sense to include domain-specific languages (DSLs and DSMLs, embedded or not), programming languages as well as intermediate and auxiliary languages in grammarware and modelware. The overarching objective of the tutorial is to foster cross-pollination between the technological spaces with interests in language modeling: modelware, grammarware, and, to some extent, ontoware. Language modeling refers to the process of defining the syntax and semantics of a language while involving different aspects: abstract (tree- versus graph-based) versus concrete (textual versus visual) syntax, parsing, editing, pretty-printing, well-formedness, well-typedness, and other constraints, dynamic semantics in terms of interpretation or reduction, and translation-based semantics.

The tutorial walks through a catalogue of language modeling problems and recovers fundamental notions to provide simple, technology-neutral explanations of these problems. The notions, some of them on the verge of extinction, are adopted from diverse disciplines of programming languages and software engineering, e.g., compiler construction, formal semantics, metamodeling, software language engineering, algebraic specification, term rewriting, functional programming, the semantic web, software reverse and re-engineering.

For instance, consider the well-known problem of mapping (textual) concrete syntax to abstract syntax. How to model and thus, to fundamentally understand such a mapping in a principled manner? The problem can be explained in terms of these basic notions: algebraic signature, term algebra, algebraic interpretation of a context-free grammar, and signature morphism. This is a suitable foundation for understanding such mappings as facilitated by specific grammarware or modelware technologies. Here are some other language modeling problems: definition-use resolution, type and constraint checking, type inference and logical reasoning, program and model normalization, interpretation, model and program translation and generation, and language embedding. Of course, the idea is not to cover these problems in depth, but to associate them with fundamental notions that explain the problems at a basic level to support helpful and robust intuitions.

Lightweight semi-formal notation, encoded in Prolog or Haskell, is used to capture the involved notions, thereby providing an integrated and executable model of language modeling. Profound background on the aforementioned disciplines is not assumed. Specific grammarware and modelware technologies serve for illustration. Further reading pointers are provided. The tutorial is interactive in that it is designed to pursue continuous discussion on a representative and manageable set of language modeling problems, a suitable and digestible set of notions to explain the problems, and a diverse set of technologies and applications for illustration.

In this tutorial, attendees will learn how to design, specify, and implement verified software components. The tutorial should be of interest to researchers, educators, and software practitioners. They will be involved in hands-on experimentation with construction and modular verification using a web-integrated software engineering environment that requires no software installation. The tutorial will discuss how to engineer specifications and how to design and annotate object-based component implementations of software components. To make the ideas concrete, the tutorial will use RESOLVE, an integrated specification and programming language especially designed for building verified components, which features a prototype “push-button” verifying compiler. It will also summarize the presenters’ experiences in adapting a RESOLVE discipline of component-based development to C++ and Java.

Mining software repositories provides developers and researchers a chance to learn from previous development activities and apply that knowledge to the future. Ultra-large-scale open source repositories (e.g., SourceForge with 350k+ projects) provide an extremely large corpus to perform such mining tasks on. This large corpus allows researchers the opportunity to test new mining techniques and empirically validate new approaches on real-world data. However, the barrier to entry is often extremely high. Researchers interested in mining must know a large number of techniques, languages, tools, etc, each of which is often complex. Additionally, performing mining at the scale proposed above adds additional complexity and often is difficult.

The Boa language and infrastructure was developed to solve these problems. Boa provides a web-based interface for mining ultra-large-scale software repositories. Users use a domain-specific language tailored for software repository mining and submit queries to the website. These queries are then automatically parallelized and executed on a cluster.

This tutorial teaches users how to efficiently perform mining tasks on over 600k open-source software projects. We introduce the language and supporting infrastructure and then perform several mining tasks. Users need not be experts in mining: Boa is simple enough for even novices, yet still powerful enough for experts.

Charm++ is a C++-based parallel programming framework with a 20-year track record of delivering high performance on systems ranging from single workstations to the largest supercomputers in the world. It supports parallel execution across shared and distributed memory systems with no technological discontinuity between the two regimes.

Using objects as the units of parallelism, Charm++ allows parallel application logic to be expressed via collections of asynchronously interacting objects. This yields composable parallel software without compromising on the efficient utilization of available hardware. During execution, the runtime system in Charm++ observes application behavior and system conditions, and adapts the mapping of objects to processors accordingly. By doing so, the runtime system can automate many of the domain-independent necessities for good performance, like load balancing, exploiting accelerators, and energy management. Thus, application developers can focus on the requirements of their applications and users.

This presentation will introduce attendees to the principles of parallel application development in Charm++. We will explain the advantages of expressing parallel algorithms using this paradigm. Attendees will see several examples of how Charm++ has been applied to create fast, scalable software. They will learn how to express parallel logic to construct their own parallel programs using Charm++.

Virtual machines are a key technology for object oriented lan-guages, and thus an important context for research and teaching. Unfortunately, they also have a reputation as being intimidating and unapproachable. The purpose of this tutorial is to show researchers and educators how a large, widely used virtual machine can be used as an effective platform for research and teaching of the virtual machine technology. The tutorial is centered on a running exam-ple that involves designing, implementing and debugging a real-istic research-motivated extension to a virtual machine. We guide the audience through the process and demonstrate how to use the available tools to make sense of the VM’s sophisticated compo-nents and we show how to debug the machine when things don’t go as planned. We do this using Jikes RVM, a very widely used research Java virtual machine.

At the end of the tutorial, participants who had never heard of Jikes RVM will have enough information to start using it for their teaching and research. The participants already familiar with the platform will have better understanding of the system and will learn about recent development targeted to make Jikes RVM more approachable to the broader circle of researchers and students.

“Dalvik” is the name of the virtual machine that runs programs on Android devices. The architecture of Dalvik is designed to match the energy consumption and performance requirements of devices with limited energy and hardware capabilities. Therefore, the study of the architectural decisions behind Dalvik is relevant for researchers and practitioners interested in the capabilities and limitations of the machine executing mobile programs and the specific programming styles required for battery-powered devices.

To understand how Dalvik works, we compare it with the Java Virtual Machine running on desktop computers using the following criteria: the objectives, the compilation process, and the format of Dalvik executables.

This talk points out the strengths of Dalvik, and how these strengths are achieved. Researchers and practitioners involved in mobile programming or Green Computing will learn how programs are executed and which strategies Dalvik adopts to retain battery power. This knowledge can be used to optimize program execution or to adopt similar strategies in similar projects.

Prerequisite: some experience in Java programming, and a basic understanding of computer architecture

The tutorial surveys developers' tasks in agile, iterative, and evolutionary software development. Among these, a particularly important task is software change where developers add a new feature, correct a bug, or add a new property to software. The tutorial then surveys recent research results and explores how the results translate into the practice and teaching of software development. Examples of developer practices include “feature location” that locates in the existing code the place where a new feature is to be implemented, “impact analysis” that assesses how much the old code is going to be impacted if a new feature is added to it, refactoring that either prepares the code for the change or cleans up the aftermath, change propagation that traces where the secondary changes are to be made, verification that confirms both the new and the old code, and so forth. These practices are summarized in a “phased model of software change.”

Prerequisite: medium knowledge of object-oriented programming (e.g. C++, Java, or C#)

Have you ever been confused by an arrow in a box-and-line design diagram? Do you use UML in your software architecture? Have you ever wondered where is the line between architecture and detailed design? If your answer is yes to any of these questions, then this tutorial has practical and valuable information for you. The goal is to show you what information about an architecture should be captured, so that others can successfully use it, maintain it, and build a software system from it. Important takeaways from this tutorial include: architecture consists of multiple views; how can we use UML in each view and when other notations work better; what views can we use to evaluate performance, availability, modifiability and other qualities; how to complement structural diagrams with sequence diagrams, statecharts and other behavior diagrams; how to document software interfaces; guidelines and templates to make your architecture documentation more effective. To benefit the most from this tutorial, attendees should have familiarity with basic UML and an interest in software architecture.

Prerequisite: intermediate level of knowledge/experience in software development in general, and familiarity with basic UML.

This tutorial will introduce attendees to the various paradigms for creating algorithms that take advantage of the growing number of multicore processors, while avoiding the overhead of excessive synchronization overhead. Many of these approaches build upon the basic divide-and-conquer approach, while others might be said to use a multiply-and-conquer paradigm. Attendees will also learn the theory and practice of "work stealing," a multicore scheduling approach which is being adopted in numerous multicore languages and frameworks, and how classic work-list algorithms can be restructured to take best advantage of the load balancing inherent in work stealing. Finally, the tutorial will investigate some of the tradeoffs associated with different multicore storage management approaches, including task-local garbage collection and region-based storage management.

Prerequisite: Intermediate to advanced knowledge of programming, with some understanding of multi-threaded/multi-tasking issues, including race conditions and synchronization.

Over the last ten years, Agile Methods have been adopted for many software development projects. In this talk, I'll describe the research method - Grounded Theory - that we have adopted to study Agile projects and teams, and present some of the results of that research. In particular, I'll talk about the history of Grounded Theory in the social sciences, the major stages of a Grounded Theory research project, and describe the major techniques: data gathering, coding, constant comparison. I'll describe how Grounded Theory relies upon the kind of feedback loops that are characteristic Agile methods, in particular theoretical sampling and selective coding. I'll talk about how to know when you're done: theoretical saturation, theoretical coding, and completing literature reviews. Finally I'll talk about the kind of research results discovered by Grounded Theory, their relationships to other kinds of research and publications, and hints on how to convince programme committees that they should accept your research.

The heavy use of pointers in modern object-oriented programming languages interferes with the ability to adapt computations to the new distributed and/or multicore architectures. This tech talk will introduce an alternative pointer-free approach to object-oriented programming, which dramatically simplifies adapting computations to the new hardware architectures. This tech talk will illustrate the pointer-free approach by demonstrating the transformation of two popular object-oriented languages, one compiled, and one scripting, into pointer-free languages, gaining easier adaptability to distributed and/or multicore architectures, while retaining power and ease of use.

API Economy is economy where companies expose their (internal) business assets or services in the form of (web) APIs to third parties with the goal of unlocking additional business value. Triggered by the explosion of the growth of Internet­enabled devices, evolution of social interactions (i.e., social networking, social commerce), and appearance of new software markets in the form of Apps, API Economy brings a different philosophy to how companies do business and how they interact with their customers and competition. The aim of this talk is to give a clear view on what API Economy is, what opportunities it offers to API producers and API consumers, and what are the general steps (methodology) to unlock those benefits.

Reasoning about programs is a fundamental skill that every software engineer needs. This tutorial provides participants an opportunity to get hands-on experience with Dafny, a tool that can help develop this skill. Dafny is a programming language and state-of-the-art program verifier. The language is type-safe and sequential, and it includes common imperative features, dynamic object allocation, and datatypes. It also includes specification constructs like pre- and postconditions, which let a programmer record the intended behavior of the program along with the executable code that is supposed to cause that behavior. What sets Dafny apart from other programming systems is that it runs its verifier continuously in the background, and thus the consistency of a program and its specifications is always enforced. This tutorial gives a taste of how to use Dafny in program development. This includes an overview of Dafny, basics of writing specifications, how to debug verification attempts, and how to formulate and prove lemmas. The tutorial is geared toward programmers who want to get their programs right, students, educators, as well as researchers in formal methods.

With increasing frustration with Java and its ilk, instructors are searching for an alternative language for introducing students to object-oriented programming. This alternative should have simple and clear syntax and semantics, provide good support for object-oriented programming, and yet give instructors the flexibility to introduce the material in a variety of ways, including objects-first, objects-late, and functional-first. It should also support both dynamic and static typing.

Grace is a new language that meets these needs. Grace allows the definition of both objects and classes, provides encapsulation and inheritance, and is gradually typed, allowing instructors to start with either dynamic or static typing and to move from one to the other. Moreover, Grace provides a concise syntax for first-class functions providing great flexibility in building new language constructs from the primitive notions of the language.

In order to support good pedagogy, Grace, like Racket, supports dialects, so that students can be introduced first to limited versions of the language, which can then be grown, in a variety of ways, to the full version. A simple, object-based module system supports the use of libraries that can be used as scaffolding for teaching. For example, a Grace version of the Java objectdraw library for graphics is available for use in teaching event-based graphical programming using Grace.

The first 90 minutes of this tutorial will introduce participants to the features of Grace, the motivations that led to the design, and discuss how Grace might be used in introductory courses. Those wanting to experience Grace immediately may stay for a second 90-minute lab in which they can try their hand at Grace programming.

Attendees of this tutorial will gain hands-on experience using functional programming for solving financial engineering problems. In this tutorial, we will acquaint ourselves with Kx’s KDB/Q language, a dynamically-typed vector-oriented language with roots in APL, while comparing and contrasting some of the programming concepts with equivalent ones in Scala. The tutorial consists of three parts:

1. Overview of KDB/Q, its data types and functional constructs.

2. Financial engineering concepts, returns, volatility, discount factors, binomial lattice models, and term structures, the basic building blocks of many financial engineering problems.

3. Building a real-time mock market tick by tick system that feeds real-time calculation engine based on some of the concepts introduced in Section 2.

The goal of this tutorial is two-fold. First, it is to introduce both financial engineering concepts and the computational resources required to model and solve problems in this discipline. Second, it is to explore the use of a functional programming language to build solutions for problems in this area.

Prerequisites: This tutorial will be presenting KDB/Q from the ground up. So while there are no prerequisites for this tutorial, some prior experience with Scheme/Lisp, Scala, Clojure would make it easier to grasp some of the concepts presented.