[ecoop-info] ECOOP 2016 - Workshops - Call for Papers

Emilio Coppa coppa at di.uniroma1.it
Tue Mar 15 21:40:44 CET 2016

ECOOP 2016 will host an exciting array of 11 workshops on a variety of
topics in computing:

 - COP       8th International Workshop on Context-Oriented Programming
             Submission deadline on April 15, 2016

 - FTfJP     18th Workshop on Formal Techniques for Java-like Programs
             Submission deadline on April 15, 2016

 - GRACE     1st Workshop on the Grace Programming Language

 - ICOOOLPS  11th Implementation, Compilation, Optimization of
Object-Oriented Languages, Programs and Systems Workshop
             Submission deadline on April 15, 2016

 - IWACO     7th International Workshop on Aliasing, Capabilities and
             Submission deadline on April 22, 2016

 - JSTools   5th Annual Workshop on Tools for JavaScript Analysis
             Submission deadline on May 10, 2016

 - LIVE      1st Workshop on Live Programming Systems
             Submission deadline on April 15, 2016

 - PMLDC     1st Workshop on Programming Models and Languages for
Distributed Computing
             Submission deadline on May 6, 2016

 - PX        1st Edition of the Programming Experience Workshop
             Submission deadline on April 15, 2016

 - STOP      2nd Edition of the Script To Program Evolution Workshop

 - VORTEX    1st VORTEX Workshop on Runtime Verification
             Submission deadline on April 30, 2016

Calls for papers of these workshops are included in this message.


COP 2016 - 8th International Workshop on Context-Oriented Programming

July 19 (Tue), 2016. Co-located with ECOOP 2016 in Rome

===  Introduction  ===

Context information plays an increasingly important role in our
information-centric world. Software systems must adapt to changing contexts
over time, and must change even while they are running. Unfortunately,
mainstream programming languages and development environments do not
support this kind of dynamic change very well, leading developers to
implementing complex designs to anticipate various dimensions of

Context-oriented Programming (COP) directly supports variability depending
on a wide range of dynamic attributes. In effect, it should be possible to
dispatch run-time behavior on any property of the execution context. By
now, several researchers have been working on notions approaching that
idea, and implementations ranging from first prototypes to mature platform
extensions used in commercial deployments have illustrated how
multidimensional dispatch can indeed be supported effectively to achieve
expressive run-time variation in behavior.

=== Topics ===

The previous editions of this workshop (ECOOP 2009–2015) have shown to be
well-received. The goal of the 8th Workshop on Context-oriented Programming
(COP-16) is to further establish context orientation as a common thread to
language design, application development, and system support. Topics of
interest include but are not limited to:

 * Interesting application domains and scenarios
 * Programming language abstractions for Context-oriented Programming (e.g.
dynamic scoping, roles, traits, prototype-based extensions)
 * Theoretical foundations for Context-oriented Programming (e.g.
semantics, type systems)
 * Configuration languages (e.g. feature description interpreters,
transformational approaches)
 * Interaction between non-functional programming concerns and
