Sat 26 - Thu 31 October 2013 Indianapolis, United States

The SPLASH tutorial program complements the technical material from OOPSLA, Onward!, and Wavefront with 80-minute tech talks and 1/2-day in-depth tutorials taught by experts that provide participants with in-depth or hands-on background in the area of focus. We invite tech talks and tutorials covering any topic related to SPLASH and its constituent events, including programming languages, programming, and software engineering. Tutorials and talks should target one or more significant segments of SPLASH’s audience, which includes researchers, educators, students, and leading-edge practitioners. Successful tutorial models include describing an important piece of research infrastructure, introducing an educational technique or tool, or educating the community on an emerging topic. Note the different tutorial model this year, with free tutorials and the short tech talk option, and the first-come first-served review process.


Capsule-Oriented Programming: Concurrency Made Simple

Sean Mooney, Iowa State U, USA
Bryan Shrader, Iowa State U, USA
Lorand Szakacs, Iowa State U, USA
Hridesh Rajan, Iowa State U, USA

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.


Sean Mooney is a graduate student at Iowa State University with a research focus on program analysis and methods for concurrency.

Bryan Shrader is an undergraduate student at Iowa State University. He works on the Panini project as a compiler engineer.

Lorand Szakacs is a graduate student at Iowa State University with a focus on easing the development of reliable software that scales to multi-core processors by means of programming language design and implementation.

Hridesh Rajan has extensive experience developing new languages. He has developed the Panini, Boa, Ptolemy and Eos languages.

Interactive Language Design with the Spoofax Language Workbench

Eelco Visser, Delft U Technology, Netherlands
Guido Wachsmuth, Delft U Technology, Netherlands

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.


Eelco Visser is associate professor at Delft University of Technology, where he leads the Software Language Design and Engineering program, which develops the Spoofax language workbench, as well as many domain-specific languages, including DSLs for syntax definition (SDF), program transformation (Stratego), web application development (WebDSL), and mobile phone applications (mobl).

Guido Wachsmuth is assistant professor at Delft University of Technology where he designs and implements new declarative metalanguages for the Spoofax language workbench, including languages for name binding (NaBL) and type systems.

R: A Language for Analyzing Data

Tomas Kalibera, Purdue U, Czech Republic

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.


Tomas Kalibera is a researcher working for Purdue University on the FastR project. His research interests include virtual machines, garbage collection, and benchmarking based on statistical methods.

Best Practices for Writing and Managing Performance Requirements

André Bondi, Siemens, USA

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.

AudienceThis tutorial is intended for architects, requirements engineers, developers, and their managers.It is also of interest to product managers, who must elicit product performance needs, and designers of programming languages in performance-sensitive domains

André Bondi is a performance engineer and senior research scientist in the Software Engineering Department at Siemens Corporation, Corporate Research and Technology in Princeton, New Jersey. He spent a year on assignment in Munich as the lead performance engineer of team that used an agile process to develop a system based on a service-oriented architecture. He has been actively involved with the negotiation and interpretation of performance requirements with developers and suppliers of services. He has worked on performance issues in several domains, including railway control, alarm systems, telecommunications, call centers, conveyor systems, finance systems, building surveillance, and network management systems. Just prior to joining Siemens, he held senior performance positions at two startup companies. Before that, he spent more than ten years working on a variety of performance and operational issues at AT&T Labs and its predecessor, Bell Labs, in New Jersey. He taught courses in performance, simulation, and operating systems principles at the University of California, Santa Barbara for three years. Dr. Bondi holds a Ph.D. in computer science from Purdue University and an M.Sc. in statistics from University College London.

Language Modeling Principles

Ralf Lämmel, U Koblenz, Germany

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.


Ralf Lämmel is Professor of Computer Science at University of Koblenz Landau, Germany. In the past, he held positions at Microsoft Corp., Free University of Amsterdam, CWI (Dutch Center for Mathematics and Computer Science), and the University of Rostock, Germany. Ralf Lämmel's speciality is "software language engineering", but he is generally interested in themes that combine software engineering and programming languages. He is one of the founding fathers of the international summer school series on Generative and Transformational Techniques on Software Engineering (GTTSE), the international conference on Software Language Engineering (SLE), and the 101companies project for the aggregation and integration of knowledge about software concepts, software languages, and software technologies.

