Search

This document is a guest editorial for the special section on SEFM 2020 and 2021 in the journal Software & Systems Modeling. The International Conference on Software Engineering and Formal Methods (SEFM) aims to bring together practitioners and researchers to advance the state of the art in formal methods and their application in the software industry. This special section includes selected papers from SEFM 2020 and 2021, which were held virtually during the COVID pandemic. Each article in this section has undergone rigorous peer review and has been revised and extended compared to its conference version. The selected papers cover topics such as embedded software portability and verification, nontermination inference, quantitative modeling and analysis of BDI agents, lazy model checking for recursive state machines, P-stable abstractions of hybrid systems, fairness and guarantees for extended bounded response LTL+P synthesis, counterexample classification, analyzing the impact of human errors on interactive service robotic scenarios, and active model learning of stochastic reactive systems. [Extracted from the article]

This document is a guest editorial for a special section in the journal "Software & Systems Modeling." The special section features revised and extended versions of selected papers from the 20th International Conference on Software Engineering and Formal Methods (SEFM'22), which was held in Berlin, Germany in September 2022. The SEFM conference series aims to advance the state of the art in formal methods and their integration into practical software engineering methods and tools. The special section includes papers on topics such as user-centric analysis, automated generation of finite automata, formal specifications of smart contracts, distributed verification of programs, and abstraction-based verification of neural networks. The authors express their gratitude to the authors and reviewers for their contributions and thank Springer for their support in publishing the special section. [Extracted from the article]

What are the landmark papers in scientific disciplines? Which papers are indispensable for scientific progress? These are typical questions which are of interest not only for researchers (who frequently know the answers – or guess to know them) but also for the interested general public. Citation counts can be used to identify very useful papers since they reflect the wisdom of the crowd – in this case, the scientists using published results for their research. In this study, we identified with recently developed methods for the program CRExplorer landmark publications in nearly all Web of Science subject categories (WoS-SCs). These are publications which belong more frequently than other publications during the citing years to the top-1‰ in their subject area. As examples, we show the results of five subject categories: 'Information Science & Library Science', 'Computer Science, Information Systems', 'Computer Science, Software Engineering', 'Psychology, Social' and, 'Chemistry, Physical'. The results of the other WoS-SCs can be found online at http://crexplorer.net. An analyst of the results should keep in mind that the identification of landmark papers depends on the used methods and data. Small differences in methods and/or data may lead to other results. [ABSTRACT FROM AUTHOR]

The data-driven approach is popular to automate learning of fuzzy rules and tuning membership function parameters in fuzzy inference systems (FIS) development. However, researchers highlight different challenges and issues of this FIS development because of its complexity. This paper evaluates the current state of the art of FIS development complexity issues in Computer Science, Software Engineering and Information Systems, specifically: 1)What complexity issues exist in the context of developing FIS? 2) Is it possible to systematize existing solutions of identified complexity issues? We have conducted a hybrid systematic literature review combined with a systematic mapping study that includes keyword map to address these questions. This review has identified the main FIS development complexity issues that practitioners should consider when developing FIS. The paper also proposes a framework of complexity issues and their possible solutions in FIS development. [ABSTRACT FROM AUTHOR]