Context-oriented Programming (e.g. security, persistence, concurrency,
 * Interaction with other paradigms: event-based and reactive programming,
object-oriented programming.
 * Modularization approaches for Context-oriented Programming (e.g.
aspects, modules, layers, plugins).
 * Guidelines to include Context-oriented Programming in programs (e.g.
best practices, patterns)
 * Runtime support for Context-oriented Programming (e.g. reflection,
dynamic binding)
 * Implementation issues such as optimization, VM support, JIT compilation
etc. for Context-oriented Programming
 * Tool support (e.g. design tools, IDEs, debuggers).

=== Submissions ===

COP invites submissions of high-quality papers reporting original research,
or describing innovative contributions to, or experience with
Context-oriented Programming, its implementation, and application. Papers
that depart significantly from established ideas and practices are
particularly welcome.

Submissions must not have been published previously and must not be under
review for any another refereed event or publication.

The program committee will evaluate each contributed paper based on its
relevance, significance, clarity, and originality. Accepted papers will be
published in the ACM Digital Library.

Papers are to be submitted via EasyChair (
https://easychair.org/conferences/?conf=cop2016). Papers must be written in
English, be provided as PDF documents, and follow the ACM SIGPLAN
Conference Format (10 point font, Times New Roman font family, numeric
citation style, http://www.sigplan.org/Resources/Author/). They should not
exceed 6 pages.

===  Important Dates ===

Submissions: April 15, 2016
Notifications: May 13, 2016
COP-16: July 19, 2016

=== Organizers ===

Guido Salvaneschi, Technische Universität Darmstadt, Germany
Robert Hirschfeld, Hasso Plattner Institute, University of Potsdam, Germany
Atsushi Igarashi, Kyoto University, Japan
Hidehiko Masuhara, Tokyo Institute of Technology, Japan

=== Program Committee ===

Tomoyuki Aotani, Tokyo Institute of Technology, Japan
Dave Clarke, Uppsala University, Sweden and KU Leuven, Belgium
Rocco De Nicola, IMT Institute for Advanced Studies Lucca, Italy
Coen De Roover, Vrije Universiteit Brussel, Belgium
Pierpaolo Degano, University of Pisa, Italy
Gorel Hedin, Lund University, Sweden
Tetsuo Kamina, Ritsumeikan University, Japan
Jens Lincke, Hasso Plattner Institute, University of Potsdam, Germany
Harold Ossher, IBM, United States
Mario Südholt - École des Mines de Nantes, France
Didier Verna, EPITA / LRDE, France


FTfJP 2016 - 18th Workshop on Formal Techniques for Java-like Programs

Co-located with ECOOP 2016 - 19 July 2016, Rome, Italy

=== Important Dates ===

Submission deadline: April 15, 2016 (AoE)
Notification of acceptance: May 13
Workshop: July 19

=== Overview ===

Formal techniques can help analyze programs, precisely describe program
behavior, and verify program properties.  Languages such as Java, C#,
and Scala are interesting targets for formal techniques due to their
ubiquity and large installed base, stable and well-defined interfaces
and platforms, powerful (but also complex) libraries. The rising
deployment in smart cards and mobile computing raises concerns about
security and demands new methods to counter new possibilities for abuse.

Work on formal techniques and tools and work on the formal underpinnings
of programming languages themselves naturally complement each other.
This workshop aims to bring together people working in both fields, on
topics such as:

 * Language semantics
 * Specification techniques and languages
 * Verification of program properties
 * Verification logics
 * Dynamic program analysis
 * Static program analysis
 * Type systems
 * Security

The workshop welcomes a wide range of submissions (see below), such as
technical contributions, case studies, challenge proposals, and position
papers. Just as the number and the feature set of Java-like languages is
expanding, the term "Java-like" is also to be understood broadly.

=== Submissions and Proceedings ===

Contributions are sought on open questions, new developments, or
interesting new applications of formal techniques in the context of Java
or similar languages. Contributions are possible in two formats:

* full  papers (up to 6 pages in the ACM 2-column style)
* short papers (up to 2 pages in the ACM 2-column style)

Submissions should strive not merely to present completely finished
work, but also raise challenging open problems or propose speculative
new approaches. Case studies, reports from competitions, and other
experience reports  should identify lessons learned, reflect on the
state of the art, or clearly motivate further research.

We particularly welcome (clearly marked) position and discussion papers
that may simply present suitable topics for discussion at the workshop,
or raise issues that you feel deserve the attention of the research
community. Examples include future work identified from existing
research, potential PhD proposals, and specific well-motivated
challenges within the workshop scope.

Contributions will be formally reviewed for originality, relevance, and
the potential to generate interesting discussions. Accepted papers will
have the option of being published in the ACM Digital Library. In
addition, depending on the nature of the contributions, we may be
organizing a special journal issue as a follow-up to the workshop, as
has been done for some of the previous FTfJP workshops. Contributions
must be in English, in PDF format, and follow the format outlined above.
Authors of accepted papers are required to ensure that at least one of
them will be present at the workshop.

Instructions for submitting can be found on the workshop site:

=== Program Committee ===

Davide Ancona, Università degli studi di Genova, IT
Richard Bubel, Darmstadt Technical University, DE
Delphine Demange, University of Rennes 1, FR
Pietro Ferrara, Julia Srl, IT
Carlo Furia, Chalmers Techincal University, SE
Vladimir Klebanov (chair), Karlsruhe Institute of Technology, DE
Andrzej Murawski, University of Warwick, UK
Gustavo Petri, Université Paris Diderot-Paris 7, FR
Nadia Polikarpova, MIT, US
Alex Potanin, Victoria University of Wellington, NZ
Bent Thomsen, Aalborg Universitet, DK
Oksana Tkachuk, NASA Ames, US

=== Contact ===

klebanov at kit.edu


GRACE 2016 - 1st Workshop on the Grace Programming Language


The Grace Object-Oriented Educational Programming Language design project
was started at ECOOP in Slovenia to design a new OO language for teaching
and research. This workshop will allow the core project team to present
their results back to the community: a specification, reference
implementation, and experience teaching with Grace. The workshop will also
allow the Grace project to gain feedback on the current design and
implementation, and to plan for the future.

We invite short research papers, position papers, and tool demonstrations
in areas such as:

 * experience implementing Grace
 * critiques and feedback on the Grace specification
 * proposed extensions to Grace
 * lessons that Grace may take from other related language projects (such
as Pyret, Racket, BlueJ, Wyvern, Stride,TouchDevelop, TrumpScript etc)
 * lessons that Grace may take from language workbench implementation tools

Expressions of interest to submit position papers or make presentations
should be emailed to the organisers.


ICOOOLPS 2016 - 11th Workshop on Implementation, Compilation, Optimization
of OO Languages, Programs and Systems

Co-located with ECOOP. July 18, 2016, Rome, Italy
Twitter: @ICOOOLPS

The ICOOOLPS workshop series brings together researchers and practitioners
working in the field of language implementation and optimization. The goal
the workshop is to discuss emerging problems and research directions as
well as
new solutions to classic performance challenges.

The topics of interest for the workshop include techniques for the
implementation and optimization of a wide range of languages including but
limited to object-oriented ones. Furthermore, meta-compilation techniques or
language-agnostic approaches are welcome, too. A non-exclusive list of

 - implementation and optimization of fundamental languages features (from
   automatic memory management to zero-overhead metaprogramming)
 - runtime systems technology (libraries, virtual machines)
 - static, adaptive, and speculative optimizations and compiler techniques
 - meta-compilation techniques and language-agnostic approaches for the
   efficient implementation of languages
 - compilers (intermediate representations, offline and online
 - empirical studies on language usage, benchmark design, and benchmarking
 - resource-sensitive systems (real-time, low power, mobile, cloud)
 - studies on design choices and tradeoffs (dynamic vs. static compilation,
   heuristics vs. programmer input,...)
 - tooling support, debuggability and observability of languages as well as
   their implementations

=== Workshop Format and Submissions ===

This workshop welcomes the presentation and discussion of new ideas and
emerging problems that give a chance for interaction and exchange. More
work is welcome as part of a mini-conference format, too. We aim to
interactive brainstorming and demonstration sessions between the formal
presentations to foster an active exchange of ideas.

The workshop papers will be published either in the ACM DL or in the
LIPIcs ECOOP Workshop proceedings. Until further notice, please use the ACM
SIGPLAN template with a 10pt font size:

  - position and work-in-progress paper: 1-4 pages
  - technical paper: max. 10 pages
  - demos and posters: 1-page abstract

For the submission, please use the HotCRP system:

=== Important Dates ===

 - abstract submission: April 11, 2016
 - paper submission: April 15, 2016
 - notification: May 13, 2016
 - all deadlines: Anywhere on Earth (AoE), i.e., GMT/UTC−12:00 hour

 - workshop: July 18th, 2016

=== Program Committee ===

Edd Barrett, King’s College London, UK
Clement Bera, Inria Lille, France
Maxime Chevalier-Boisvert, Université de Montréal, Canada
Tim Felgentreff, Hasso Plattner Institute, Germany
Roland Ducournau, LIRMM, Université de Montpellier, France
Elisa Gonzalez Boix, Vrije Universiteit Brussel, Belgium
David Gregg, Trinity College Dublin, Ireland
Matthias Grimmer, Johannes Kepler University Linz, Austria
Michael Haupt, Oracle, Germany
Richard Jones, University of Kent, UK
Tomas Kalibera, Northeastern University, USA
Hidehiko Masuhara, Tokyo Institute of Technology, Japan
Tiark Rompf, Purdue University, USA
Jennifer B. Sartor, Ghent University, Belgium
Sam Tobin-Hochstadt, Indiana University, USA

=== Workshop Organizers ===

  Stefan Marr, Johannes Kepler University Linz, Austria
  Eric Jul, University of Oslo, Norway

For questions or concerns, please mail to stefan.marr at jku.at or contact
via https://twitter.com/icooolps.


IWACO 2016 - 7th IWACO International Workshop on Aliasing, Capabilities and

Co-located with ECOOP
Monday July 18th, 2016, Rome, Italy

Reasoning about shared state in imperative programs is challenging. The
existence of aliases, in particular, compromises modular reasoning, making
imperative programs hard to understand, maintain, and analyze. These
difficulties become even aggravated in a concurrent context. On the other
hand, aliasing is a very powerful feature and allows for efficient
implementations of data structures, for example.

To address those challenges, techniques have been introduced for describing
and reasoning about stateful programs and for restricting, analyzing, and
preventing aliases. Approaches are based on ownership, capabilities,
separation logic, linear logic, uniqueness, sharing control, escape
analysis, argument independence, read-only references, linear references,
effects systems, and access control mechanisms.

The workshop will generally address the question how to reason about
stateful (sequential or concurrent) programs. In particular, we will
consider the following issues (among others):
models, type and other formal systems, programming language mechanisms,
analysis and design techniques, patterns and notations for expressing
ownership, aliasing, capabilities, uniqueness, and related topics;
optimization techniques, analysis algorithms, libraries, applications, and
novel approaches exploiting ownership, aliasing, capabilities, uniqueness,
and related topics; empirical studies of programs or experience reports
from programming systems designed with these issues in mind; programming
logics that deal with aliasing and/or shared state, or use ownership,
capabilities or resourcing; applications of any of these techniques to a
concurrent setting.

We encourage not only submissions presenting original research results, but
also papers that attempt to establish links between different approaches
and/or papers that include survey material. Original research results
should be clearly described. Paper selection will be based on the quality
of the submitted material. Please direct any questions regarding the
workshop's scope to the workshop organizer.

Both full papers and short papers in the ACM 2-column style are welcome,
with a maximum of 15 pages for full papers and 8 pages for short papers.
Papers are strongly encouraged to be well below the maximum length. All
submissions will be reviewed by the program committee. The accepted papers,
after rework by the authors, will be made publicly available as informal
proceedings on the workshop web page.

For the submission, please use the HotCRP/EasyChair system:

=== Important Dates ===

• Paper submission: April 22rd, 2016
• Notification: May 20th, 2016
• All deadlines: Anywhere on Earth (AoE), i.e., GMT/UTC−12:00 hour

=== Workshop Programming Committee ===

Paley Li, Northeastern University (organizer)
Alexander Summers, ETH Zurich
Sylvan Clebsch, Imperial College London
Tobias Wrigstad, Uppsala University
Marieke Huisman, University of Twente
Hridesh Rajan, Iowa State University
Bart Jacobs, KU Leuven
Felix Klock, Mozilla Corporation
Colin Gordon, Drexel University
Marwan Abi-Antoun, Wayne State University


JSTools 2016 - 5th Annual Workshop on Tools for JavaScript Analysis


JavaScript has become ubiquitous: not only is it the lingua franca of
the Web platform, but it is also increasingly being used for developing
server-side applications and for writing platform-independent mobile
applications. Consequently, it is now the focus of many strands of
research work in static and dynamic program analysis, automated testing,
security analysis and refactoring, to name just a few. At the same time,
there is a strong interest from industry in providing better development
tools for JavaScript programmers, such as refactoring tools, debuggers,
and smart IDEs.

All these projects need to overcome similar challenges: How to delineate
the program in a dynamic setting like a web page, how to deal with the
extensive native APIs and framework libraries most JavaScript code
relies on, how to handle non-determinism of concurrency and asynchronous
events, and what to do about the language’s extraordinarily dynamic
features like eval or reflection over object structure.

JSTools will bring together participants from academia and industry
working on analysis of JavaScript and its dialects to share ideas and
problems, with a focus on presentations of shareable infrastructure
created by the participants. We also aim to involve developers working
on JavaScript dialects such as TypeScript to share their perspective.

In addition to a set of invited speakers, JSTools welcomes submissions
of work on this field. You may submit a paper, an abstract for a talk,
or a talk abstract together with a supporting position paper. As the
title of the workshop suggests, we also welcome presentations and
demonstrations of state of the art tools for JavaScript. To submit,
please e-mail submissions to the organizers. The workshop does not have
formal proceedings, but if desired, slides from talks and/or a paper
will be put online on the workshop web site. The organizing committee
will referee submissions for relevance. We are looking for ongoing work
more than finished research projects. Additional expert opinions may be
requested from the expected participants.

Submission deadline:
  May 10, 2016

Template for submissions (recommended but not mandatory):

Further information:


LIVE 2016 - 2nd Workshop on Live Programming Systems


LIVE 2016 aims to bring together people who are interested in live
programming. Live programming systems abandon the traditional
edit-compile-run cycle in favor of fluid user experiences that encourage
powerful new ways of “thinking to code” and enable programmers to see and
understand their program executions. Programming today requires much mental
effort with broken stuttering feedback loops: programmers carefully plan
their abstractions, simulating program execution in their heads; the
computer is merely a receptacle for the resulting code with a means of
executing that code. Live programming aims to create a tighter more fluid
feedback loop between the programmer and computer, allowing the computer to
augment more of the programming process by, for example, allowing
programmers to progressively mine abstractions from concrete examples and
providing continuous feedback about how their code will execute. Meanwhile,
under the radar of the PL community at large, a nascent community has
formed around the related idea of “live coding”—live audiovisual
performances which use computers and algorithms as instruments and include
live audiences in their programming experiences.

We encourage short research papers, position papers, web essays, tool
demonstrations (as videos), and performance proposals in areas such as:

 * Recent work in REPLs, language environments , code playgrounds, and
interactive notebooks.
 * Live visual programming.
 * Programming by example.
 * Programming tools for creative experiences and interactive audio visual
 * Live programming as a learning aid.
 * Fluid debugging experiences
 * Language design in support of the above.

Submissions will go through EasyChair:

Papers and essays must be written in English and provided as PDF documents.
As a recommendation, papers should be around 5 pages and videos should be
5-10 minutes in length; other non-paper submissions should consume no more
than 30 minutes of a casual reader’s time. However, papers up to 10 pages
and videos up to 20 minutes are also welcome. Video and non-paper
submissions can by listed as URLs (e.g. to a web page, file locker, or
streaming site) in the submission’s abstract. At the author’s discretion,
workshop articles can be published using an institutional ISBN with full
support for open access.

Any questions or trouble with submitting, please contact
smcdirm at microsoft.com.


PMLDC 2016 - First Workshop on Programming Models and Languages for
Distributed Computing

Co-located with ECOOP 2016, Rome, Italy
Date: July 17th, 2016

Whether you are programming a rich web application in JavaScript that
mutates state in the client’s browser, or you are building a massively
deployed mobile application that will operate with client state at the
device, it’s undeniable that you are building a distributed system!

Two major challenges of programming distributed systems are concurrency and
partial failure. Concurrency of operations can introduce accidental
nondeterminism: computations may result in different outcomes with the same
inputs given scheduling differences in the underlying system unless a
synchronization mechanism is used to enforce some order. Synchronization is
typically expensive, and reduces the efficiency of user applications.
Partial failure, or the failure of one or more components in a distributed
system at one time, introduces the challenge of knowing, when an operation
fails, which components of the operation completed successfully. To solve
these problems in practice on an unreliable, asynchronous network, atomic
commit protocols and timeouts as failure detection are typically used.

Because of these challenges, early approaches to providing programming
abstractions for distributed computing that ignored them were inherently
misguided: the canonical example being the Remote Procedure Call, still
widely deployed in industry.

The goal of this workshop is to discuss new approaches to distributed
programming that provide efficient execution and the elimination of
accidental nondeterminism resulting from concurrency and partial failure.
It will bring together both practitioners and theoreticians from many
disciplines: database theory, distributed systems, systems programming,
programming languages, data-centric programming, web application
development, and verification, to discuss the state-of-the-art of
distributed programming, advancement of the state-of-the-art and paths
forward to better application of theory in practice.

The main objectives of this workshop are the following:
 * To review the state-of-the-art research in languages, models, and
systems for distributed programming;
 * To identify areas of critical need where research can advance the state
of the art;
 * To create a forum for discussion;
 * To present open problems from practitioners with an aim towards
motivating academic research on relevant problems faced by industry.

In the spirit of both ECOOP and Curry On, this workshop aims at favoring a
multidisciplinary perspective by bringing together researchers, developers,
and practitioners from both academia and industry.

=== Submission Guidelines ===

We solicit proposals for contributed talks. We recommend preparing
proposals of 2 pages, in ACM 2 column SIGPLAN style, written in English and
in PDF format. However, we will accept longer proposals or submissions to
other conferences, under the understanding that PC members are only
expected to read the first two pages of such longer submissions. Authors
with accepted papers will have the opportunity to have their submission
published on the ACM Digital Library.

=== Important Dates ===

 * Paper submission: May 6, 2016 (any place on Earth)
 * Authors notification: June 10, 2016
 * Final version: June 17, 2016

=== Program Chairs ===

Heather Miller (Ecole Polytechnique Federale de Lausanne)
Christopher Meiklejohn (Université catholique de Louvain)

=== Program Committee ===

Peter Alvaro (University of California, Santa Cruz)
Annette Bieniusa (Technischen Universität Kaiserslautern)
Sebastian Burckhardt (Microsoft Research)
Natalia Chechina (University of Glasgow)
Neil Conway (Mesosphere)
Carla Ferreira (Universidade Nova Lisboa)
Alexey Gotsman (IMDEA Software Institute)
Seyed Hossein Haeri (Université catholique de Louvain)
Philipp Haller (KTH Royal Institute of Technology)
Carl Lerche (Independent Consultant)
Rita Loogen (University of Marburg)
Rodrigo Rodrigues (Instituto Superior Técnico, University of Lisboa &
Ali Shoker (HASLab/INESC TEC & University of Minho)
Phil Trinder (University of Glasgow)
José Valim (Plataformatec)
Peter Van Roy (Université catholique de Louvain)
Hongseok Yang (University of Oxford)


PX 2016 - 1st Edition of the Programming Experience Workshop

July 18 (Mon), 2016
Co-located with ECOOP 2016 in Rome

=== Abstract ===

Imagine a software development task. Some sort of requirements and
specification including performance goals and perhaps a platform and
programming language. A group of developers head into a vast workroom.

<crossfade to developers exiting the vast workroom>

The Programming Experience Workshop is about what happens in that room when
one or a couple of programmers sit down in front of computers and produce
code, especially when it's exploratory programming. Do they create text
that is transformed into running behavior (the old way), or do they operate
on behavior directly ("liveness"); are they exploring the live domain to
understand the true nature of the requirements; are they like authors
creating new worlds; does visualization matter; is the experience
immediate, immersive, vivid and continuous; do fluency, literacy, and
learning matter; do they build tools, meta-tools; are they creating
languages to express new concepts quickly and easily; and curiously, is joy
relevant to the experience?

Correctness, performance, standard tools, foundations, and text-as-program
are important traditional research areas, but the experience of programming
and how to improve and evolve it are the focus of this workshop.

=== Submissions ===

Submissions are solicited for Programming Experience 2016 (PX/16). The
thrust of the workshop is to explore the human experience of
programming—what it feels like to program, or more accurately, what it
should feel like. The technical topics include exploratory programming,
live programming, authoring, representation of active content,
visualization, navigation, modularity mechanisms, immediacy, literacy,
fluency, learning, tool building, and language engineering.

Submissions by academics, professional programmers, and non-professional
programmer are welcome. Submissions can be in any form and format,
including but not limited to papers, presentations, demos, videos, panels,
debates, essays, writers' workshops, and art. Presentation slots will be
between 30 minutes and one hour, depending on quality, form, and relevance
to the workshop. Submissions directed toward publication should be so
marked, and the program committee will engage in peer review for all such
papers. Video publication will be arranged.

All artifacts are to be submitted via EasyChair (
https://easychair.org/conferences/?conf=px16). Papers and essays must be
written in English, provided as PDF documents, and follow the ACM SIGPLAN
Conference Format (10 point font, Times New Roman font family, numeric
citation style, http://www.sigplan.org/Resources/Author/).

There is no page limit on submitted papers and essays. It is, however, the
responsibility of the authors to keep the reviewers interested and
motivated to read the paper. Reviewers are under no obligation to read all
or even a substantial portion of a paper or essay if they do not find the
initial part of it interesting.

=== Format ===

Paper presentations, presentations without papers, live demonstrations,
performances, videos, panel discussions, debates, writers' workshops, art
galleries, dramatic readings.

=== Review ===

Papers and essays labeled as publications will undergo standard peer
review; other submissions will be reviewed for relevance and quality;
shepherding will be available.

=== Important dates ===

Submissions: April 15, 2016 (anywhere in the world)
Notifications: May 13, 2016
PX/16: July 18, 2016

=== Publication ===

Papers and essays accepted through peer review will be published as part of
ACM's Digital Library; video publication on Vimeo or other streaming site;
other publication on the PX workshop website.

=== Organizers ===

Robert Hirschfeld, Hasso Plattner Institute, University of Potsdam, Germany
Richard P. Gabriel, Dreamsongs and IBM Almaden Research Center, United
Hidehiko Masuhara, Mathematical and Computing Science, Tokyo Institute of
Technology, Japan

=== Program committee ===

Carl Friedrich Bolz, King's College London, United Kingdom
Gilad Bracha, Google, United States
Andrew Bragdon, Twitter, United States
Jonathan Edwards, CDG Labs, United States
Jun Kato, National Institute of Advanced Industrial Science and Technology,
Cristina Videira Lopes, University of California at Irvine, United States
Yoshiki Ohshima, Viewpoints Research Institute, United States
Michael Perscheid, SAP Innovation Center, Germany
Guido Salvaneschi, TU Darmstadt, Germany
Marcel Taeumel, Hasso Plattner Institute, University of Potsdam, Germany
Alessandro Warth, SAP Labs, United States

=== Flyer ===



STOP 2016 - 3rd Script To Program Evolution Workshop


In recent years there has been increased interest in scripting languages,
the migration from scripts to large programs, and the interplay between
typed and untyped code. New languages such as TypeScript, Hack, Dart, Typed
Racket, and GradualTalk, to name a few, have begun to explore the
integration of dynamic and static typing within the same language.

Scripting languages are lightweight, dynamic programming languages designed
to maximize productivity by offering high-level abstractions and reducing
the syntactic overhead found in most system’s languages. The rising
popularity of scripting languages has many underlying causes: they allow
partial execution of programs, permitting easy unit testing, interactive
experimentation, and even demoing of software at all times; their support
for powerful and flexible high-level datatypes and dynamic typing admits
quick interim solutions that can later be revised; etc. In short, scripting
languages optimize developement time rather than machine time, a good
approach early in the software development life cycle.

However, once the understanding of the system has reached a critical point
and requirements have stabilized, scripting languages become less
appealing. The compromises made to optimize development time make it harder
to reason about program correctness, harder to do semantic-preserving
refactorings, and harder to optimize execution speed. The lack of type
information makes the code harder to navigate.

The concept of gradual typing has been proposed, in which the programmer
controls which portions of the program are dynamically typed and which
portions are statically typed. Over the last decade there has been
significant progress on the theory and practice of gradual typing, but
there are still many open questions and unexplored points in the design

=== Scope ===

The STOP workshop is interested in the evolution of scripts, in the sense
of untyped pieces of code, into safer programs, with more rigid structure
and constrained behavior through the use of gradual typing, contract
checking, extensible languages, refactoring tools, and the like. The goal
is to further the understanding of such systems in practice, and connect
practice and theory. This workshop aims to bring researchers together from
academia and industry for passionate discussion about these topics, and to
promote not only the theory, but practical evalution of these ideas, and
experience reports.

=== Proceedings ===

The accepted papers will be distributed at the workshop in an informal
proceedings. All accepted submissions shall remain available from the
workshop web page.

=== Submission Guidelines ===

Abstracts, position papers, and status reports are welcome. Papers should
be 1-2 pages in standard ACM SIGPLAN format. All submissions will be
reviewed by the program committee. Submit your papers on EasyChair when the
link becomes available at:


VORTEX 2016 - Verification of Objects at RunTime EXecution

Co-located with ECOOP 2016, July 18, Rome, Italy

=== Chairs ===

Davide Ancona, DIBRIS, Università di Genova, Italy
Frank de Boer, CWI, Amsterdam, Netherlands

=== Important Dates ===

All deadlines are at 23:59  AoE (Anywhere on Earth timezone, Howland Island
time, UTC-12h)

Submission deadline: April, 30th
Notification:        May, 28th
Camera-ready:        June, 15th
Workshop:            July, 18th

=== Program Committee ===

Davide Ancona, Università di Genova, Italy (co-chair)
Frank S. de Boer, CWI-Leiden University, Netherlands  (co-chair)
Wolfgang Ahrendt, Chalmers University of Technology, Sweden
Ferruccio Damiani, Università di Torino, Italy
Stijn De Gouw, CWI, Fredhopper, Netherlands
Radu Grosu, Vienna University of Technology, Austria
Klaus Havelund, NASA/Caltech Jet Propulsion Laboratory, USA
Reiner Hähnle, TU Darmstadt, Germany
Jean-Baptiste Jeannin, Samsung Research America, USA
Martin Leucker, University of Lübeck, Germany
Gordon Pace, University of Malta, Malta
Grigore Rosu, University of Illinois at Urbana-Champaign, USA
Gerardo Schneider, University of Gothenburg, Sweden
Tarmo Uustalu, Tallinn University of Technology, Estonia

=== Overview ===s

Runtime verification (RV) is an approach to software verification which is
concerned with monitoring and analysis of software and hardware system

In recent years RV has gained more and more consensus as an effective and
promising approach to ensure software reliability, bridging a gap between
verification, and conventional testing; furthermore, monitoring a system
runtime execution offers additional opportunities for addressing error
self-adaptation, and other issues that go beyond software reliability.

The goal of the first edition of this workshop is to bring together
working on RV for object-oriented languages, and systems, on topics covering
either theoretical, or practical aspects, or, preferably, both.

=== Call for contributions ===

Contributions are solicited on Runtime Verification in the context of
Object-Oriented Programming addressing open questions covering theoretical
and/or practical aspects, presenting new implemented tools, proposing
interesting new applications, or describing real case studies.

Submissions suggesting speculative new approaches, raising challenging
or focusing on problems deemed to be crucial for the research community are
welcome, as well as all contributions covering topics suitable for lively
discussion at the workshop.

Topics of interest include, but are not limited to, the following ones:

 * combination of static and dynamic analyses
 * industrial applications
 * monitor construction and synthesis techniques
 * monitoring concurrent/distributed systems
 * program adaptation
 * runtime enforcement, fault detection, recovery and repair
 * RV for safety and security
 * specification formalisms and formal underpinning of RV
 * specification mining
 * tool development

Contributions will be formally reviewed by at least three reviewers, and
selection will be based on originality, relevance, technical accuracy, and
potential to generate interesting discussions.

=== Submission Instructions ===

Submissions must be in English, in PDF format, and are limited to 6 pages
in the
ACM Proceedings Format (http://www.acm.org/publications/proceedings-template
Papers must be submitted electronically via Easy Chair at

PC members, except for the chairs, are allowed to submit papers, and any
conflict of interest will be properly managed by excluding the involved PC
members from the review and evaluation process.

=== Proceedings and Special Issue ===

Accepted papers will have the option of being published in the ACM Digital

Depending on the quality and the overall number of accepted papers, authors
selected papers will be invited after the workshop to submit an extended
for a special issue hosted by the online open-access Journal Frontiers in
  Specialty Formal Methods

More information about the ecoop-info mailing list