[ecoop-info] <Programming> 2017: Call for workshop, symposium & poster submissions

Tim Molderez tmoldere at vub.ac.be
Fri Jan 6 16:42:15 CET 2017

  <Programming> 2017 : The Art, Science, and Engineering of Programming

    April 3-6, 2017, Brussels, Belgium

We are excited to announce there will be 10 co-located events at the 
<Programming> 2017 conference (and more to come!):

  - LASSY 2017 - 2nd Workshop on Live Adaptation of Software SYstems
  - MOMO 2017 - 2nd Workshop on Modularity in Modelling
  - MoreVMs 2017 - 1st Workshop on Modern Language Runtimes, Ecosystems, 
and VMs
  - PASS 2017 - 1st Workshop on Programming Across the System Stack
  - PX 2017 - 2nd Workshop on Programming Experience
  - ProWeb 2017 - 1st Workshop on Programming Technology for the Future Web
  - Salon des Refusés 2017 - 1st edition of the Salon des Refusés workshop
  - ELS 2017 - 10th European Lisp Symposium
  - Modularity 2017 Invited talks - International Symposium on Modularity
  - ACM Student Research Competition / <Programming> 2017 Posters

All co-located events will take place during April 3-4 2017.
CFPs for each of these events are listed below. (apart from Modularity 
2017, which is invitation-based)

  LASSY 2017 - 2nd Workshop on Live Adaptation of Software SYstems

    Submissions: Fri 3 Feb 2017
    Notifications: Fri 3 Mar 2017


When developing current-day software systems, their deployment and usage 
environments should be considered carefully, in order to understand the 
adaptations those systems might need to undergo to interact with other 
systems and with their environment. Moreover, due to the portability, 
mobility and increasingly evolutionary nature of software systems, such 
adaptations should be enacted even while the system is running. 
Developing such software systems can prove challenging, and many 
seemingly different techniques to address this concern have been 
proposed over the last couple of years.

The intention of the LASSY workshop is to congregate all topics relevant 
to dynamic adaptation and run-time evolution of software systems, 
ranging from a computer science perspective covering the domains of 
programming languages, model-driven software development, software and 
service composition, context-aware databases, software variability, 
requirements engineering, UI adaptation and other domains, to a human 
perspective covering sociological or ethical implications of dynamic 
software systems. The workshop provides a space for discussion and 
collaboration between researchers working on the problem of enabling 
live adaptations to software systems, across the development stack.

Topics of Interest:

     * Design and Implementation of Live Adaptive Software Systems
         * Context-, aspect-, feature-, role- and agent-oriented programming
         * Context representation and discovery
         * Context-aware model-driven software development
         * Context-aware data management
         * Software variability and dynamic product lines
         * Self-adaptive, self-explanatory systems
         * Inconsistency management, verification, and validation
     * Middleware and Runtime of Live Adaptive Software Systems
         * Dynamic software evolution, upgrades and configuration
         * Dynamic software and service composition mechanisms
         * Dynamic software architecture and middleware approaches
         * Dynamic user interface adaptation and multimodal user interfaces
     * Impact and Assessment of Live Adaptive Software Systems
         * User acceptance and usability issues
         * Human, sociological, ethical and legal aspects
         * Privacy and security aspects of dynamic adaptability
         * Live adaptation in smart environments (e.g. smart rooms, 
smart robot cells, smart factories, smart cities)
         * Self-adaptation and emergence in SoS and CPSoS

  MOMO 2017 - 2nd Workshop on Modularity in Modelling

    Abstract submissions (optional): Sun Jan 29 2017
    Paper submissions: Sun Feb 5 2017
    Notifications: Wed Feb 22 2017


Extending the time-honored practice of separation of concerns, 
Model-Driven Engineering (MDE) promotes the use of separate models to 
address the various concerns in the development of complex 
software-intensive systems. The main objective is to choose the right 
level of abstraction to modularize a concern, specify its properties and 
reason about the system under development depending on stakeholder and 
development needs. While some of these models can be defined with a 
single modelling language, a variety of heterogeneous models and 
languages are typically used in the various phases of software 
development. Furthermore, Domain-Specific Modelling Languages designed 
to address particular concerns are also increasingly used.