Aim/Purpose This paper investigates the gaps between industry and academia perceptions of information technology fields, such as computer science, software engineering, and computer engineering, and it identifies areas of asymmetry between curricula and industry expectations. The study mainly focuses on the skills required of IT professionals (graduated students) and on how higher education institutes equip students for industry. Background Higher education institutes have several IT-related departments. However, it is not clear whether these departments have sufficient content to equip students with industry-related skills. Rapid advances mean that some curriculum topics are redundant before the end of a standard two- or four-year degree programs. Balancing the technical/non-technical skills and adjusting the curricula to better prepare the students for industry is a constant demand for higher education institutions. Several studies have demonstrated that a generic curriculum is inadequate to address current IT industry needs. Methodology The study involved a comprehensive survey of IT professionals and compa- nies using a Web-based questionnaire sent directly to individual companies, academics, and employers. 64 universities and 38 companies in 24 countries were represented by the 209 participants, of whom 99 were IT professionals, 72 academics, and 38 employers. Contribution This paper is intended to guide academics in preparing dynamic curricula that can be easily adapted to current industry trends and technological developments, with content directly relevant to student's careers. In addition, the results may identify the skills that students need to secure employment and the courses that will provide skills in line with current industry trends. Findings The results indicate a lack of emphasis on personal and non-technical skills in undergraduate education compared to general computer science, software development, and coding courses. Employers' and software experts' responses emphasize that soft skills should not be ignored, and that, of these, analytical thinking and teamwork are the two most requested. Rather than a theoretical emphasis, courses should include hands-on projects. Rapid developments and innovations in information technologies demand that spiral and waterfall models are replaced with emerging software development models, such as Agile and Scrum development. Recommendations for Practitioners A multidisciplinary approach should be taken to the teaching of soft skills, such as communication, ethics, leadership, and customer relations. Establishing multiple learning tracks in IT education would equip students with specialized knowledge and skills in IT. An effective communication channel should be established between students and industry. It is also important to reduce the distance between academics and students and to provide an interactive environment for technical discussions. Enterprise level computing and Framework use provide job market advantages. Recommendations for Researchers Researchers and department heads, particularly those involved in curriculum design and accreditation, could use the results of this exemplary study to identify key topics for attention. Impact on Society Changes of various degrees are required in the current curricula in many higher education institutions to better meet student needs. Societies and technology are dynamic in nature, and information technology-related curricula in higher education institutions should be equally dynamic. Future Research Since technology (especially information technology) transforms and advances itself so rapidly, this study should be replicated t to investigate how these changes affect the gap between revised curricula and current industry expectations. [ABSTRACT FROM AUTHOR]

Background: More than 30 years ago, Harmon distinguished developmental research articles (RAs), which propose a solution to a problem, from experimental RAs, but the developmental format has received little attention. Literature review: Genre analysis of RAs has been largely restricted to articles following the standard experimental/Introduction, Methods, Results, Discussion (IMRD) format, thereby excluding many developmental engineering articles. Recently, a textbook proposed Introduction, Process, Testing, Conclusion (IPTC) as a prototypical format for electrical engineering RAs, but this format has not yet been demonstrated from a corpus. Research questions: 1. What is the macrostructure of electrical engineering RAs? 2. What are the characteristic features of each division of electrical engineering RAs? Methodology: Section headings, wordcount, and notable features were analyzed for 75 RAs from 15 electrical engineering journals and compared with both IPTC and Harmon's developmental structure. Results: Only one article, a case study, followed IMRD. Sixty-seven developmental RAs followed the IPTC format. These are distinguished by the second division (P), where the new solution is described, written in extended style, comprising several sections with headings specific to the research. A paragraph at the end of the Introduction describing the organization of the paper, the location of the theoretical framework and testing methods, and a ubiquitous Conclusion also differ from IMRD. Seven developmental RAs exhibited a hybrid format with the well-known IMRD section headings superimposed on an IPTC structure. Conclusions: Most electrical engineering articles are developmental and follow IPTC format. This can inform future genre analysis research and has pedagogical implications for teaching engineering writing. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for a special issue of the journal "Programming & Computer Software" titled "Recent Trends on Advanced Computing: The Converging Technologies." The issue features research and practical implementation results from researchers and industry experts in computer science, engineering, and technology. The papers cover a range of topics including microservices, software quality, user engagement on social media, non-functional requirements, medical software architecture, fallacies in political speeches, intelligent learning environments, and more. The guest editors for this special issue are Prof. Dr. Andrei Tchernykh, Prof. Reyes Juárez Ramírez, Dr. Esteban Mocskos, and Prof. Sergio Nesmachnow. [Extracted from the article]

Execution traces comprehension is an important topic in computer science since it allows software engineers to get a better understanding of the system behavior. However, traces are usually very large and hence they are difficult to interpret. Parallel, execution traces comprehension is a very important topic into the algorithms learning courses since it allows students to get a better understanding of the algorithm behavior. Therefore, there is a need to investigate ways to help students (and teachers) find and understand important information conveyed in a trace despite the trace being massive. In this paper, we propose a new approximation for execution traces comprehension based on fuzzy linguistic descriptions. A new methodology and a data-driven architecture based on linguistic modelling of complex phenomenon are presented and explained. In particular, they are applied to automatically generate linguistic reports from execution traces generated during the execution of algorithm implemented by the students of an introductory course of artificial intelligence. To the best of our knowledge, it is the first time that linguistic modelling of complex phenomenon is applied to execution traces comprehension. Throughout the article, it is shown how this kind of technology can be employed as a useful computer-assisted assessment tool that provides students and teachers with technical, immediate and personalised feedback about the algorithms that are being studied and implemented. At the same time, they provide us with two useful applications: they are an indispensable pedagogical resource for improving comprehension of execution traces, and they play an important role in the process of measuring and evaluating the "believability" of the agents implemented. To show and explore the possibilities of this new technology, a web platform has been designed and implemented by one of the authors, and it has been incorporated into the process of assessment of an introductory artificial intelligence course. Finally, an empirical evaluation to confirm our hypothesis was performed and a survey directed to the students was carried out to measure the quality of the learning-teaching process by using this methodology enriched with fuzzy linguistic descriptions. [ABSTRACT FROM AUTHOR]