Verified Software Components

Murali Sitaraman, Clemson U, USA
Bruce W. Weide, Ohio State U, USA

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.


Murali Sitaraman is Professor of Computer Science in the School of Computing at Clemson. He directs the RESOLVE/Reusable Software Research Group (RSRG) at Clemson. His research spans a spectrum of foundational, practical, and educational topics in software engineering, and it has been supported by US NSF grants continuously for over 20 years. He has co-edited a book on Foundations of Component-Based Systems with Gary Leavens for Cambridge University Press. Together with members of his group, he has published over 100 papers in various forums. He has offered tutorial-style workshops to educators on teaching mathematical reasoning at the ACM SIGCSE conference several times, including each of the last four years. Sitaraman has taught these ideas to graduate and undergraduate students for over 20 years.

Bruce W. Weide is Professor of Computer Science and Engineering at Ohio State University. He and his colleagues in the RESOLVE/Reusable Software Research Group (RSRG) have studied design, specification, and verification of component-based software. Weide and his colleague, Prof. Tim Long, were awarded the IEEE Computer Society Computer Science and Engineering Undergraduate Teaching Award in 2000 “for innovative work in the content and pedagogy of introductory computer science education, linking research advances in software engineering with educational delivery of the material taught in the introductory courses.” Weide has taught these ideas to graduate and undergraduate students for over 30 years.

Mining Ultra-Large-Scale Software Repositories with Boa

Robert Dyer, Iowa State U, USA
Hridesh Rajan, Iowa State U, USA

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.


Robert Dyer is the current lead on the Boa project. He co-developed the Boa language and backend caching mechanisms, and developed the compiler and the supporting website infrastructure. He has previously given a poster presentation on Boa and several formal demonstrations of Boa at SPLASH’12. He has prior experience implementing and evaluating the Ptolemy language.

Hridesh Rajan has extensive experience in developing new languages. He co-developed the Boa language. Prior to that, he developed the Ptolemy language, an event-based language for advanced separation of concerns. He also developed the aspect-oriented language Eos. He has successfully given multiple tutorials and demonstrations on other topics at AOSD’10, FSE’10, ECOOP’11, AOSD’11, and ASE’11.

Parallel Programming with Charm++

Phil Miller, U Illinois, USA
Laxmikant Kale, U Illinois, USA

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++.