Despite the power of abstraction of modelling, models of real-world 
problems and systems quickly grow to such an extent that managing the 
complexity by using proper modularization techniques becomes necessary. 
As a result, many (standard) modelling notations have been extended with 
aspect-oriented mechanisms and advanced composition operators to support 
advanced separation of concerns, to combine (possibly heterogeneous) 
models modularizing different concerns, to execute an application based 
on modularized models, and to reason over global properties of 
modularized models.

The Second International Modularity in Modelling Workshop brings 
together researchers and practitioners interested in the theoretical and 
practical challenges resulting from applying modularity, advanced 
separation of concerns, and advanced composition at the modelling level. 
It is intended to provide a forum for presenting new ideas and 
discussing the impact of the use of modularization in the context of MDE 
at different levels of abstraction.

We are interested in submissions on all topics related to modularity and 
modelling including but not limited to:

     * Modularization Support in Modelling Languages and Tools
         * Model Interfaces
         * Homogeneous Model Composition Operators
         * Heterogeneous Model Composition Operators
         * Visualization of Modularized and Composed Models
     * Effects of Using Modularization and Composition in Modelling
         * On Verification and Validation
         * On Reuse
         * On the Model-Driven Software Development Process 
(Requirements Engineering, Software Architecture, Software Design, 
         * On Maintenance
         * Experience Reports / Empirical Evaluations of Applying 
Modularization and Composition in Modelling
     * Feature-Oriented, Aspect-Oriented and Concern-Oriented Modelling
         * Modularization support and composition operators for specific 
modelling notations
         * Modelling essential characteristics of specific 
(crosscutting) concerns
         * Multi-View Modelling: avoiding inconsistencies, avoiding 
         * Support for Detecting and/or Resolution of Feature Interactions
     * Domain-Specific Modelling
         * Modularization for Domain-Specific Languages
         * Composition for Domain-Specific Languages
         * Domain-specific Aspect Models

  MoreVMs 2017 - 1st Workshop on Modern Language Runtimes, Ecosystems, 
and VMs

    Submissions: Wed 15 Feb 2017
    Notifications: Wed 1 Mar 2017


The main goal of the workshop is to bring together both researchers and 
practitioners and facilitate effective sharing of their respective 
experiences and ideas on how languages and runtimes are utilized and 
where they need to improve further. We welcome presentation proposals in 
the form of extended abstracts discussing experiences, work-in-progress, 
as well as future visions from the academic as well as industrial 

Relevant topics include, but are definitely not limited to, the following:

     * Extensible VM design (compiler- or interpreter-based VMs)
     * Reusable runtime components (e.g. interpreters, garbage 
collectors, intermediate representations)
     * Static and dynamic compiler techniques
     * Techniques for compilation to high-level languages such as JavaScript
     * Runtimes and mechanisms for interoperability between languages
     * Tooling support (e.g. debugging, profiling, etc.)
     * Programming language development environments and virtual machines
     * Case studies of existing language implementations, virtual 
machines, and runtime components (e.g. design choices, tradeoffs, etc.)
     * Language implementation challenges and trade-offs (e.g. 
performance, completeness, etc.)
     * Surveys and applications usage reports to understand runtime 
usage in the wild
     * Surveys on frameworks and their impact on runtime usage
     * New research ideas on how we want to build languages in the future

  PASS 2017 - 1st Workshop on Programming Across the System Stack

    Submissions: Mon 13 Feb 2017
    Notifications: Mon 27 Feb 2017


The landscape of computation platforms has changed dramatically in 
recent years. Emerging systems - such as wearable devices, smartphones, 
unmanned aerial vehicles, Internet of things, cloud computing servers, 
heterogeneous clusters, and data centers - pose a distinct set of 
system-oriented challenges ranging from data throughput, energy 
efficiency, security, real-time guarantees, to high performance. In the 
meantime, code quality, such as modularity or extensibility, remains a 
cornerstone in modern software engineering, bringing in crucial benefits 
such as modular reasoning, program understanding, and collaborative 
software development. Current methodologies and software development 
technologies should be revised in order to produce software to meet 
system-oriented goals, while preserving high internal code quality. The 
role of the Software Engineer is essential, having to be aware of the 
implications that each design, architecture and implementation decision 
has on the application system ecosystem.

This workshop is driven by one fundamental question: How does internal 
code quality interact with system-oriented goals? We welcome both 
positive and negative responses to this question. An example of the 
former would be modular reasoning systems specifically designed to 
promote system-oriented goals, whereas an example of the latter would be 
anti-patterns against system-oriented goals during software development.

Areas of interest include but are not limited to:

     * Energy-aware software engineering (e.g. energy efficiency models, 
energy efficiency as a quality attribute)
     * Modularity support (e.g., programming language design, 
development tools or verification) for applications in 
resource-constrained or real-time systems
     * Emerging platforms (e.g., Internet of Things and wearable devices)
     * Security support (e.g., compositional information flow, 
compositional program analysis)
     * Software architecture for reusability and adaptability in systems 
and their interactions with applications
     * Empirical studies (patterns and anti-patterns) on the 
relationship between internal code quality and system-oriented goals
     * Software engineering techniques to balance the trade-off between 
internal code quality and efficiency
     * Memory bloats and long-tail performance problems across modular 
     * Program optimization across modular boundaries
     * Internal code quality in systems software
     * Reasoning across applications, compilers, and virtual machines

  PX 2017 - 2nd Programming Experience Workshop

    Submissions: Sat 4 Feb 2017
    Notifications: Mon 27 Feb 2017


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. 
In that room they discover they need to explore the domain and the 
nature of potential solutions—they need exploratory programming.

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, and in this edition we would like to focus on 
exploratory programming.

The technical topics include:

     * Exploratory programming
     * Live programming
     * Authoring
     * Representation of active content
     * Visualization
     * Navigation
     * Modularity mechanisms
     * Immediacy
     * Literacy
     * Fluency
     * Learning
     * Tool building
     * Language engineering

  ProWeb 2017 - 1st Workshop on Programming Technology for the Future Web

    Submissions: Wed 15 Feb 2017
    Notifications: Wed 1 Mar 2017


Full-fledged web applications have become ubiquitous on desktop and 
mobile devices alike. Whereas “responsive” web applications already 
offered a more desktop-like experience, there is an increasing demand 
for “rich” web applications (RIAs) that offer collaborative and even 
off-line functionality —Google docs being the prototypical example. Long 
gone are the days that web servers merely had to answer incoming HTTP 
request with a block of static HTML. Today’s servers react to a 
continuous stream of events coming from JavaScript applications that 
have been pushed to clients. As a result, application logic and data is 
increasingly distributed. Traditional dichotomies such as “client vs. 
server” and “offline vs. online” are fading.

The 1st International Workshop on Programming Technology for the Future 
Web, or ProWeb17, is a forum for researchers and practitioners to share 
and discuss new technology for programming these and future evolutions 
of the web. We welcome submissions introducing programming technology 
(i.e., frameworks, libraries, programming languages, program analyses 
and development tools) for implementing web applications and for 
maintaining their quality over time, as well as experience reports about 
the use of state-of-the-art programming technology.

Relevant topics include, but are not limited to:

     * Quality on the new web: static and dynamic program analyses; 
code, design test and process metrics; development and migration tools; 
automated testing and test generation; contract systems, type systems, 
and web service API conformance checking; …
     * Hosting languages on the web: new runtimes; transpilation or 
compilation to JavaScript, WebAssembly, asm.js, …
     * Designing languages for the web: multi-tier (or tierless) 
programming; reactive programming; frameworks for multi-tier or reactive 
programming on the web; …
     * Distributed data sharing, replication and consistency: cloud 
types, CRDTs, eventual consistency, offline storage, peer-to-peer 
communication, …
     * Security on the web: client-side and server-side security 
policies; policy enforcement; proxies and membranes; vulnerability 
detection; dynamic patching, …
     * Surveys and case studies using state-of-the-art web technology 
(e.g., WebAssembly, WebSocket, LocalStorage, AppCache, ServiceWorkers, 
Meteor, deepstream.io, Angular.js, React and React Native, Swarm.js, 
Caja, TypeScript, Proxies, ClojureScript, Amber Smalltalk, Scala.js, …)
     * Ideas on and experience reports about: how to reconcile the need 
for quality with the need for agility on the web; how to master and 
combine the myriad of tier-specific technologies required to develop a 
web application, …
     * Position statements on what the future of the web will look like

  Salon des Refusés 2017

    Submissions: Wed 1 Feb 2017
    Notifications: Fri 17 Feb 2017


Salon des Refusés (“exhibition of rejects”) was an 1863 exhibition of 
artworks rejected from the official Paris Salon. The jury of Paris Salon 
required near-photographic realism and classified works according to a 
strict genre hierarchy. Paintings by many, later famous, modernists such 
as Édouard Manet were rejected and appeared in what became known as the 
Salon des Refusés. This workshop aims to be the programming language 
research equivalent of Salon des Refusés. We provide a venue for 
exploring new ideas and new ways of doing computer science.

Many interesting ideas about programming might struggle to find space in 
the modern programming language research community, often because they 
are difficult to evaluate using established evaluation methods (be it 
proofs, measurements or controlled user studies). As a result, new ideas 
are often seen as “unscientific”.

This workshop provides a venue where such interesting and 
thought-provoking ideas can be exposed to critical evaluation. 
Submissions that provoke interesting discussion among the program 
committee members will be published together with an attributed review 
that presents an alternative position, develops additional context or 
summarizes discussion from the workshop. This means of engaging with 
papers not just enables explorations of novel programming ideas, but 
also encourages new ways of doing computer science.
Topics of interest

The scope of the workshop is determined more by the format of 
submissions than by the specific area of programming language or 
computer science research that we are interested in. We welcome 
submissions in a format that makes it possible to think about 
programming in a new way, including, but not limited to:

     * Thought experiments – we believe that thought experiments, 
analogies and illustrative metaphors can provide novel insights and 
inspire fruitful programming language ideas.
     * Experimentation – we find prejudices in favour of theory, as far 
back as there is institutionalized science, but programming can often be 
seen more as experimentation than as theorizing. We welcome interesting 
experiments even if there is yet no overarching theory that explains why 
they happened.
     * Paradigms – all scientific work is rooted in a scientific 
paradigm that frame what questions can be asked. We encourage 
submissions that reflect on existing paradigms or explore alternative 
scientific paradigms.
     * Metaphors, myths and analogies – any description of formal, 
mathematical, quantitative or even poetical nature still represents just 
an analogy. We believe that fruitful ideas can be learned from less 
common forms of analogies as well as from the predominant, formal and 
mathematical ones.
     * From jokes to science fiction – a story or an artistic 
performance may explore ideas and spark conversations that provide 
crucial inspiration for development of new computer science thinking.

  ELS 2017 - 10th European Lisp Symposium

    Submissions: Mon 30 Jan 2017
    Notifications: Mon 27 Feb 2017


The purpose of the European Lisp Symposium is to provide a forum for the 
discussion and dissemination of all aspects of design, implementation 
and application of any of the Lisp and Lisp-inspired dialects, including 
Common Lisp, Scheme, Emacs Lisp, AutoLisp, ISLISP, Dylan, Clojure, ACL2, 
ECMAScript, Racket, SKILL, Hop and so on. We encourage everyone 
interested in Lisp to participate.

The 10th European Lisp Symposium invites high quality papers about novel 
research results, insights and lessons learned from practical 
applications and educational perspectives. We also encourage submissions 
about known ideas as long as they are presented in a new setting and/or 
in a highly elegant way.

Topics include but are not limited to:

     * Context-, aspect-, domain-oriented and generative programming
     * Macro-, reflective-, meta- and/or rule-based development approaches
     * Language design and implementation
     * Language integration, inter-operation and deployment
     * Development methodologies, support and environments
     * Educational approaches and perspectives
     * Experience reports and case studies

  ACM Student Research Competition / <Programming> 2017 Posters

    Submissions: Mon 16 Jan 2017


The ACM Student Research Competition (SRC), sponsored by Microsoft 
Research, offers a unique forum for ACM student members at the 
undergraduate and graduate levels to present their original research 
before a panel of judges and conference attendees. The SRC gives 
visibility to up-and-coming young researchers, and offers them an 
opportunity to discuss their research with experts in their field, get 
feedback, and to help sharpen communication and networking skills.

ACM’s SRC program covers expenses up to $500 for all students invited to 
an SRC. Please see our website for requirements and further details.

More information about the ecoop-info mailing list