This study aims to examine research collaboration between universities and industry in the field of computer science using bibliometric methods. To further understand the impact of individual countries on university-industry (UI) collaboration, data were retrieved from the computer science journal papers included in the Science Citation Index and published during the period 2002--2011. The density, degree centrality, betweenness centrality, and closeness centrality of UI collaborative networks were calculated in order to ascertain the core countries involved in international UI collaboration. This study investigates university-industry collaborative papers (UI papers) at the global and country levels. At the global level, the results show an increasing trend in UI papers and a stable UI collaboration ratio during the last decade. The average number of authors for UI papers is 4.13, which is higher than that for all other papers. Most UI papers result from two-institution collaboration, but we observed an increase in the number of UI papers produced by multiple universities and industrial entities. At the country level, the results also show that international UI paper collaboration has intensified. Meanwhile, the USA is the dominant collaborative partner with many countries and has produced the highest number of UI papers globally. [ABSTRACT FROM AUTHOR]

Many test case generation algorithms have been proposed to test Android apps through their graphical user interfaces. However, no systematic study on the impact of the core design elements in these algorithms on effectiveness and efficiency has been reported. This paper presents the first controlled experiment to examine three key design factors, each of which is popularly used in GUI traversal-based test case generation techniques. These three major factors are definition of GUI state equivalence, state search strategy, and waiting time strategy in between input events. The empirical results on 33 Android apps with real faults revealed interesting results. First, different choices of GUI state equivalence led to significant difference on failure detection rate and extent of code coverage. Second, searching the GUI state hierarchy randomly is as effective as searching it systematically. Last but not the least, the choices on when to fire the next input event to the app under test is immaterial so long as the length of the test session is practically long enough such as 1 h. We also found two new GUI state equivalence definitions that are statistically as effective as the existing best strategy for GUI state equivalence. [ABSTRACT FROM AUTHOR]

The invention of the computer has led to the establishment of a new research paradigm, computation, which has recently become more and more popular in scientific exploration. However, computation is not well represented in high school and university curricula in science and engineering, although it applies to a wide range of disciplines beyond computer science and software engineering. In light of the increasing need to provide students with computational education, this paper presents a novel way to develop computational thinking among students. The proposed approach is based on the implementation of Papert's theory of constructionism in electronic spreadsheets. In this approach, students build their knowledge while constructing the difference equation that describes a physical (or engineering) phenomenon, based on specific cases investigated in the spreadsheet. The method does not require the students to write code or perform complex calculations in the spreadsheet and makes it possible to teach advanced subjects at a relatively early stage. The method is demonstrated through contents taken from the secondary and tertiary curricula in mechanics and electromagnetism. [ABSTRACT FROM AUTHOR]

The aim of this study was mapping, visualizing and determining subject trends in the field of information retrieval using author co-citation network based on articles indexed in Scopus from 2005-2018. This scientometric study was performed using co-citation analysis. Research population includes all articles indexed in Scopus in the field of information retrieval from 2005 to 2018. Therefore, 35018 papers were retrieved in this field. VOSviewer was used to analyze the author co-citation. The study indicated that a total of 604757 authors were co-cited, 212328 journals were cited. Also highly cited articles and sources were determined. Amongst countries, United States, China, United Kingdom, Germany and Canada ranked one to five, respectively. Computer science was a pioneer with regard to interdisciplinary area in IR. It is noteworthy that visualization of author co-citation in field of IR determined ten clusters, namely knowledge and information science, computer science, electronics, information retrieval, information seeking behavior, psychology, multimedia information retrieval, software engineering, ophthalmology and surgery. [ABSTRACT FROM AUTHOR]

