[squeak-dev] Call for Workshop Papers - ECOOP 2022

Carolin Brandt C.E.Brandt at tudelft.nl
Thu Mar 31 14:04:06 UTC 2022

ECOOP 2022: Call for Workshop Papers

COP 2022: International Workshop on Context-Oriented Programming and Advanced Modularity
Deadline: Friday, 15th of April

Workshop on Formal Techniques for Java-like Programs
Deadline: Friday, 1st of April

ICOOOLPS’22: Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems
Deadline: Thursday, 21st off April (Submission Talks, Demos, Position Papers)

Program Analysis for WebAssembly (PAW) 2022
Deadline: Monday, 11th of April

Programming Local-first Software
Deadline: Friday, 1st of April

PRIDE 2022: Workshop on Practical Research IDEs
Deadline: Friday, 15th of April

Truffle 2022: Truffle/GraalVM Languages Workshop
Deadline: Saturday, 30th of April

VORTEX 2022: Workshop on Verification and mOnitoring at Runtime EXecution
Deadline: Monday, 18th of April

Detailed Calls for Papers:
COP 2022: International Workshop on Context-Oriented Programming and Advanced Modularity
https://2022.ecoop.org/home/COP-2022 <https://2022.ecoop.org/home/COP-2022>
Deadline: Friday, 15th of April

Contextual information plays an ever-increasing role in our information-centric world. Current-day software systems adapt continuously to changing execution and usage contexts, even while running. Unfortunately, mainstream programming languages and development environments still do not support this kind of dynamicity very well, leading developers to implement complex designs to anticipate various dimensions of variability.

Context-Oriented Programming directly supports variability at the programming level, depending on a wide range of dynamic attributes. It enables run-time behavior to be dispatched directly on any detected properties of the execution or user context. Since more than a decade, researchers have been working on a variety of notions approaching that idea. Implementations ranging from first prototypes to mature platform extensions used in commercial deployments have illustrated how multidimensional dispatch can be supported effectively to achieve expressive run-time variation in behavior.

The scope of this workshop will further encompass diverse and advanced forms of modularity support in programming languages. We encourage results and discussions on advanced modularity that go beyond COP.

## Call for Papers

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.

All papers must be original. Submissions must not have been published previously and must not be simultaneously submitted or under review at any other refereed event or publication. The program committee will evaluate each contributed paper based on its relevance, significance, clarity, and originality.

### Topics

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

- Context-Oriented Programming (COP) and Contextual modeling in modern computer systems (mobile systems, IoTs, cloud/edge computing, autonomous systems, etc.);
- Programming language abstractions for COP (e.g., dynamic scoping, roles, traits, prototype-based extensions);
- Implementation issues for COP (e.g., optimization, VM support, JIT compilation);
- COP applications in computer systems (e.g., mobile systems, IoTs, cloud/edge computing, security);
- COP applications in autonomous systems (e.g., unmanned aerial vehicles, autonomous vehicles);
- Configuration languages (e.g., feature description interpreters, transformational approaches);
- Programming language abstractions for composition and modularization (e.g., modules, aspects, features, layers, plugins, libraries, components);
- Theoretical foundations and reasoning support for COP and modular systems (e.g., semantics, type systems, mechanized proofs);
- Software lifecycle support for modularization (e.g., requirements; architecture; synthesis; metrics; software product lines; economics; testing; patterns);
- Tool support for modular software development (e.g., platform; refactoring; static and dynamic analysis; evolution; reverse engineering; mining);
- Modular applications (e.g., data-intensive applications, micro-services, serverless computing);

### Submission guidelines

