<Programming> 2017: Call for workshop, symposium & poster submissions for Programming 2017 (Brussels, Apr 17)

Sun, 15 Jan 2017 16:49:14 -0500 (EST)

          From comp.compilers

Related articles
<Programming> 2017: Call for workshop, symposium & poster submissions timmolderez@gmail.com (2017-01-15)
| List of all articles for this month |

From: timmolderez@gmail.com
Newsgroups: comp.compilers
Date: Sun, 15 Jan 2017 16:49:14 -0500 (EST)
Organization: Compilers Central
Injection-Info: miucha.iecc.com; posting-host="news.iecc.com:2001:470:1f07:1126:0:676f:7373:6970"; logging-data="97292"; mail-complaints-to="abuse@iecc.com"
Keywords: CFP
Posted-Date: 15 Jan 2017 16:49:14 EST

  <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!):

  - ELS 2017 - 10th European Lisp Symposium
  - Modularity 2017 Invited talks - International Symposium on Modularity
  - ACM Student Research Competition / <Programming> 2017 Posters
  - 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
  - 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 RefusC)s 2017 - 1st edition of the Salon des RefusC)s workshop

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)

  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

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.

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

  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, Implementation)
                * 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)
                * 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 perspective.

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
        * 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
solutionsbthey 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 itbs exploratory programming. Do they create text that
is transformed into running behavior (the old way), or do they operate on
behavior directly (blivenessb); 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 bresponsiveb web applications already offered a
more desktop-like experience, there is an increasing demand for brichb web
applications (RIAs) that offer collaborative and even off-line functionality
bGoogle 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. Todaybs 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 bclient vs. serverb and boffline vs. onlineb are

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

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; b&
        * Hosting languages on the web: new runtimes; transpilation or compilation
to JavaScript, WebAssembly, asm.js, b&
        * Designing languages for the web: multi-tier (or tierless) programming;
reactive programming; frameworks for multi-tier or reactive programming on the
web; b&
        * Distributed data sharing, replication and consistency: cloud types,
CRDTs, eventual consistency, offline storage, peer-to-peer communication, b&
        * Security on the web: client-side and server-side security policies;
policy enforcement; proxies and membranes; vulnerability detection; dynamic
patching, b&
        * 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, b&)
        * 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 RefusC)s 2017

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


Salon des RefusC)s (bexhibition of rejectsb) 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 C douard
Manet were rejected and appeared in what became known as the Salon des
RefusC)s. This workshop aims to be the programming language research
equivalent of Salon des RefusC)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 bunscientificb.

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

        * Thought experiments b we believe that thought experiments, analogies
and illustrative metaphors can provide novel insights and inspire fruitful
programming language ideas.
        * Experimentation b 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 b 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 b 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 b a story or an artistic performance may
explore ideas and spark conversations that provide crucial inspiration for
development of new computer science thinking.

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.