Determining the most appropriate learning technique(s) is vital for the accurate and effective software fault prediction (SFP). Earlier techniques used for SFP have reported varying performance for different software projects and none of them has always reported the best performance across different projects. The problem of varying performance can be solved by using an approach, which partitions the fault dataset into different module subsets, trains learning techniques for each subset, and integrates the outcomes of all the learning techniques. This paper presents an approach that dynamically selects learning techniques to predict the number of software faults. For a given testing module, the presented approach first locates its neighbor module subset that contained modules similar to testing module using a distance function and then chooses the best learning technique in the region of that module subset to make the prediction for testing module. The learning technique is selected based on its past performance in the region of module subset. We have performed an evaluation of the proposed approach using fault datasets garnered from the PROMISE data repository and Eclipse bug data repository. Experimental results showed that the proposed approach led to an improved performance when predicting the number of faults in software systems. [ABSTRACT FROM AUTHOR]

Highlights • An architectural assumption management process with guidelines is developed. • Two case studies were conducted to validate the process. • The process can help to make architectural assumptions explicit. • The process can help to identify and reduce invalid architectural assumptions. Abstract Context Architectural assumption management is critical to the success of software development projects. In this paper, we propose an Architectural Assumption Management (AAM) process, comprised of four AAM activities: Architectural Assumption Making, Description, Evaluation, and Maintenance. Objective Evaluating the AAM process in architectural assumption management, regarding the ease of understanding and the effort of conducting the AAM process, as well as the effectiveness of using the AAM process to make architectural assumptions explicit and to identify and reduce invalid architectural assumptions. Method An explanatory study with 88 first-year master students in software engineering, and an exploratory study with five practitioners from five companies. Results (1) the ease of understanding the AAM process is moderate for first-year master students but easy for practitioners; (2) the effort of conducting the AAM process is moderate for first-year master students; (3) Making and Evaluation took the students more time than Description and Maintenance; (4) the practitioners considered Evaluation as the most time consuming activity; (5) the AAM process can help to make architectural assumptions explicit and to identify and reduce invalid architectural assumptions in projects. The majority of the students and practitioners agreed that Architectural Assumption Evaluation is the most helpful activity for all these three aspects. For other activities, there are different opinions about their helpfulness; and (6) there are various factors identified that can impact the aforementioned results. Being aware of and properly adjusting these factors can facilitate the application of the AAM process in projects. Conclusions The AAM process aims at systematically managing architectural assumptions in software development. The results of the case studies provide preliminary empirical evidence for the evaluation of the AAM process. [ABSTRACT FROM AUTHOR]

In recent years, misconfigurations have become one of the major causes of software system failures, resulting in numerous service outages. What is worse, misconfigurations are also costly to diagnose and troubleshoot. This remains a great challenge for sysadmins (system administrators) to detect, diagnose, or troubleshoot these misconfigurations. Unlike software bugs, misconfigurations are more vulnerable to sysadmins’ mistakes. Developers and researchers are attempting to improve system reactions to misconfigurations to ease the burden of sysadmins’ diagnoses. Such efforts would greatly benefit from the techniques that can comprehensively detect bad system reactions through injected misconfigurations. Unfortunately, few such studies have achieved the above goal in the past, primarily because they only relied on generic alterations and failed to find a way to systematically generate misconfigurations. In this paper, we study eight mature open-source and commercial software packages and summarize a fine-grained classification of option types. Based on this classification, we use Augmented Backus–Naur Form to summarize and extract syntactic and semantic constraints of each type. In order to generate comprehensive misconfigurations in the test systems, we propose misconfiguration generation methods for our constraints. We implement a tool named Configuration Vulnerability Detector (ConfVD) to conduct misconfiguration injection and further analyze the systems’ reaction abilities to various misconfigurations. We carried out comprehensive analyses upon Apache Httpd, MySQL, PostgreSQL, and Yum. The results of our analysis show that our option classification covers 96% of 1582 options from the above-mentioned systems. Our constraints are more fine grained than previous works and their accuracy was found to be 91% (ascertained by manual verification). Our technique could improve generic alteration approaches without constraints, and we found that ConfVD could find nearly three times the bad reactions that were found by ConfErr. In total, we found 65 bad reactions from the systems being tested and our fine-grained constraints contributed 27.7% more bad reactions than techniques only using coarse-grained constraints. [ABSTRACT FROM AUTHOR]

A bridge role metric model is put forward in this paper. Compared with previous metric models, our solution of a large-scale object-oriented software system as a complex network is inherently more realistic. To acquire nodes and links in an undirected network, a new model that presents the crucial connectivity of a module or the hub instead of only centrality as in previous metric models is presented. Two previous metric models are described for comparison. In addition, it is obvious that the fitting curve between the results and degrees can well be fitted by a power law. The model represents many realistic characteristics of actual software structures, and a hydropower simulation system is taken as an example. This paper makes additional contributions to an accurate understanding of module design of software systems and is expected to be beneficial to software engineering practices. [ABSTRACT FROM AUTHOR]