Papers are to be submitted via [EasyChair](https://easychair.org/my/conference?conf=cop2022). They must be written in English, provided as PDF documents, and follow the new [ACM Master Article Template](https://www.acm.org/publications/proceedings-template) with the sigconf option. They should not exceed 8 pages. Accepted papers will be published in the ACM Digital Library (SCOPUS).

Workshop on Formal Techniques for Java-like Programs
https://2022.ecoop.org/track/ftfjp-2022 <https://2022.ecoop.org/track/ftfjp-2022>
Deadline: Friday, 1st of April

Participation: Participation in the workshop is hybrid as with ECOOP 2022, but registration through the ECOOP registration system is required. As a hybrid event, when considering virtual mode, the registration system will provide you with the link to participate in the Zoom conference sessions.

Formal techniques can help analyse programs, precisely describe program behaviour, and verify program properties. Modern programming languages are interesting targets for formal techniques due to their ubiquity and wide user base, stable and well-defined interfaces and platforms, and powerful (but also complex) libraries. New languages and applications in this space are continually arising, resulting in new programming languages (PL) research challenges.

Work on formal techniques and tools and on the formal underpinnings of programming languages themselves naturally complement each other. FTfJP is an established workshop which has run annually since 1999 alongside ECOOP, with the goal of bringing together people working in both fields.

The workshop has a broad PL theme; the most important criterion is that submissions will generate interesting discussions within this community. The term “Java-like” is somewhat historic and should be interpreted broadly: FTfJP solicits and welcomes submission relating to programming languages in general, beyond Java, including C#, Scala, etc.

Example topics of interest include (but not limited to):

- Language design and semantics
- Type systems
- Concurrency and new application domains
- Specification and verification of program properties
- Program analysis (static or dynamic)
- Program synthesis
- Security Pearls (programs or proofs)
- Programming environments

FTfJP welcomes submissions on technical contributions, case studies, experience reports, challenge proposals, tools, and position papers. Webpages for previous workshops in this series are available at: https://ftfjp.github.io/.

We plan that, as in previous years, accepted papers will be published in the ACM Digital Library, though authors will be able to opt out of this publication, if desired. At least one author of an accepted paper must attend the workshop to present the work and participate in the discussions.

## Submissions

Contributions are sought in two categories:

* Full Papers (6 pages, excluding references) present a technical contribution, case study, tool, or detailed experience report. We welcome both complete and incomplete technical results; ongoing work is particularly welcome, provided it is substantial enough to stimulate interesting discussions.
* Short Papers (2 pages, excluding references) should advocate a promising research direction, or otherwise present a position likely to stimulate discussion at the workshop. We encourage e.g. established researchers to set out a personal vision, and beginning researchers to present a planned path to a PhD.

All submissions and reviews will be managed within EasyChair.
Submissions should be made via https://easychair.org/conferences/?conf=ftfjp2022.
There is no need to indicate the paper category (long/short).

Both types of contributions will benefit from feedback received at the workshop. Submissions will be peer reviewed, and will be evaluated based on their clarity and their potential to generate interesting discussions. Reviewing will be single blind, there is no need to anonymize submissions.

The format of the workshop encourages interaction. FTfJP is a forum in which a wide range of people share their expertise, from experienced researchers to beginning PhD students.

## Formatting and Publication
All authors should use the official “ACM Master article template”, which can be obtained from the ACM Proceedings Template pages ( https://www.acm.org/publications/proceedings-template ). Latex users should use the “sigconf” option as well as “review” (to produce line numbers for easy reference by the reviewers). To that end, the following latex code can be placed at the start of the latex document: \documentclass[sigconf,review]{acmart}

We plan that, as in previous years, accepted papers will be published in the ACM Digital Library, though authors will be able to opt out of this publication, if desired. At least one author of an accepted paper must register to the conference by the early registration date and attend the workshop to present the work and participate in the discussions.

Selected papers will also be considered for extended versions to be submitted to the Journal of Object Technology (JOT).

ICOOOLPS’22: Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems
https://2022.ecoop.org/home/ICOOOLPS-2022 <https://2022.ecoop.org/home/ICOOOLPS-2022>
Deadline: Thursday, 21st off April (Submission Talks, Demos, Position Papers)
The ICOOOLPS workshop series brings together researchers and practitioners working in the field of language implementation and optimization.

The goal of 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 not limited to object-oriented ones. Furthermore, virtual machines, meta-compilation techniques or language-agnostic approaches are welcome, too.

Call for Contributions

The ICOOOLPS workshop series brings together researchers and practitioners working in the field of language implementation and optimization (even beyond the historical OO background of the workshop). The goal of the workshop is to discuss emerging problems and research directions, as well as new solutions and techniques.

We hope to provide a space for participation and discussion and in particular to discuss your work in progress. That’s why we’ll have two additional submission categories for position papers and talks. We also accept talk proposals for papers that have appeared at some other past conference, but didn’t receive much discussion there due to the conference being cancelled or virtual because of Covid.

A non-exclusive list of topics of interest for this workshop is:

	• Implementation and optimization of fundamental languages features (from automatic memory management to 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 optimizations,…)
	• Empirical studies on language usage, benchmark design, and benchmarking methodology
	• 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

The workshop welcomes the presentation and discussion of new ideas and emerging problems. We aim to provide an environment to present and discuss your work at different stages of maturity. Therefore we provide three submission categories:

	• Full papers (up to 12 pages), which will be included in the proceedings;
	• Position papers (up to 4 pages), for work in progress, ideas in early stages;
	• Talks, Demos.
Please note that option (1) features a different submission deadline than the rest and will include a short rebuttal period, in which authors will be able to answer reviewers comments.


To submit a paper please use the official “ACM Master article template”, which can be obtained from the ACM Proceedings Template pages. ICOOOLPS features a light-weight double-blind review process. Authors should omit their names in the submission. Use the sigconf option as well as review and anonymous, i.e., place the following at the start of the latex document: \documentclass[sigconf,review,anonymous]{acmart}.

Program Analysis for WebAssembly (PAW) 2022
https://2022.ecoop.org/home/paw-2022 <https://2022.ecoop.org/home/paw-2022>
Deadline: Monday, 11th of April
WebAssembly is a recently introduced portable virtual machine, to which code written in many high-level languages can be compiled in order to be executed in web browsers and other runtimes. There have been several independent efforts to bring static and dynamic analysis tools to the WebAssembly ecosystem. This workshop aims to bring together researchers working in the domain of static and dynamic analyses for WebAssembly. Specifically, this workshop aims to discuss all techniques related to detecting bugs and vulnerabilities in WebAssembly binaries, to build models of such binaries, to prove their correctness, to monitor their execution, or to optimize binaries for running time and binary size. The workshop will be a community-building event to exchange ideas and build collaborations in these domains. To that end, contributions in the form of submitted talks are welcome. The workshop will also hold discussion sessions in order to foster collaborations.

Questions? Use the PAW contact form (https://2022.ecoop.org/contact2/paw-2022-papers <https://2022.ecoop.org/contact2/paw-2022-papers>).

Call for presentations

WebAssembly is a recently introduced portable virtual machine, to which code written in many high-level languages can be compiled in order to be executed in web browsers and other runtimes. There have been several independent efforts to bring static and dynamic analysis tools to the WebAssembly ecosystem. This workshop aims to bring together researchers working in the domain of static and dynamic analyses for WebAssembly. Specifically, this workshop aims to discuss all techniques related to detecting bugs and vulnerabilities in WebAssembly binaries, to build models of such binaries, to prove their correctness, to monitor their execution, or to optimise binaries for running time and binary size. The PAW workshop is a community-building event, for exchanging ideas and fostering collaborations in these domains.

The workshop will consist of submitted and invited talks, as well as discussion sessions. To that end, we invite submissions for talks in the form of a 1-page abstract delineating at a high-level the content of the proposed presentation.

Submission site: https://easychair.org/conferences/?conf=paw2022


	• April 11 2022: Submission deadline
	• May 2 2022: Acceptance notification
	• June 6-10 2022: ECOOP conference

Programming Local-first Software
https://2022.ecoop.org/home/plf-2022 <https://2022.ecoop.org/home/plf-2022>
Deadline: Friday, 1st of April
Languages for Multi-Device Collaborative Applications

Due to ubiquitous connectivity and cheap availability of user devices from smartphones to desktops, applications supporting multi-device and collaborative use have become more common, and with the Corona pandemic this trend has tremendously accelerated.

While most of the distributed applications that we see nowadays are cloud-based, avoiding the cloud can lead to privacy and performance benefits for users and operational and cost benefits for companies and developers. Following this idea, Local-First Software runs and stores its data locally while still allowing collaboration, thus retaining the benefits of existing collaborative applications without depending on the cloud.

Many specific solutions already exist: operational transformation, client-side databases with eventually consistent replication based on CRDTs, and even synchronization as a service provided by commercial offerings, and a vast selection of UI design libraries.

However, these solutions are not integrated with the programming languages that applications are developed in. Language based solutions related to distribution such as type systems describing protocols, reliable actor runtimes, data processing, machine learning, etc., are designed and optimized for the cloud not for a loosely connected set of cooperating devices. This workshop aims at bringing the issue to the attention of the PL community, and accelerating the development of suitable solutions for this area.

Workshop timeline

Note: Times are only examples and will change along the main conference and other workshops.

We currently plan an in-person event, however, we will keep monitoring the ongoing situation. In case of a virtual workshop, we will ask speakers to prerecord their talk, and organize live Q&A sessions. We do plan to make the workshop accessible to remote participation for non-speakers.

	• ~09:30 Keynote (TBA)
	• ~10:30 Accepted talk block 1
	• ~13:00 Accepted talk block 2
	• ~16:00 Panel discussion (TBA)
Call for Talks and Papers

Note: details about the process are still subject to change.

Scope of contributions

We are looking to advance the state of the art to program local-first software, that is, programs that are useful to a single user while offline, but allow sharing and collaboration when connected. Examples topics include:

	• language constructs that enable offline use
	• case studies that consider what works well and what is challenging using existing languages
	• UI techniques that consider connectivity states
	• users, identities, and trust as language constructs
	• type systems to track what functionality is available offline
	• easy to use APIs for (new and existing) efficient data synchronization algorithms
	• dynamic placement techniques that scale down to a single offline device
Types of contribution

We encourage a range of contributions to facilitate exchange between academia and industry. Specifically, we are looking for:

	• Talk proposals of at most 1 page summarizing:
		• the content and scope
		• the context (speaker, company, research group, larger project, etc.)
		• include links to further info if available (an existing published paper, prior talks, project websites, etc.)
	• Relevant in progress research papers:
		• no format or page limit
			• if the paper is longer than 8 pages: include a summary one or two key contributions/sections the reviewers should focus on
		• these will receive reviews by the organizing committee focused on potential improvements
		• there will be no officially published proceedings, but papers will be listed on the website if the authors agree
If accepted, authors of both types of submission are assigned a 25 minute slot for a talk + 5 minutes for questions. In addition,  submissions are published on the website.

Timeline and submission

	• 2022-04-01 Submission closes
	• 2022-05-01 Notification of accepted papers
Use the submission link at the top of the right sidebar.

For talk proposals, you may either upload a PDF, or put the proposal into the “abstract” field of the submission site.

For in progress papers of more than 8 pages, include the description of what the reviewers should focus on as part of the abstract.

In case will would only attend the workshop in person or only via video conferencing, please indicate this as part of the submission (in the abstract field).

Questions? Use the PLF contact form (https://2022.ecoop.org/contact2/plf-2022-papers <https://2022.ecoop.org/contact2/plf-2022-papers>)

PRIDE 2022: Workshop on Practical Research IDEs
https://2022.ecoop.org/home/pride-2022 <https://2022.ecoop.org/home/pride-2022>
Deadline: Friday, 15th of April

Goal of the Workshop

The goal of this workshop is to help researchers take their research developments and integrate them easily into existing IDE tools. We are seeking participation from researchers who have developed novel analysis technology and would like an easy way to deploy this technology in existing IDE tools. For example, a new, more-precise taint analysis is nice, but it will be potentially much easier to use and to evaluate if it is available in popular IDE’s—e.g. IntelliJ, VisualStudio Code—in editors—e.g. Sublime Text, Atom—and traditional editors used by programmers—e.g. Emacs, Vim.

We welcome researchers who are interested in IDE integration of program analyses to submit talk proposals (see Call for Talks). We will also host a hands-on Panathon session (Call for Participation in Panathon) where participants will be using MagpieBridge to integrate their own program analysis tools. MagpieBridge provides support for accomplishing this: it provides a framework in which a research analysis can be invoked from standard IDE’s. The underlying mechanism makes use of the Language Server Protocol (LSP), but that is completely hidden by a straightforward API that allows analyses to be invoked on source projects from IDE’s and report results that get displayed in idioms natural to each IDE. Such functionality could benefit a wide range of research tools, and so we encourage participation by bringing either your own research analysis or any analysis that you would like to see in a tool.

Preliminary Workshop Program

Date: Tuesday, 7 June 2022

Time	Session
09:00 - 09:15   	— Welcome by the organizers
09:15 - 12:00  	— Invited Talks (See Call for Talks)
13:00 - 14:00 	— MagpieBridge Tutorial
14:00 - 17:00 	— Panathon (See Call for Participation in Panathon)
17:00 - 18:30 	— Demonstration and Best IDE Integration Award

Questions? Use the PRIDE contact form (https://2022.ecoop.org/contact2/pride-2022 <https://2022.ecoop.org/contact2/pride-2022>)

Call for Talks

We look for talk proposals for the Invited Talks session. We welcome submissions addressing the following topics:

	• Past experience with integrating program analyses into IDEs. E.g, it would describe an integration into an IDE, and discuss how MagpieBridge simplified it. It could contrast MagpieBridge with other integrations, or it could show issues using MagpieBridge and possible improvements,

	• Tool demonstration. A tool demonstration should show a running analysis integrated into IDEs, and the talk would focus on how the information is displayed and how the mechanisms are used to show the analysis.

	• Report of user experience and expectation. A report of user experience would discuss user studies of IDE integration of program analyses. It should focus on how the integration works, what informations is displayed, how the study was designed and results.

	• Explainability of analysis result. Explainability of analysis results would describe novel IDE mechanisms for displaying results, and how that was done. For instance, mechanisms for showing interprocedural data-flow paths.

Authors of accepted proposals will be invited to give a talk (10 - 15 mins + 5 mins Q&A) at the workshop.

How to Submit

All submissions must confirm to the ECOOP 2022 formatting instructions and must not exceed 2 pages for the main text, inclusive of all figures and tables. Reference has no page limit.

The submission is non-blind. Please include your name, e-mail and affiliation in the submission. The proposal should describe: motivation, background about the program analysis tool, lessons learned or features of the IDE integration, looks of the analysis result in IDE, user feedbacks, challenges for future research.

	• Submission deadline: 15. April 2022
	• Submission website: click here
	• Accepted talk proposals will be notified by 1. May 2022

Call for Participation in Panathon

Researchers who want to integrate their program analysis tools into IDEs are welcome to participate in the Panathon session, get cool Swag and win the Best IDE Integration Award with prize money.

Before the Panathon session, participants will be given a tutorial on how to use MagpieBridge for integrating program analysis tools into IDEs. During the Panathon session, participants will be given three hours to build an IDE integration of their analysis tools using MagpieBridge.

Afterwards, each participant will be given 5 minutes to demonstrate an integrated analysis tool. The demonstration will be evaluated by a panel of judges. A winner will be chosen and receive the Best IDE Integration Award. All participants will get cool Swag as a gift from the organizers. For participation, the idea is to create integration, so the ideal analysis will already work on code and produce some kind of result amenable to displaying in an IDE, such as issues or warnings about specific code constructs or variables.

How to participate

Participants first need to register their interests by providing some basic information such as the background of the analysis tool that needs to be integrated into IDEs.

	• Registration link: click here
	• Registration deadline: 15. April 2022.
	• Selected participants for the Panathonn session will be notified by 1. May 2022.
	• Selected participants come to the workshop and build IDE integration for their analysis tools.
	• A winner will be selected after the demonstration of integrated analysis tools.

MagpieBridge is designed to be broadly useful, but there are a few guidelines as to what sort of analysis would likely work best. Consult these guidelines to understand whether your analysis would be easy to integrate and whether you could display information as you would like:

1. Ease of use

	• The MagpieBridge wiki provides documentation and tutorials.
	• MagpieBridge is available on Maven Central. It can be easily added to projects using common build tools such as Maven and Gradle.
2. Performance and language requirements

	• MagpieBridge is largely asynchronous with respect to the IDE, so analysis computation time will never block the IDE and results are reported when they are ready. Latency-sensitive features such as hovers can have results computed during analysis, so analysis computation time can be hidden even there. This increases the amount of analysis time that is tolerable compared to on-demand analysis; however, analyses that take excessive amounts of time would not be suitable.
	• MagpieBridge is written in Java, which makes integrating analyses also written in Java simplest. However, the protocol for communicating with analyses is straightforward, and we will support projects communicating with other languages with JNI bindings when appropriate and also with JSON messaging when that is most convenient. As such, the language in which your analysis is written should not be an issue for taking part in the hackathon.
3. How analysis results can be displayed

MagpieBridge largely supports functionality provided by LSP, with a focus on three features given below, but also provides a mechanism to integrate arbitrary HTML pages including forms and JavaScript. The three focus features are the following:

	• Diagnostics are the kind of error, warning and informational messages commonly supported in IDE’s. MagpieBridge provides an API for returning these kinds of messages, which then get displayed by the IDE using its usual mechanisms.
	• Hovers are messages that pop up when the mouse hovers over a specific code segment . Note that LSP in most IDE’s integrates its hovers seamlessly with any other hover messages that the IDE generates.
	• Code lenses are comments injected into program buffers by the IDE, typically accentuated by means of different fonts or colors. These lenses can be linked to actions that interact with the analysis.
	• Code actions such as quick fixes, displaying a HTML page which presents more complex information.
MagpieBridge does not support wholesale changes to the IDE, but, using the HTML integration mechanism, it allows non-trivial views to e.g. configure an analysis or display results. This HTML integration is robust across all IDE’s supported: if an IDE provides such a mechanism (e.g. VS Code), MagpieBridge uses it; otherwise these views would show up in the user’s Web browser.

4. How analysis results can be used

MagpieBridge supports the LSP notion of code actions, in which an analysis provides a code range from the program and the text with which it would like to replace that range. This is the primary mechanism, but it is straightforward to extend it to multiple ranges for a single fix. MagpieBridge supports arbitrary HTML documents, which can be used by an analysis to display more complex information than can be easily rendered in a hover. For example, a detailed description of a security warning could be displayed for a brief error message, a data-flow path could be displayed in a graph-like structure.

We encourage student participants with limited funding to apply for student volunteers at ECOOP.

Truffle 2022: Truffle/GraalVM Languages Workshop
https://2022.ecoop.org/home/truffle-2022 <https://2022.ecoop.org/home/truffle-2022>
Deadline: Saturday, 30th of April
The Truffle/GraalVM Languages Workshop is intended to bring together researchers and developers from both industry and academia that work with the technologies offered by the Truffle language framework and the GraalVM runtime, as well as those working on related approaches pertaining to specializing dynamic language runtimes and tooling. The workshop is meant to foster the exchange of experiences of working with Truffle, provide introductions to Truffle & GraalVM to developers interested in starting their own projects, present specific implementation aspects of existing languages on Truffle, and discuss  limitations and future directions of language implementation frameworks in general and Truffle/GraalVM in particular. The format of the workshop will include both presentations of current research and experiences in dynamic language runtime and tool implementations, as well as tutorial-style presentations of specific aspects of using Truffle and GraalVM. We explicitly encourage presentations of work-in-progress as well as work in the early exploration phases to solicit early feedback from and foster discussion with other experienced language developers.

Questions? Use the Truffle contact form (https://2022.ecoop.org/contact2/truffle-2022 <https://2022.ecoop.org/contact2/truffle-2022>)

Call for Participation:

We solicit discussion topic proposals, describing both ongoing and future projects, in the form of extended (1-3 page) abstracts. The discussion topics include but are not limited to the following areas:

	• Case studies of existing language implementations on Truffle and/or GraalVM.
	• Comparing alternative language implementation techniques to Truffle.
	• Performance analysis and/or optimizations for GraalVM and Truffle language implementations.
	• Tooling support for Truffle languages and GraalVM.
	• Infrastructure-level optimizations and extensions that can benefit languages built with Truffle.
	• Research project proposals utilizing Truffle and/or GraalVM.
Depending on the number of accepted submissions, we expect topics to cover between 30 minutes and 60 minutes time slots at the workshop. All proposals should be submitted by email to Tim Felgentreff

	• Deadline for proposal submissions: Apr 30, 2022 (by 11:59 PM AoE)
	• Notification: May 6, 2022
Although we would like to encourage participants to join the workshop in person, we are planning for a hybrid event due to the continued uncertainties surrounding travel. Please indicate if you plan to attend in person or via video conferencing.

VORTEX 2022: Workshop on Verification and mOnitoring at Runtime EXecution
https://2022.ecoop.org/home/vortex-2022 <https://2022.ecoop.org/home/vortex-2022>
Deadline: Monday, 18th of April

Runtime Monitoring (RM) is concerned with the runtime analysis of software and hardware system executions in order to infer properties relating to system behaviour. Example applications include telemetry, log aggregation, threshold alerting, performance monitoring and adherence to correctness properties (more commonly referred to as runtime verification). RM has gained popularity as a solution to ensure software reliability, bridging the gap between formal verification and testing: on the one hand, the notion of event trace abstracts over system executions, thus favoring system agnosticism to better support reuse and interoperability; on the other hand, monitoring a system offers more opportunities for addressing error recovery, self-adaptation, and issues that go beyond software reliability. The goal of VORTEX is to bring together researchers contributing on all aspects of RM covering and possibly integrating both theoretical and practical aspects, with particular focus on hybrid approaches inspired by formal methods, program analysis, testing.

Call for Papers

Submissions are expected to be in English and to belong to one of the following two categories:

	• regular paper, page limit 8 in acmart style: unpublished self-contained work
	• extended abstract, page limit 4 in acmart style: original contribution, not yet fully developed
Topics of interest include, but are not limited to, the following ones:

	• monitor construction and synthesis techniques
	• program adaptation
	• monitoring oriented programming
	• runtime enforcement, fault detection, recovery and repair
	• combination of static and dynamic analyses
	• specification formalisms for RM
	• specification mining
	• monitoring concurrent/distributed systems
	• RM for safety and security
	• RM for the Internet of Things
	• industrial applications
	• integrating RM, formal verification, and testing
	• tool development
	• instrumentation techniques for RM
	• surveys on different RM tools, formal frameworks or methodologies
	• presentations of RM tools
Papers must be submitted electronically via EasyChair; the submission deadline is April 18 AoE. Authors should use the official ACM Master article template, which can be obtained from the ACM Proceedings Template pages.

Latex users should use the sigconf option, as well as review to produce line numbers for easy reference by the reviewers, as indicated by the following command:



Depending on the quality and number of submissions, the workshop proceedings will be published in the ACM DL, and authors of selected papers will be invited to contribute with extended versions to be included in a special issue of the Journal of Object Technology (JOT)

Questions? Use the VORTEX contact form (https://2022.ecoop.org/contact2/vortex-2022 <https://2022.ecoop.org/contact2/vortex-2022>)


Carolin Brandt

PhD Student // she/her // 🇬🇧 🇩🇪 🇳🇱
TU Delft // EEMCS // Software Engineering Research Group // TestShift Project
E c.e.brandt at tudelft.nl // T https://twitter.com/laci_noire // W https://carolin-brandt.de/

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.squeakfoundation.org/pipermail/squeak-dev/attachments/20220331/caf60eb6/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 833 bytes
Desc: Message signed with OpenPGP
URL: <http://lists.squeakfoundation.org/pipermail/squeak-dev/attachments/20220331/caf60eb6/attachment-0001.sig>

More information about the Squeak-dev mailing list