Professor Laxmikant Kale works on various aspects of parallel computing, with a focus on enhancing performance and productivity via adaptive runtime systems. He has led the development of the Charm++ programming system with the aim of creating tools and techniques that advance the state of the art in computing while also providing a production-quality platform for programmers to develop parallel software. He is a Fellow of IEEE, collaborated on the widely used Gordon-Bell award winning (SC'2002) biomolecular simulation program NAMD, and won the Sidney Fernbach award for contributions to high performance computing.

Phil Miller works on developing new abstractions for high-performance computing applications. He has published work on safe usage of distributed-memory arrays, parallel I/O, distributed algorithms, and optimization of parallel numerical linear algebra. He is also one of the core developers of Charm++, focusing on performance tuning, usability, and making stable releases more widely available to application programmers.

Using a VM For Effective Research and Teaching: Learn to hack a VM in 90 minutes

Matthias Hauswirth, U Lugano, Switzerland
Dmitri Makarov, U Lugano, Switzerland
Stephen M. Blackburn, Australian National U, Australia

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.


Dmitri Makarov is a Ph.D. student at the University of Lugano. His research interests are parallel programming, virtual machines, compiler optimizations, software performance. He aims to improve performance of inherently sequential or difficult to parallelize algorithms on multiprocessors. After spending innumerable evenings debugging his modifications of the Jikes RVM with GDB, he decided to develop a tool that he could use to debug the machine faster and more efficiently.

Matthias Hauswirth is an Associate Professor at the University of Lugano. He has been on the program committees of PLDI, ECOOP, OOPSLA and numerous other conferences, and he is a co-organizer of the EVALUATE workshop series. Matthias received the Credit Suisse Award for Best Teaching. He is interested in performance measurement, understanding, and optimization, and he has used the Jikes RVM in his research and teaching.

Stephen M. Blackburn is a Professor at the Australian National University (ANU). He has served on numerous SIGPLAN program committees, including OOPSLA, ECOOP, PLDI, VEE and ISMM and served as chair for VEE, ISMM, and VMIL. He is an organizer of the EVALUATE workshop series. His research interests include programming language implementation, architecture, and performance analysis. He is a Distinguished Scientist of the ACM. Steve is a current member of Jikes RVM team and steering committee, has used Jikes RVM in teaching, and in 2004 with Perry Cheng, ran a successful OOPSLA tutorial on Jikes RVM's memory management subsystem, MMTk.

Diving into Dalvik

Andrea Janes, Free U Bolzano-Bozen, Italy
Dainius Jocas, Free U Bolzano-Bozen, Italy
Giancarlo Succi, Free U Bolzano-Bozen, Italy
Alberto Sillitti, Free U Bolzano-­Bozen, Italy

“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

AudiencePractitioners and researchers interested in software development for the Android platform.

Andrea Janes is an Assistant Professor at the Free University of Bolzano-Bozen (Italy) where he teaches a course on Architectures of Digital Systems. He has experience in mobile development in Java and C#.

Dainius Jocas is a masters student in Computer Science at the Free University of Bolzano-Bozen (Italy) and passionate about Android development in Java.

Alberto Sillitti, Ph.D., is an Associate Professor at the Free University of Bolzano-Bozen (Italy) where he teaches a course on Internet and Mobile Services. He has experience in Android development in Java and C/C++.

Giancarlo Succi, Ph.D., is Professor at the Free University of Bolzano-Bozen (Italy) where he teaches a course on Advanced Internet Technologies. He has experience in Android development in Java and C/C++.

Fundamental Practices of Software Developers

Václav Rajlich, Wayne State U, USA
Christopher Dorman, Ford Motor Company, USA

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#)

Audiencedevelopers, educators, and students

Václav Rajlich is Professor of Computer Science at Wayne State University. His research centers on agile, iterative, and evolutionary software development. He has published approximately 100 refereed papers and a recent book. He is the founder the IEEE International Conference on Program Comprehension (ICPC), and a member of Editorial Board of Journal of Software: Evolution and Process.

Christopher Dorman is a Java developer at Ford Motor Company in Dearborn, Michigan. He practices the processes presented in the tutorial on a daily basis. He also taught classes and given talks on the processes.

How to Document the Architecture of Your Application Using UML and More

Paulo Merson, Software Engineering Institute, Carnegie Mellon U, USA

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.

AudiencePractitioners that produce or consume software architecture documentation, and educators who teach software architecture.

Paulo Merson has 22 years of software development experience. He is a visiting scientist at the Software Engineering Institute where one of his assignments is to teach a 2-day course in "Documenting Software Architectures". Paulo also works in industry as a software architect. His speaking experience includes tutorials at SD Best Practices, Dr. Dobb’s Architecture & Design World, JavaOne, SATURN Conference, The SOA and Cloud Symposium, lectures to graduate students at universities in the US, Europe and Brazil, and invited talks at different companies. He is co-author of Documenting Software Architectures: Views and Beyond, 2nd edition.

Multicore Programming using Divide-and-Conquer and Work Stealing

S. Tucker Taft, AdaCore, USA

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.


S. Tucker Taft is VP and Director of Language Research at AdaCore, a company focused on open-source tools to support the development of high-integrity software. Tucker joined AdaCore in 2011 as part of a merger with SofCheck, a company he had founded in 2002 to develop advanced static analysis technology. Prior to that Tucker was a Chief Scientist at Intermetrics, Inc. and its follow-ons for 22 years, where in 1990-1995 he led the design of Ada 95. Tucker received an A.B. Summa Cum Laude degree from Harvard University, where he has more recently taught compiler construction and programming language design.

Agile Studies of Agile Methods

James Noble, Victoria U Wellington, New Zealand

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.

AudienceResearchers, students, and practitioners interested in grounded theory research techniques and in research results about agile methods.

James Noble is Professor of Computer Science and Software Engineering at Victoria University of Wellington, New Zealand. His research centres around software design, ranging from object-orientation, aliasing, design patterns, and agile methodology, via usability and visualisation, to postmodernism and the semiotics of programming.

Living without Pointers: Bringing Value Semantics to Object-Oriented Parallel Programming

S. Tucker Taft, AdaCore, USA

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.


S. Tucker Taft is VP and Director of Language Research at AdaCore, a company focused on open-source tools to support the development of high-integrity software. Tucker joined AdaCore in 2011 as part of a merger with SofCheck, a company he had founded in 2002 to develop advanced static analysis technology. Prior to that Tucker was a Chief Scientist at Intermetrics, Inc. and its follow-ons for 22 years, where in 1990-1995 he led the design of Ada 95. Tucker received an A.B. Summa Cum Laude degree from Harvard University, where he has more recently taught compiler construction and programming language design.

Unlocking the benefits of the API Economy

Israel Gat, Cutter Consortium
Tadas Remencius, Free U Bozen-­Bolzano, Italy
Alberto Sillitti, Free U Bolzano-­Bozen, Italy
Jelena Vlasenko, Free U Bozen-­Bolzano, Italy
Giancarlo Succi, Free U Bolzano-Bozen, Italy

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.


Dr. Israel Gat is a Cutter Consortium Fellow and Director of the Agile Product & Project Management practice, a Fellow of the Lean Systems Society, and a member of the Trident Capital SaaS advisory board.

Tadas Remencius is a Researcher at the Free University of Bolzano­Bozen (Italy). His primary research area is knowledge and experience management.

Alberto Sillitti, Ph.D., is Associate Professor at the Free University of Bolzano­Bozen (Italy) where he teaches the Internet and Mobile Services course.

Giancarlo Succi, Ph.D., is Professor at the Free University of Bolzano­Bozen (Italy) where he teaches the Advanced Internet Technologies.

Jelena Vlasenko, M.Sc., graduated from Free University of Bolzano­Bozen (Italy) in July 2012. Her research area is focused on Agile Software Development techniques and in particular on the effects of social aspects on team performance.

Developing Verified Programs with Dafny

K. Rustan M. Leino, Microsoft, USA

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.


Rustan Leino is a Principal Researcher at Microsoft Research. He is known for his work on programming methods and program verification tools, including Dafny, Chalice, Boogie, and ESC/Java. With Dafny, his mission is not just to provide a tool that helps teach programmers to reason about programs, but also to provide a vision for the kind of automatic reasoning support that all future programming environments may provide. Previously, Leino has been a researcher at DEC/Compaq SRC and a software developer at Microsoft. Leino collects thinking puzzles on a popular web page and hosts the Verification Corner channel on YouTube.

Grace: A new object-oriented language for novices

Kim Bruce, Pomona College, USA
James Noble, Victoria U Wellington, New Zealand
Andrew Black, Portland State U, USA

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.


The presenters of this tutorial are the members of the core Grace deign team: Black, Bruce and Noble. All are involved in teaching undergraduate programming, and are looking forward to teaching their introductory courses with a modern, conceptually simple, object-oriented programming language: Grace.

Kim Bruce has been Reuben C. and Eleanor Winslow Professor of Computer Science at Pomona College and the Frederick Latimer Wells Professor of Computer Science emeritus at Williams College, where he taught for 28 years. He received his B.A. from Pomona College and Ph.D. from the University of Wisconsin.

Bruce's research is mainly in the area of programming language design and semantics, with special focus on object-oriented languages. He has also done considerable work in computer science education, including work on the ACM/IEEE CS Curricula '91 committee and on all three of the curricula put forward by the Liberal Arts Computer Science Consortium. He received the ACM SIGCSE award for Outstanding Contributions to Computer Science Education in 2005. Aside from the usual collection of research papers, he has authored two books: Foundations of Object-Oriented Languages: Types and Semantics, published in 2002 by MIT Press, and Java: An Eventful Approach (with Danyluk and Murtagh) in 2005.

James Noble is Professor of Computer Science and Software Engineering at Victoria University of Wellington, New Zealand. James has B.Sc(Hons) and Ph.D. degrees, both from VUW, completed in 1997. After leaving VUW, James worked in Sydney, first at the University of Technology, Sydney, and then at the Microsoft Research Institute, Macquarie University. James returned to VUW as a lecturer in late 1999, just in time to avoid the predicted end of the world.

Noble's research centers around software design. This includes the design of the users' interface, the parts of software that users have to deal with every day, and the programmers' interface, the internal structures and organizations of software that programmers see only when they are designing, building, or modifying software. His research in both of these areas is colored by his longstanding interest in object-oriented approaches to design.

Andrew Black is Professor of Computer Science at Portland State University, and a former head of department at the Oregon Graduate Institute. He has been both teaching programming and designing programming languages since 1977, and holds a doctorate from the University of Oxford, but has also punctuated his academic career with spells in industry.

Black's research aims at making programming easier, and encompasses programming environments and tools as well as languages. He is a co-designer of Emerald, the first object-based distributed programming language, and of the traits mechanism for software reuse, which has been adopted in various forms by several recent languages, including Fortress, Pearl and Scala. He is a co-author of Squeak By Example and Pharo by Example.

Using Functional Programming Concepts in Financial Engineering

Roberto Salama, USA

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.

AudiencePeople interested in the application of functional programming to the area of financial engineering.

Roberto Salama has an MS in Electrical and Computer Engineering from North Carolina State University. He worked in the area of circuit simulation for a number of years before heading on to financial engineering. Over the last twenty years, he has worked at Goldman Sachs and Morgan Stanley building systems ranging from Fixed Income trading systems to financial analysis interactive platforms to time series systems. His area of interest is the application of emerging technologies, especially in the areas of language and distributed processing, to financial engineering.

Call for Contributions

The SPLASH tutorial program complements the technical material from OOPSLA, Onward!, and Wavefront with 80-minute tech talks and 1/2-day in-depth tutorials taught by experts that provide participants with in-depth or hands-on background in the area of focus. We invite tech talks and tutorials covering any topic related to SPLASH and its constituent events, including programming languages, programming, and software engineering. Tutorials and talks should target one or more significant segments of SPLASH's audience, which includes researchers, educators, students, and leading-edge practitioners. Successful tutorial models include describing an important piece of research infrastructure, introducing an educational technique or tool, or educating the community on an emerging topic. Note the different tutorial model this year, with free tutorials and the short tech talk option, and the first-come first-served review process.

Submission Summary
Due on: April 10, 2013
Accepted until: May 20, 2013
Notifications: May 25, 2013
Camera-ready copy due: (Tentative) August 05, 2013
Format: ACM Proceedings format
Contact: (chair)

The ACM International Conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH) is sponsored by ACM SIGPLAN.