Event-based communication is used in different domains including telecommunications, transportation, and business information systems to build scalable distributed systems. Such systems typically have stringent requirements for performance and scalability as they provide business and mission critical services. While the use of event-based communication enables loosely-coupled interactions between components and leads to improved system scalability, it makes it much harder for developers to estimate the system's behavior and performance under load due to the decoupling of components and control flow. In this paper, we present our approach enabling the modeling and performance prediction of event-based systems at the architecture level. Applying a model-to-model transformation, our approach integrates platform-specific performance influences of the underlying middleware while enabling the use of different existing analytical and simulation-based prediction techniques. In summary, the contributions of this paper are: (1) the development of a meta-model for event-based communication at the architecture level, (2) a platform aware model-to-model transformation, and (3) a detailed evaluation of the applicability of our approach based on two representative real-world case studies. The results demonstrate the effectiveness, practicability and accuracy of the proposed modeling and prediction approach. [ABSTRACT FROM AUTHOR]

The purpose of regression testing is to ensure that changes made to software, such as adding new features or modifying existing features, have not adversely affected features of the software that should not change. Regression testing is usually performed by running some, or all, of the test cases created to test modifications in previous versions of the software. Many techniques have been reported on how to select regression tests so that the number of test cases does not grow too large as the software evolves As the software systems evolve with time, regression testing is an important and very expensive activity to ensure that this evolution will not disrupt the existing functionalities of the system. An important issue, in this context, is optimal selection of subset of test cases from the initial test suite to minimize the testing time, cost and effort. Researchers have proposed various types of regression test selection techniques that are code-based, and modelbased. Code-based regression test selection techniques can be effectively applied for unit-testing. It uses relationship between code parts and test cases that traverse them to locate test cases for retest when code is modified. This paper is the analysis of both code-based and model-based regression testing technique according to some comparison and evaluation criterion. [ABSTRACT FROM AUTHOR]

An architecture haiku aims to capture software system architecture's most important details on a single piece of paper. An architecture haiku helps development teams focus on the most essential information relevant to the architecture, provides clear guidance for construction, and encourages collaboration. [ABSTRACT FROM PUBLISHER]

Model composition plays a central role in many software engineering activities, e.g., evolving design models to add new features. To support these activities, developers usually rely on model composition heuristics. The problem is that the models to-be-composed usually conflict with each other in several ways and such composition heuristics might be unable to properly deal with all emerging conflicts. Hence, the composed model may bear some syntactic and semantic inconsistencies that should be resolved. As a result, the production of the intended model is an error-prone and effort-consuming task. It is often the case that developers end up examining all parts of the output composed model instead of prioritizing the most critical ones, i.e., those that are likely to be inconsistent with the intended model. Unfortunately, little is known about indicators that help developers (1) to identify which model is more likely to exhibit inconsistencies, and (2) to understand which composed models require more effort to be invested. It is often claimed that software systems remaining stable over time tends to have a lower number of defects and require less effort to be fixed than unstable systems. However, little is known about the effects of software stability in the context of model evolution when supported by composition heuristics. This paper, therefore, presents an exploratory study analyzing stability as an indicator of inconsistency rate and resolution effort on model composition activities. Our findings are derived from 180 compositions performed to evolve design models of three software product lines. Our initial results, supported by statistical tests, also indicate which types of changes led to lower inconsistency rate and lower resolution effort. [ABSTRACT FROM AUTHOR]

The accuracy of performance-prediction models is crucial for widespread adoption of performance prediction in industry. One of the essential accuracy-influencing aspects of software systems is the dependence of system behaviour on a configuration, context or history related state of the system, typically reflected with a (persistent) system attribute. Even in the domain of component-based software engineering, the presence of state-reflecting attributes (the so-called internal states) is a natural ingredient of the systems, implying the existence of stateful services, stateful components and stateful systems as such. Currently, there is no consensus on the definition or method to include state-related information in component-based prediction models. Besides the task to identify and localise different types of stateful information across component-based software architecture, the issue is to balance the expressiveness and complexity of prediction models via an effective abstraction of state modelling. In this paper, we identify and classify stateful information in component-based software systems, study the performance impact of the individual state categories, and discuss the costs of their modelling in terms of the increased model size. The observations are formulated into a set of heuristics-guiding software engineers in state modelling. Finally, practical effect of state modelling on software performance is evaluated on a real-world case study, the SPECjms2007 Benchmark. The observed deviation of measurements and predictions was significantly decreased by more precise models of stateful dependencies. [ABSTRACT FROM AUTHOR]

