## SPLASH 2015 - Workshops Combined Call for Papers

/************************************************************************************/
ACM Conference on Systems, Programming, Languages, and Applications:
Software for Humanity (SPLASH'15)

Pittsburgh, Pennsylvania, USA
25th-30th October, 2015

/************************************************************************************/
CALL FOR WORKSHOP PAPERS AND PARTICIPATION

/************************************************************************************/

SPLASH'15 workshops address a rich variety of well-known and newly emerging research areas and provide a creative and collaborative environment to discuss and solve challenge problems with attendees from industry and research organizations from all over the world. Submission deadlines vary from workshop to workshop. Some workshops will be published in the ACM Digital Library. The current SPLASH'15 workshops program is listed below and the abstracts at the end.

**************************************************************

CURRENT WORKSHOP PROGRAM

AGERE! - Workshop on Programming based on Actors, Agents, and Decentralized Control
http://2015.splashcon.org/track/agere2015
Abstracts: August 1, 2015,
Submissions: August 7, 2015,
Position/work-in-progress Papers and Demos: September 7, 2015

DSM - Workshop on Domain-Specific Modeling
http://2015.splashcon.org/track/dsm2015
Submissions: August 7, 2015

ETX - Eclipse Technology eXchange Workshop
http://2015.splashcon.org/track/etx2015
Paper Registration: July 31, 2015
Submissions: August 7, 2015

FPW - Future Programming Workshop
http://2015.splashcon.org/track/fpw2015
Submissions: August 7, 2015

MobileDeLi - Workshop on Mobile Development Lifecycle
http://2015.splashcon.org/track/mobiledeli2015
Submissions: August 7, 2015

PLATEAU – Workshop on Evaluation and Usability of Programming Languages and Tools
http://2015.splashcon.org/track/plateau2015
Submissions: August 7, 2015

PROMOTO – Workshop on Programming for Mobile and Touch
http://2015.splashcon.org/track/promoto2015
Submissions: August 7, 2015

Parsing@SLE - Workshop on Parsing Programming Languages
http://2015.splashcon.org/track/ParsingAtSLE2015
Submissions: August 7, 2015

REBLS - Workshop on Reactive and Event-based Languages & Systems
http://2015.splashcon.org/track/rebls2015
Submissions: August 7, 2015

SEPS - Workshop on Software Engineering for Parallel Systems
http://2015.splashcon.org/track/seps2015
Submissions: August 7, 2015

SMART - Smart Software Strategies
http://conf.researchr.org/track/SmartSoftwareStrategies2015/SmartSoftwareStrategies2015
Submissions: October 2, 2015

WODA - Workshop on Dynamic Analysis
http://2015.splashcon.org/track/woda2015
Submissions: August 7, 2015

**************************************************************
ANNEX: WORKSHOP ABSTRACTS AND DATES
**************************************************************
AGERE! 5th International Workshop on Programming based on Actors, Agents, and Decentralized Control
http://2015.splashcon.org/track/agere2015

Abstracts: August 1, 2015
Submissions: August 7, 2015
Position/work-in-progress Papers and Demos: September 7, 2015

- Organizers:
Elisa Gonzalez Boix, Vrije Universiteit Brussel, Belgium
Philipp Haller, KTH Royal Institute of Technology, Sweden
Alessandro Ricci, University of Bologna, Italy
Carlos Varela, Rensselaer Polytechnic Institute

- Abstract:
The AGERE! workshop is aimed at focusing on programming systems, languages and applications based on actors, active/concurrent objects, agents and – more generally – high-level programming paradigms promoting a mindset of decentralized control in solving problems and developing software. The workshop is designed to cover both the theory and the practice of design and programming, bringing together researchers working on models, languages and technologies, and practitioners developing real-world systems and applications.

**************************************************************
DSM - Domain-Specific Modeling workshop
http://2015.splashcon.org/track/dsm2015

Submissions: August 7, 2015

- Organizers:
Jeff Gray, University of Alabama, USA
Jonathan Sprinkle, University of Arizona, USA
Juha-Pekka Tolvanen, MetaCase, Finland
Matti Rossi, Aalto University School of Economics, Finland

- Abstract:
Domain-specific languages provide a viable and time-tested solution for continuing to raise the level of abstraction, and thus productivity, beyond coding, making systems development faster and easier. When accompanied with suitable automated modeling tools and generators it delivers to the promises of continuous delivery and devops. In Domain-Specific Modeling (DSM) the models are constructed using concepts that represent things in the application domain, not concepts of a given programming language. The modeling language follows the domain abstractions and semantics, allowing developers to perceive themselves as working directly with domain concepts. Together with frameworks and platforms, DSM can automate a large portion of software production. This automation is possible because of domain-specificity: both the modeling language and code generators fit to the requirements of a narrowly defined domain, often inside one organization only.

**************************************************************
ETX - Eclipse Technology eXchange Workshop
http://2015.splashcon.org/track/etx2015

Abstracts: July 31, 2015
Submissions: August 7, 2015

- Organizers:
Tim Verbelen, Ghent University - iMinds, Belgium
Michael Burke, Rice University, USA

- Abstract:
The Eclipse platform (http://www.eclipse.org) was originally designed for building integrated development environments for object-oriented applications. Over the years it has developed into a vibrant ecosystem of platforms, toolkits, libraries, modeling frameworks, and tools that support various languages and programming styles. The goal of the ETX workshop is to bring together researchers and practitioners to exchange ideas about potential new uses of Eclipse and how Eclipse technology can be leveraged, improved, and/or extended for research and education. After successful editions of the ETX workshop in 2003-2007, we revived the ETX workshop in 2014 and are now up for another edition. ETX 2015 invites original and unpublished contributions about potential new uses of Eclipse and how Eclipse technology can be leveraged, improved, and/or extended for research and education.

**************************************************************
FPW - Future Programming Workshop
http://2015.splashcon.org/track/fpw2015

Submissions: August 7, 2015

- Organizers:
Jonathan Edwards, MIT CSAIL, USA
Richard Gabriel, IBM Research, USA
Alex Payne, Emerging Languages Camp, USA

- Abstract:
The Future Programming Workshop (FPW) invites ambitious visions, new approaches, and early-stage work of all kinds seeking to improve software development. Participants will present their work at SPLASH in Pittsburgh and optionally at Strange Loop in St. Louis, culminating in a writers’ workshop at SPLASH. FPW fosters a supportive and inspirational community of researchers and practitioners working at the frontiers of software. We are looking for transformative ideas outside the academic and industrial mainstream - ideas with potentially large impacts on how we will build software in the future. We embrace early-stage work, when it is most in need of constructive criticism, and offer a safe and effective environment in which to receive such criticism.

**************************************************************
MobileDeLi - Workshop on Mobile Development Lifecycle
http://2015.splashcon.org/track/mobiledeli2015

Submissions: August 7, 2015

- Organizers:
Aharon Abadi, IBM Haifa Research Lab, Israel
Lori Flynn, CERT, USA
Jeff Gray, University of Alabama, USA

- Abstract:
Mobile application usage and development is experiencing exponential growth. According to Gartner, by 2016 more than 200 billion total apps will have been downloaded. The mobile domain presents new challenges to software engineering. Mobile platforms are rapidly changing, including diverse capabilities as GPS, sensors, and input modes. Applications must be omni-channel and work on all platforms.
Activated on mobile platforms, modern applications must be elastic and scale on demand according to the hardware abilities. Applications often need to support and use third-party services. Therefore, during development, security and authorization processes for the dataflow must be applied. Bring your own device (BYOD) policies bring new security data leaks challenges. Developing such applications requires suitable practices and tools e.g., architecture techniques that relate to the complexity at hand; improved refactoring tools for hybrid applications using dynamic languages and polyglot development and applications; and testing techniques for applications that run on different devices. This workshop aims at establishing a community of researchers and practitioners to share their work and lead further research in the mobile development area.

**************************************************************
PLATEAU – 6th Workshop on Evaluation and Usability of Programming Languages and Tools
http://2015.splashcon.org/track/plateau2015

Submissions: August 7, 2015

- Organizers:
Thomas LaToza, UC Irvine, USA
Joshua Sunshine, Carnegie Mellon University, USA
Craig Anslow, Middlesex University, UK

- Abstract:
Programming languages exist to enable programmers to develop software effectively. But how efficiently programmers can write software depends on the usability of the languages and tools that they develop with. The aim of this workshop is to discuss methods, metrics and techniques for evaluating the usability of languages and language tools. The supposed benefits of such languages and tools cover a large space, including making programs easier to read, write, and maintain; allowing programmers to write more flexible and powerful programs; and restricting programs to make them more safe and secure. PLATEAU gathers the intersection of researchers in the programming language, programming tool, and human-computer interaction communities to share their research and discuss the future of evaluation and usability of programming languages and tools.

**************************************************************
Parsing - Parsing@SLE 2015
http://2015.splashcon.org/track/ParsingAtSLE2015

Submissions: August 7, 2015

- Organizers:
Ali Afroozeh,
Loek Cleophas, Umea University, Sweden

- Abstract:
Parsing@SLE is a workshop on parsing programming languages, now in its third edition. The intended participants are the authors of parser generation tools and parsers for programming languages and other software languages. For the purpose of this workshop parsing’’ is a computation that takes a sequence of characters as input and produces a syntax tree or graph as output. This possibly includes tokenization using regular expressions, deriving trees using context- free grammars, and mapping to abstract syntax trees. The goal is to bring together today’s experts in the field of parsing, in order to explore open questions and possibly forge new collaborations. The topics may include algorithms, implementation and generation techniques, syntax and semantics of meta formalisms (BNF), etc.

**************************************************************
PROMOTO – 3rd Workshop on Programming for Mobile and Touch
http://2015.splashcon.org/track/promoto2015

Submissions: August 7, 2015

- Organizers:
Steven D. Fraser, Innoxec, USA
Alberto Sillitti, Center for Applied Software Engineering Bolzano, Italy

- Abstract:
Today, easy-to-use mobile devices like smartphones and tablets are becoming more prevalent than traditional PCs and laptops. New programming languages are emerging to enable programmers to develop software easily—leveraging the exciting advances in existing hardware, and providing abstractions that fit the capabilities of target platforms with multiple sensors, touch and cloud capabilities. PROMOTO brings together researchers who have been exploring new programming paradigms, embracing the new realities of always connected, touch-enabled mobile devices. PROMOTO 2015 would like to invite contributions covering technical aspects of cross-platform computing, cloud computing, social applications and security. Submissions for this event are invited in the general area of mobile and touch-oriented programming languages and programming environments, and teaching of programming for mobile devices.

**************************************************************
REBLS - Workshop on Reactive and Event-based Languages & Systems
http://2015.splashcon.org/track/rebls2015

Submissions: August 7, 2015

- Organizers:
Wolfgang De Meuter, Vrije Universiteit, Belgium
Patrick Eugster, Purdue University, USA
Lukasz Ziarek, State University of New York (SUNY) Buffalo, USA

Reactive programming and event-based programming are two closely related programming styles that are becoming ever more important with the advent of advanced HPC technology and the ever increasing requirement for our applications to run on the web or on collaborating mobile devices. A number of publications on middleware and language design — so-called reactive and event-based languages and systems (REBLS) — have already seen the light, but the field still raises several questions. For example, the interaction with mainstream language concepts is poorly understood, implementation technology is in its infancy and modularity mechanisms are almost totally lacking. Moreover, large applications are still to be developed and patterns and tools for developing reactive applications is an area that is vastly unexplored.

**************************************************************
SEPS - 2nd Workshop on Software Engineering for Parallel Systems
http://2015.splashcon.org/track/seps2015

Papers: August 7, 2015

- Organizers:
Ali Jannesari, Technical University of Darmstadt, Germany
Siegfried Benkner, University of Vienna, Austria
Xinghui Zhao, Washington State University, USA
Yukionri Sato, Tokyo Institute of Technology, Japan

- Abstract:
The increased complexity of parallel applications on modern parallel platforms (e.g. multicore/manycore, distributed or hybrid) requires more insight into development processes, and necessitates the use of advanced methods and techniques supporting developers in creating parallel applications or parallelizing and reengineering sequential legacy applications. We aim to advance the state of the art in different phases of parallel software development, covering software engineering aspects such as requirements engineering and software specification; design and implementation; program analysis, profiling and tuning; testing and debugging.

**************************************************************
SMART - Workshop on Smart Software Strategies
http://conf.researchr.org/track/SmartSoftwareStrategies2015/SmartSoftwareStrategies2015

Papers: October 2, 2015

- Organizers:
Steven D. Fraser, Independent Consultant, USA
Dennis Mancl, Alcatel-Lucent, USA
Bill Opdyke, JP Morgan Chase & Co, USA

- Abstract:
We should learn from the past – to use what we learn for the next problem. What can we learn from the experiences of Y2K? There are some lessons about software design and software maintenance that we might apply to the next wave of software and technology:

Y2K bugs: In the late 1990s, software developers and managers were furiously working to analyze and fix potential “Y2K bugs.” We all knew that there were software applications that might fail on January 1, 2000, but no one was sure how we would manage to fix all of these defects in time.
Today’s “smart” technologies: Fifteen years later, we are at the threshold of a new era of software – smart phones, wearable technology, digital currency, smart automobiles, smart power grids, smart appliances. How should we prepare for this wave? Should we be thinking ahead, should we be anticipating some of the potential risks and latent defects in our smart applications and smart support software for a software-driven future world?
What advances in software analysis, design, coding, and testing will we need to do reduce our exposure to defects, unintended side effects, and malicious mischief? We might look to the past – to the biggest concentrated effort to clean up and modernize software on a worldwide scale. Are there some lessons we can learn from “Y2K remediation activities” of the 1990s?

**************************************************************
WODA - 13th International Workshop on Dynamic Analysis
http://2015.splashcon.org/track/woda2015

Papers: August 7, 2015

- Organizers:
Harry Xu, University of California, Irvine, USA
Walter Binder, University of Lugano, Switzerland
Yudi Zheng, University of Lugano, Switzerland

- Abstract:
Dynamic analysis is widely used in software development to understand various run-time properties of a program. Dynamic analysis includes both offline techniques, which operate on some captured representation of the program's behavior (e.g., a trace), and run-time techniques, which analyze the behavior on the fly, while the system is executing. Although inherently incomplete, dynamic analyses can be more precise than their static counterparts and show promise in aiding the understanding, development, and maintenance of robust and reliable large scale systems. Moreover, the data they provide enable statistical inferences to be made about program behavior. Dynamic analysis is playing a central role in the understanding of applications and systems as we grapple with emerging challenges such as systemic runtime bloat, high energy consumption, and the explosion of Big Data. The overall goal of WODA is to bring together researchers and practitioners working in all areas of dynamic analysis to discuss new issues, share results and ongoing work, and foster collaborations. This workshop is a forum for researchers and practitioners interested in the intersection of compilers, programming languages, architecture, software engineering, systems, high-performance computing, performance engineering, machine learning, and data mining for addressing software and system performance. The workshop focuses on developing and studying analytic technologies (e.g., program analysis, statistical analysis, machine learning, data mining, visualization) applied on various software or system artifacts (e.g., production systems, tests, program traces, system logs) to address issues in software and system reliability, dependability, performance, and scalability.

/************************************************************************************/

## Research vs implementation, theory vs practice, and LtU

There's a conflict between doing research and creating usable programming languages, and different people have different interests.
However, some LtU regulars seem to believe (some variation of) PL research is somehow pointless. (I won't try to offer an exact summary, it's too hard, so this might well be a strawman).

Instead of discussing this inside other topic, it seems this topic deserves its own thread, because the question is interesting. I'm not sure there's something new to say on the topic — this is an old discussion. And I guess that some of us will still not be personally interested in research. But I'd like to not hear the wrong arguments against research. I don't want to hear that research will never be useful in practice. I'm fine with hearing, say, that if you want something now, theoretical research is often not what you should look into — theoretical researchers figure out what you should use in a few years or decades.

## inline vs scatter/gather separate annotation

I want to explore a "what if?" question that involves separating aspects of code that are normally adjacent in programming languages, in the sense of being nearby in syntax and grammar. What if some parts are specified elsewhere? Remote specs might augment or replace local specs in code, when compiled against a particular build target, or when transpiled to a new inline representation where everything is a local spec again.

(What do I mean by inline? Roughly speaking, some contiguous sequence of local tokens in a legal grammar order. In a programming language, keywords are usually inline, modifying the meaning of source code nearby, per the semantics of grammar used.)

One metaphor that seems applicable is the idea of styles used in document text markup. The same way you can separate text styles in cascading style sheets from the documents using it, we might separate abstractions of code application and specialization from source code using it. For example, if you wanted to support a meta-object protocol (mop), a spec for what the mop means locally might be defined somewhere else, and applied only at compile or transpile time. All kinds of instrumentation for logging, profiling, and debugging, etc, might be put somewhere else where it interferes less with the basic stuff.

One objective would be to isolate accidental noisy stuff from essential basics, while another would be enabling replacement and update in new versions without updating the old original. When you do this to types of variables, you get something like generics.

You would want different parts of a code base to see different views, applying different styles and annotations to the same original. One part of a code tree might have permission to alter certain data structures, and see data types involved as mutable, while another part of the code tree sees only immutable types that cause compile time errors on any attempt to call API that would modify state.

Note when important information becomes separated, this amounts to a form of obfuscation. (Witness C switch statements turned into C++ virtual method calls that distribute each case into whatever file implements each relevant method.) If you use scatter/gather on code annotations, it's easy for a compiler to gather, but hard on a human being. So you would want to support generation of views with everything gathered in more inline form, just for human consumption.

I've been thinking about this idea a lot, but it's seldom a topic of conversation, so that's mainly why I bring the idea up, just to see if folks have interesting comments.

[Edit: I'm looking for comments on splitting or scattering code declarations, rules, and constraints, where gather in this context is code rewriting. While the scatter/gather metaphor comes from doing this to data, I'm talking about doing it to code. Applications to dataflow aren't relevant unless input and output is code. There's isn't a good word that means the opposite of inline, unless you want to go with plain English apart.]

## Recursive Descent Parser Generators

I'm writing a parser generator, to avoid being TLDR (which is most of my messages) I wanted to ask if anyone knows of other LL(*) parser generators, what I should aim for performance wise (what's acceptable) and if you've had experience writing something similar what's one of the toughest nuts to crack on this style of parser?

For me (more than one thing) :

1. Generating Parsers with unbound look-ahead uses a lot of memory to do statically so none (or very little) of the processing is done during run-time.
2. Follow predictions are a PITA: you have to analyze all possible parse paths coming into the given rule, walk the context stack to disambiguate the offending lock(s), and keep stepping ahead and only accept if the parent contexts can parse and that state can also accept (this was a nightmare, but I think I have it...?) I'm writing the prediction discriminator logic now (my most recent task.) Dangling else isn't an issue because iirc it is aware that the parent context is on an edge state once the current rule exits, and I apply to the maximal munch principle.
3. Lexical Ambiguities: I'm a glutton for punishment, I used includes to allow complex grammars to span multiple files. To avoid issues with parse order and precedence on the user's side (you can still specify which trumps the other, but this trumping order is 'always on' if used) I allow for lexical ambiguities to create new parse states and following those ambiguity identities you can figure out which path was actually intended.
4. To solve the memory issue, I decided that I would use: a symbol stack, an active rule context, recursive descent, and reductions.
• Reductions some of solve the issue of memory by identifying where multiple paths of a prediction all enter the same rule on the same state, parsing that rule, and evaluate what comes after that rule. This abates some of the issues with the look-ahead requirements, but adds more complexity when the follow-state of that rule is ambiguous with the prediction! I haven't even gotten to this issue :(
5. AST Generation: making this look easy is the hard part. It should just work (I will focus on refining it once everything else is done.)
6. It's so easy to create grammars that are simple but yield an exponential state explosion. I need to do more research to detect this ahead of time so I don't waste time on processing something useless, so the user has a better experience than 'Out of Memory Exception'.

If this ends up working as intended, I'll be astonished, because when I started this eight years ago, I didn't have an effing clue. I still probably don't, but I at least know what I want to do now. The grammars define no semantic predicates, nor actions on lexical matches, so the generator has to do all the work. So far (without error context) it's 50-80 times faster than my own hand-written parser for its own language, until I found that I wasn't handling lexical ambiguities on follow states and now have to fully implement them to do a proper comparison.

Edit:
The goal with this LL(*) approach is there is very little back-tracking employed. The only time it should need to is when it's handling left-recursive rules and it has no choice to do so because it has to fall to a weaker prediction mechanism to yield a preliminary identity onto the stack that it can use to move forward, then rinse and repeat.

Edit 2: Redacting the following, turns out the issue is more complex :) The sample I gave it had zero issues with :(
'No Alt Indirect Left Recursion' is when you have something like:
A ::= B | C;
B ::= A '[' ']';
C ::= "Other";

Without code to properly identify these 'No Alt Indirect Left Recursion' states, it will recurse infinitely because there's no fall-back to choose first, it would always predict 'B' if it has: Other[].

## New paper: Theory of Programs

A simple mathematical framework, based on elementary set theory, to cover programming concepts.

See http://bit.ly/1CkZBPj.

-- Bertrand Meyer

## Lamport: Interprocess Communication

Something that may be pertinent to the recent (lengthy) discussion of the deep implementation details of interprocess communication is Leslie Lamport's interesting discussion of how to implement various kinds of interprocess communication. The bulk of the paper deals with various kinds of shared registers, which are taken as the primitives through which messages are passed. Starting from non-atomic operations, Lamport shows how to build atomic operations that allow message-passing to occur.

"At a low level, message passing is often considered to be a form of transient communication between asynchronous processes. However, a closer examination of asynchronous message passing reveals that it involves a persistent communication. Messages are placed in a buffer that is periodically tested by the receiver. Viewed at a low level, message passing is typically accomplished by putting a message in a buffer and setting an interrupt bit that is tested on every machine instruction.
...
Hardware implementations of asynchronous communication often make assumptions about the relative speeds of the communicating processes. Such assumptions can lead to simplifications. For example, the problem of constructing an atomic register, discussed below, is shown to be easily solved by assuming that two successive reads of a register cannot be concurrent with a single write. If one knows how long a write can take, a delay can be added between successive reads to ensure that this assumption holds. No such assumptions are made here about process speeds. The results therefore apply even to communication between processes of vastly differing speeds."

## Some New Directions for ACP Research

This paper at ArXiv.org lists some new directions for research related to the Algebra of Communicating Processes (ACP). Most of these directions have been inspired by work on SubScript, an ACP based extension to the programming language Scala. SubScript applies several new ideas that build on ACP, but currently these lack formal treatment. Some of these new ideas are rather fundamental. E.g. it appears that the theory of ACP may well apply to structures of any kind of items, rather than to just processes. The aim of this list is to raise awareness of the research community about these new ideas; this could help both the research area and the programming language SubScript.

## Practical Principled FRP: Forget the past, change the future, FRPNow!

A new ICFP 15 paper by Ploeg and Claessen; abstract:

We present a new interface for practical Functional Reactive Programming (FRP) that (1) is close in spirit to the original FRP ideas,
(2) does not have the original space-leak problems, without using arrows or advanced types, and (3) provides a simple and expressive way for performing I/O actions from FRP code. We also provide a denotational semantics for this new interface, and a technique (using Kripke logical relations) for reasoning about which FRP functions may “forget their past”, i.e. which functions do not have an inherent space-leak. Finally, we show how we have implemented this interface as a Haskell library called FRPNow.

## Who can make LtU2?

If we had voting on things (a la reddit, slashdot, hacker news, etc.) I think we'd all be better off. There are technological things which won't outright fix everything, but should greatly help I should think.

But we'd need somebody who can actually set that stuff up.

## Bi-simulation in security auditing

Bi-simulation has been an important topic in Computer Science (e.g. intensely studied for process calculi) which may be applicable to an important emerging issue for computer engineering, namely security auditing.

See bottom of page 3 of Distributed Public Recording: Providing Security Without the Risks of Mandatory Backdoors