SPLASH is the home of OOPSLA Research Papers, Onward!, and the Dynamic Languages Symposium, among other events.

Tutorial Changes from Previous Years

This year's tutorial track re-introduces half-day tutorials in addition to shorter tech talks. In a change from the OOPSLA tutorial model of a few years back, the tutorial track will focus on fewer tutorials and talks that are of interest to a broad set of attendees. Tutorials will be free for all conference participants to attend, which should increase tutorial audiences but, given the desire to keep registration costs low, precludes offering significant compensation to presenters. The tradeoff benefit to presenters is a larger audience for their tutorials.

Note that after April 10th proposals are evaluated on a first-come first-serve basis, until the final deadline which is May 20th.


A tutorial submission should be emailed to tutorials@splashcon.org, and should include the following information:

  • Tutorial or talk title
  • Category: 80-minute tech talk or 3-hour tutorial.
  • Abstract: a description of the tutorial in under 200 words, to appear in the SPLASH advance program. Take care to write an accurate and compelling abstract, as this is your primary way of "selling" your tutorial to potential attendees.
  • Advertising biography: a biography of the presenters, in under 100 words, for the advance program.
  • Presenters and contact person: For each presenter, include name, e-mail address, and affiliation. You may optionally expand on the brief "advertising" biography given above, to more completely describe the presenters' expertise and experience with the subject. If there are multiple presenters, indicate the contact person for the tutorial.
  • 1-3 page tutorial or talk description. Include the objectives of the tutorial, the topics to be covered, the presentation approach (which may include slides, hands-on or laptop exercises, games, etc.). It is suggested that 3-hour tutorials include exercises or interactive elements, not just lecture slides. Tech talk speakers should plan an 80-minute presentation with 10 additional minutes available for questions. Describe the target audience and their prerequisite knowledge. If the tutorial has been offered before, describe in what venue (e.g. which conference), the date, and the number of attendees. Describe any special requirements, beyond a room and standard A/V equipment.

Evaluation of submitted proposals starts after April 10th, 2013. Proposals submitted after that date may be selected based on their quality and provided there is space available.

For More Information

For additional information, clarification, or answers to questions please contact the Tutorials Chair, Jonathan Aldrich.