To predict the performance of an application, it is crucial to consider the performance of the underlying infrastructure. Thus, to yield accurate prediction results, performance-relevant properties and behaviour of the infrastructure have to be integrated into performance models. However, capturing these properties is a cumbersome and error-prone task, as it requires carefully engineered measurements and experiments. Existing approaches for creating infrastructure performance models require manual coding of these experiments, or ignore the detailed properties in the models. The contribution of this paper is the Goal-oriented INfrastructure Performance EXperiments ( Ginpex) approach, which introduces goal-oriented and model-based specification and generation of executable performance experiments for automatically detecting and quantifying performance-relevant infrastructure properties. Ginpex provides a metamodel for experiment specification and comes with predefined experiment templates that provide automated experiment execution on the target platform and also automate the evaluation of the experiment results. We evaluate Ginpex using three case studies, where experiments are executed to quantify various infrastructure properties. [ABSTRACT FROM AUTHOR]

Background: Cell tracking experiments, based on time-lapse microscopy, have become an important tool in biomedical research. The goal is the reconstruction of cell migration patterns, shape and state changes, and, comprehensive genealogical information from these data. This information can be used to develop process models of cellular dynamics. However, so far there has been no structured, standardized way of annotating and storing the tracking results, which is critical for comparative analysis and data integration. The key requirement to be satisfied by an ontology is the representation of a cell's change over time. Unfortunately, popular ontology languages, such as Web Ontology Language (OWL), have limitations for the representation of temporal information. The current paper addresses the fundamental problem of modeling changes of qualities over time in biomedical ontologies specified in OWL. Results: The presented analysis is a result of the lessons learned during the development of an ontology, intended for the annotation of cell tracking experiments. We present, discuss and evaluate various representation patterns for specifying cell changes in time. In particular, we discuss two patterns of temporally changing information: n-ary relation reification and 4d fluents. These representation schemes are formalized within the ontology language OWL and are aimed at the support for annotation of cell tracking experiments. We analyze the performance of each pattern with respect to standard criteria used in software engineering and data modeling, i.e. simplicity, scalability, extensibility and adequacy. We further discuss benefits, drawbacks, and the underlying design choices of each approach. Conclusions: We demonstrate that patterns perform differently depending on the temporal distribution of modeled information. The optimal model can be constructed by combining two competitive approaches. Thus, we demonstrate that both reification and 4d fluents patterns can work hand in hand in a single ontology. Additionally, we have found that 4d fluents can be reconstructed by two patterns well known in the computer science community, i.e. state modeling and actor-role pattern. [ABSTRACT FROM AUTHOR]

In the eWaterCycle II project we took up the challenge to "do Open Hydrology right". Ichallenge that we ourselves suggested in our commentary paper "Let hydrologistslearn the latest computer science by working with Research Software Engineers(RSEs) and not reinvent the waterwheel ourselves" [Hut 2017]. For computationalhydrology to be reproducible and re-usable, merely making data and software openlyavailable will not be enough. Models and model-components will have to communicatethrough well defined open interfaces to allow reusability by other scientist withoutforcing those scientists to become an expert in the code that they are trying to buildon.The goals we have for the eWaterCycle II project is to provide the hydrological communitywith tools that: Allow the use of a wide variety of models, written in different programming languages, without having to learn those languages. Run models needing large amounts of memory and CPUs. Have access to all the relevant datasets from the community (forcing, observations) Allow advanced use cases such as data assimilation and model coupling studies. Allow the sharing of models with the entire community, both for citing (DOIs) and re-use.Ultimately providing hydrologists with a toolset that allows them to run each other models, butalso adept, couple, and in general tinker with models without the headache of having to delveinto each others detailed code. Currently one year into this three year project, at the General Assembly we willdemonstrate, and make accessible to fellow hydrologist the first version of our system wherescientists can: Get started with modelling without installing a single piece of software. Run any of the available models within minutes. Add their own model with minimal effort. Compare output of their model, as well as that of colleagues to standard observations like discharge from the Global River Data Centre. Develop code quickly in a notebook environment. At the PICO screen we will have a life demonstration of this system. [ABSTRACT FROM AUTHOR]