Search

The protection of original achievements including patents and copyrights is a significant and critical issue in today's knowledge-driven economy. In this article, we propose and develop a blockchain service architecture to enhance information traceability and protection effectiveness. Our proposed service architecture is enabled by the core functionalities of blockchain technology including distributed data storage, peer-to-peer transmission, consensus mechanisms, and encryption algorithms. Through this blockchain-based traceability system, we can record, secure, validate, and track original achievements’ registrations and other related transactions. The results of our simulation experiments further validate the effectiveness and robustness of the proposed traceability system design. Our experimental analysis shows that the proposed blockchain-based design can effectively enhance original achievements traceability with an embedded automatic incentive rewarding mechanism for both the creation and protection of original achievements. Moreover, our performance analysis and comparative analysis show that the proposed method has more advantages over several other methods. While our study provides an effective solution to address the existing challenges in intellectual property rights and achievements patents protection, the breadth of the blockchain concept and its applications require nuanced investigations in many different contexts. Thus, the proposed blockchain-based traceability system highlights the potential for broader applications of this disruptive technology in many other domains.

Empirical research aims to establish generalizable claims from data. Such claims involve concepts that often must be measured indirectly by using indicators. Construct validity is concerned with whether one can justifiably make claims at the conceptual level that are supported by results at the operational level. We report a quantitative analysis of the awareness of construct validity in the software engineering literature between 2000 and 2019 and a qualitative review of 83 articles about human-centric experiments published in five high-quality journals between 2015 and 2019. Over the two decades, the appearance in the literature of the term construct validity increased sevenfold. Some of the reviewed articles we reviewed employed various ways to ensure that the indicators span the concept in an unbiased manner. We also found articles that reuse formerly validated constructs. However, the articles disagree about how to define construct validity. Several interpret construct validity excessively by including threats to internal, external, or statistical conclusion validity. A few articles also include fundamental challenges of a study, such as cheating and misunderstandings of experiment material. The diversity of topics discussed makes us recommend a minimalist approach to construct validity. We propose seven guidelines to establish a common ground for addressing construct validity in software engineering.

In order to optimise the corporate HR information system, IoT first-off technology is used, together with the system demand phase, with edge control in mind. initially, the hardware and software system are set up, and only then the communication models between the edge layer of the system and other parties are created edge layer, and the business type-driven connection selection method are considered. To ensure communication reliability across various levels of the system, northbound multilink switching algorithms are created and implemented, accordingly. After implementing the functions described above, the edge control system may be implemented. Ensure IoT applications satisfy intelligence, expandability, and security needs. due diligence and due diligence are required The campaign was aimed primarily at the enterprise, with the goal of defining the functional and performance requirements of the product. Ensuring the fundamental logical structure in the system design phase; in the system architecture design phase, the other features of the system architecture Realization of design is accomplished. a set of system module functions exists planned down to the last detail. Pay and benefits management are only two aspects of the whole management function. Employee personnel change is one of the e system's modules. Payroll, benefits, and personnel administration are referred to as department management. Human resource management is a process system modules go through; as far as system implementation is concerned, system coding occurs. In addition, development tool and software development methodology support the creation of pages. The system has finally been realised the system design goals are set up to mimic the business's real needs, which are then put to the test.

UVM is the most important mechanism in the field of SoC Verification. But complex characteristics, implementation difficulties in UVM still persist which leads to at most challenging part for the improvisation. To solve this issue, a new verification methodology called VEDA (Verification Environment for IP Architectures) which integrates python as the verification language is proposed. The powerful features of Python are used to bring the most versatile environment for verification and to make the UVM as the user friendly mechanism. The paper proposes the verification mechanism for the different IP’s which plays asignificant role in all IoT applications. Further the proposed method is being compared to existing UVM and also other existing python HDL tools and proved to be more advantages when compared to the existing methodologies.

One of the biggest challenges while migrating from a monolith architecture to a microservice architecture is to define a proper communication technology. In monolith applications, communication between components is performed using the in-process method or function calls, while different communication methods have to be established to achieve the same functionality in a microservice architecture. A microservices-based application is a distributed system running on multiple processes or services. Therefore, microservices must interact using inter-process communication technologies. This research aims to evaluate synchronous and asynchronous communication technologies and determine particular cases for their application while decomposing monolith into cloud-native applications. Five communication technologies, such as HTTP Rest, RabbitMQ, Kafka, gRPC, and GraphQL, have been evaluated and compared by proposed evaluation criteria. The advantages and disadvantages of each communication technology were identified in the context of microservices architecture.

An emergency response process outlines the workflow of different activities that need to be performed in response to an emergency. Effective emergency response requires communication and coordination with the operational systems belonging to different collaborating organizations. Therefore, it is necessary to establish information sharing and system-level interoperability among the diverse operational systems. Unlike typical e-government processes that are well structured and have a well-defined outcome, emergency response processes are knowledge-centric and their workflow structure and execution may evolve as the incident unfolds. It is impractical to define static plans and response process workflows for every possible situation. Instead, a dynamic response should be adaptable to the changing situation. We present an integrated approach that facilitates the dynamic composition of an executable response process. The proposed approach employs ontology-based reasoning to determine the default actions and resource requirements for the given incident and to identify relevant response organizations based on their jurisdictional and mutual aid agreement rules. The Web service APIs of the identified response organizations are then used to generate an executable response process that evolves dynamically. The proposed approach is implemented and experimentally validated using an example scenario derived from the FEMA Hazardous Materials Tabletop Exercises Manual.

Software ecosystems are considered the natural evolution of software product lines. A software ecosystem provides a (software) product within a particular business and organizational context that supports the exchange of activities and services within a domain. However, the increasing degree of autonomy demanded by software ecosystems is elevating the system response to end users, while the existing software ecosystem architectures are not well prepared to deal with the dynamicity of context changes and autonomous behavior needs. In order to provide a transition toward an increased level of autonomy, in this article, we introduce the notion of autonomous dynamic ecosystems as representative of those software ecosystems able to support dynamic, smart, and autonomous features demanded by modern software systems. In this work, we further investigate and provide evidence of four industrial examples that have fully embodied the principles of autonomous dynamic ecosystems, and we characterize the main features and technology requirements of this kind of new ecosystems.

Due to their increasing complexity, today's software systems are frequently built by leveraging reusable code in the form of libraries and packages. Software ecosystems (e.g., npm) are the primary enablers of this code reuse, providing developers with a platform to share their own and use others' code. These ecosystems evolve rapidly: developers add new packages every day to solve new problems or provide alternative solutions, causing obsolete packages to decline in their importance to the community. Developers should avoid depending on packages in decline, as these packages are reused less over time and may become less frequently maintained. However, current popularity metrics (e.g., Stars, and Downloads) are not fit to provide this information to developers because their semantics do not aptly capture shifts in the community interest. In this paper, we propose a scalable approach that uses the package's centrality in the ecosystem to identify packages in decline. We evaluate our approach with the npm ecosystem and show that the trends of centrality over time can correctly distinguish packages in decline with an ROC-AUC of 0.9. The approach can capture 87% of the packages in decline, on average 18 months before the trend is shown in currently used package popularity metrics. We implement this approach in a tool that can be used to augment the npms metrics and help developers avoid packages in decline when reusing packages from npm., Accepted in the Special Issue on Collaboration and Innovation Dynamics in Software Ecosystems

Functional and nonfunctional characteristics of software systems are defined by their architecture. Therefore, research streams such as Internet-of-Things (IoT) or component-based software engineering provide researchers and practitioners with construction guidelines for selected architectural characteristics. Current systems can be categorized in delivering services to the user and being engineered in a smart way. For example, services being provided by IoT-Systems must fulfill users’ goals in a highly dynamic and ad-hoc way. Consequently, this survey aims at answering various research questions regarding the methodical composition of system components and services. Furthermore, new research opportunities are sketched that should be tackled to make the scientific progress available to practitioners. Based on a systematic literature review from a software architecture point of view, in this paper we identify 75 primary studies for domain-specific IoT component composition approaches and architectures. Initial results show that current integration approaches mainly focus on performance evaluation of their integration solutions, which may be too narrow for fulfilling user goals by utilizing of IoT architectures.

Generating 3D models from 2D images or sketches is a widely studied important problem in computer graphics. We describe the first method to generate a 3D human model from a single sketched stick figure. In contrast to the existing human modeling techniques, our method does not require a statistical body shape model. We exploit Variational Autoencoders to develop a novel framework capable of transitioning from a simple 2D stick figure sketch, to a corresponding 3D human model. Our network learns the mapping between the input sketch and the output 3D model. Furthermore, our model learns the embedding space around these models. We demonstrate that our network can generate not only 3D models, but also 3D animations through interpolation and extrapolation in the learned embedding space. In addition to 3D human models, we produce 3D horse models in order to show the generalization ability of our framework. Extensive experiments show that our model learns to generate compatible 3D models and animations with 2D sketches., Scientific and Technological Research Council of Turkey (TÜBİTAK); European Union (EU); European Commission (EC); ERA-NET Program; The IMOTION project

Security analysts rely on scenarios to assess vulnerabilities, project attacks, and decide on security requirements that mitigate the threat. However, eliciting natural language scenarios from stakeholders can be an ad-hoc process and subject to ambiguity and incompleteness. In this paper, we examine systematic scenario elicitation by introducing a method based on user stories that uses a simplified process model of iterative scenario refinement. The process consists of three steps: 1) eliciting an interaction statement that describes a critical action performed by a user or system process; 2) eliciting one or more descriptive statements about a technology that enables the interaction; and 3) refinement of the technology into technical variants that correspond to design alternatives. We empirically evaluated our method by implementing our prototype in a user study that collects 30 security scenarios from participants. Based on our analysis, our proposed method is shown effective. Participants had a 100% task completion rate with 57% of participants achieving complete task-success, and the remaining 43% of participants achieving partial task-success. We also show the effect of security domain knowledge, and the benefit of using structure when collecting security requirements in natural language text. Finally, we present lessons learned and future research directions.

Existing programming practices for building Android apps mainly follow the one-size-fits-all strategy to include lots of functions and adapt to most types of devices. However, this strategy can result in software bloat and many serious issues, such as slow download speed, and large attack surfaces. Existing solutions cannot effectively debloat an app as they either lack flexibility or require human efforts. This work proposes a novel feature-oriented debloating approach and builds a new tool, named XDebloat, to automate this process in a flexible manner. First, XDebloat supports feature location approaches at a fine granularity. It also makes the feature location results editable and changeable. Second, XDebloat considers several Android-oriented issues (i.e., callback, UI dependencies), which are not covered in the state-of-art approaches. Third, XDebloat support two major debloating strategies: pruning-based and module-based debloating. We evaluate XDebloat with 200 open-source and 1,000 commercial apps. The results show that XDebloat can successfully remove unwanted features from apps or transform them into on-demand modules within 10 minutes. For the pruning-based debloating strategy, on average, XDebloat can remove 32.1% code from an app. For the module-based debloating strategy, XDebloat can help developers build modules automatically.

The Internet of Things (IoT) aids an interconnection between systems, humans, and services to develop computation-intensive autonomous applications. Service-oriented architecture (SOA) concepts have been used as defacto software architecture to develop IoT-based systems. Though SOA facilitates various benefits, several challenges exist for integration with IoT-based systems, including configurability, interoperability, and manageability. The ontology-based approach provides a semantically enriched and rigorous platform for interoperating different heterogeneous IoT-based systems and applications. The semantic modelling research has focused on IoT resource management without concerning the method of accessing and utilizing IoT information. In this context, an IoT-based large-scale SOA (IoT-LSS) ontology is proposed that supports interoperability, heterogeneity, flexibility, manageability, extendibility, scalability. This ontology integrates the concept of large-scale SOA (LSS) with semantic sensor network (SSN) ontology. Clinical decision support system (CDSS) ontology has considered as a case study to illustrate the proposed ontology. A detailed comparative analysis between the proposed system and several existing IoT-based service ontologies has been performed based on different characteristics. This analysis shows that IoT-LSS supports dynamic features and exposes to service with its different mechanisms. This article presents an ontological framework for the IoT service-based environment to efficiently use for service composition mechanisms in the large service domain.

Grounded Theory (GT), a sociological research method designed to study social phenomena, is increasingly being used to investigate the human and social aspects of software engineering (SE). However, being written by and for sociologists, GT is often challenging for a majority of SE researchers to understand and apply. Additionally, SE researchers attempting ad hoc adaptations of traditional GT guidelines for modern socio-technical (ST) contexts often struggle in the absence of clear and relevant guidelines to do so, resulting in poor quality studies. To overcome these research community challenges and leverage modern research opportunities, this paper presents Socio-Technical Grounded Theory (STGT) designed to ease application and achieve quality outcomes. It defines what exactly is meant by an ST research context and presents the STGT guidelines that expand GT's philosophical foundations, provide increased clarity and flexibility in its methodological steps and procedures, define possible scope and contexts of application, encourage frequent reporting of a variety of interim, preliminary, and mature outcomes, and introduce nuanced evaluation guidelines for different outcomes. It is hoped that the SE research community and related ST disciplines such as computer science, data science, artificial intelligence, information systems, human computer/robot/AI interaction, human-centered emerging technologies (and increasingly other disciplines being transformed by rapid digitalisation and AI-based augmentation), will benefit from applying STGT to conduct quality research studies and systematically produce rich findings and mature theories with confidence., Comment: Accepted to IEEE Transactions on Software Engineering (Aug 2021); This author preprint is 26 pages, the final IEEE version is 25 pages due to reformatting, content is same. More details: https://rashina.com/

On-board embedded software developed for spaceflight systems (space software) must adhere to stringent software quality assurance procedures. For example, verification and validation activities are typically performed and assessed by third party organizations. To further minimize the risk of human mistakes, space agencies, such as the European Space Agency (ESA), are looking for automated solutions for the assessment of software testing activities, which play a crucial role in this context. Over the years, mutation analysis has shown to be a promising solution for the automated assessment of test suites; it consists of measuring the quality of a test suite in terms of the percentage of injected faults leading to a test failure. A number of optimization techniques, addressing scalability and accuracy problems, have been proposed to facilitate the industrial adoption of mutation analysis. However, to date, two major problems prevent space agencies from enforcing mutation analysis in space software development. In this paper, we enhance mutation analysis optimization techniques to enable their applicability to embedded software and propose a pipeline that successfully integrates them to address scalability and accuracy issues in this context, as described above. Further, we report on the largest study involving embedded software systems in the mutation analysis literature. Our research is part of a research project funded by ESA ESTEC involving private companies (GomSpace Luxembourg and LuxSpace) in the space sector. These industry partners provided the case studies reported in this paper; they include an on-board software system managing a microsatellite currently on-orbit, a set of libraries used in deployed cubesats, and a mathematical library certified by ESA., Accepted for publication on IEEE TRANSACTIONS ON SOFTWARE ENGINEERING

We present a novel Digital Twin Framework for a portable table-top sized temperature-controlled system constructed entirely using free and open-source software programs. By utilizing tools such as Robotic Process Automation (RPA) and a PLC program, the entire process was automated to achieve a true Digital Twin. Further, a mathematical model was constructed for the temperature-controlled system. The data from the physical model and the mathematical model was then compared and a what-if scenario was analyzed to predict and prevent a potential failure in the physical system. Additionally, a simulation model was created to visualize the results.

Software projects capture information in various kinds of artifacts, including source code, tests, and documentation. Such artifacts routinely encode information that is redundant, i.e., when a specification encoded in the source code is also separately tested and documented. Without supporting technology, such redundancy easily leads to inconsistencies and a degradation of documentation quality. We designed a tool-supported technique, called DScribe, that leverages redundancy between tests and documentation to generate consistent and checkable documentation and unit tests based on a single source of information. DScribe generates unit tests and documentation fragments based on a novel template and artifact generation technology. By pairing tests and documentation generation, DScribe provides a mechanism to automatically detect and replace outdated documentation. Our evaluation of the Apache Commons IO library revealed that of 835 specifications about exception handling, 85% of them were not tested or correctly documented, and DScribe could be used to automatically generate 97% of the tests and documentation.

In this paper, we propose to use production executions to improve the quality of testing for certain methods of interest for developers. These methods can be methods that are not covered by the existing test suite, or methods that are poorly tested. We devise an approach called PANKTI which monitors applications as they execute in production, and then automatically generates differential unit tests, as well as derived oracles, from the collected data. PANKTI's monitoring and generation focuses on one single programming language, Java. We evaluate it on three real-world, open-source projects: a videoconferencing system, a PDF manipulation library, and an e-commerce application. We show that PANKTI is able to generate differential unit tests by monitoring target methods in production, and that the generated tests improve the quality of the test suite of the application under consideration.

In pull-based development process, contributors submit their code to open-source projects by pull requests, which are accepted or rejected by reviewers. Contributors may modify their code, which causes several iterations of code review process, and makes code reviews time-consuming for both contributors and reviewers. In this article, we set out to study pull request modifications in a code review process. We collect nine projects on GitHub with 104 307 pull requests, and investigate pull request modifications through analyzing added commits after pull requests’ submission. By studying four research questions, we conclude our major findings as follow. First, 34.56% of collected pull requests have modifications. Pull requests with modifications have longer lifetime but higher pass rates. Second, we conclude eight modification types indicating why pull requests are modified. Third, we propose a novel method called MClassify to automatically classify pull request modifications, which achieves the accuracy of 0.807. Fourth, various modification types affect code review differently from the perspective of lifetime and pass rate. Pull requests with source control system management modifications have the longest lifetime. These findings enable developers and researchers to understand a pull-based code review process better and make improvements.

Reusability is a central concept of Web services as it allows for the construction of composite Web services at lower cost/effort. Web services offer diverse functional capabilities ({\it e.g.,} ticket purchase, hotel booking) and inherent transactional properties. However, due to the lack of an explicit and formal description of these functional and transactional perspectives, the correctness of the transactional reliability and functional properties cannot be verified. The composite Web service reliability is computed using a set of transactional requirements defined by designers throughout the Accepted Termination States (ATS) concept. The main objective of this paper is to introduce a formal model of the Web service configuration and its correctness requirements that permit to ensure the correct Web service execution from functional and transactional points of view. For that purpose, we developed a Correct Configuration Model for Transactional Composite Services (CCM4TCS) using the \eventB method. This model is used to formally validate the consistency of composite Web service configuration's properties and requirements. It allows also to check the correctness of ATS constraints that we use as reliability parameters. The correctness and the validation of our model are ensured by discharging proof obligations and by animating the specification using the ProB model-checker

Web3.0, often cited to drastically shape our lives, is ubiquitous. However, few literatures have discussed the crucial differentiators that separate Web3.0 from the era we are currently living in. Via a thorough analysis of the recent blockchain infrastructure evolution, we capture a key invariant featuring the evolution, based on which we provide the first academic definition for Web3.0. Our definition is not the only way of understanding Web3.0, yet, it captures the fundamental and defining trait of Web3.0, and meanwhile it is has two desirable properties. Under this definition, we articulate three key infrastructural enablers for Web3.0: individual blockchains, federated or centralized platforms capable of publishing verifiable states, and an interoperability platform to hyperconnect those state publishers. While innovations in all categories are necessary to fully enable Web3.0, in this paper, we present a design for the third enabler, namely HyperService, that delivers interoperability and programmability across heterogeneous blockchains and state publishers. HyperService is powered by two innovative designs: a developer-facing programming framework that allows developers to build cross-chain applications in a unified programming model; and a secure blockchain-facing cryptography protocol that provably realizes those applications on blockchains. We implement a prototype of HyperService in 62,000 lines of code to demonstrate its practicality, usability, and scalability.

Application Programming Interfaces (APIs) allow their users to reuse existing software functionality without implementing it by themselves. However, using external functionality can come at a cost. Because developers are decoupled from the API's inner workings, they face the possibility of misunderstanding, and therefore misusing APIs. Prior research has proposed state-of-the-art example-based API misuse detectors that rely on existing API usage examples mined from existing code bases. Intuitively, without a varied dataset of API usage examples, it is challenging for the example-based API misuse detectors to differentiate between infrequent but correct API usages and API misuses. Such mistakes lead to false positives in the API misuse detection results, which was reported in a recent study as a major limitation of the state-of-the-art. To tackle this challenge, in this paper, we first undertake a qualitative study of 384 falsely detected API misuses. We find that around one third of the false-positives are due to missing alternative correct API usage examples. Based on the knowledge gained from the qualitative study, we uncover five patterns which can be followed to generate artificial examples for complementing existing API usage examples in the API misuse detection. To evaluate the usefulness of the generated artificial examples, we apply a state-of-the-art example-based API misuse detector on 50 open source Java projects. We find that our artificial examples can complement the existing API usage examples by preventing the detection of 55 false API misuses. Furthermore, we conduct a pre-designed experiment in an automated API misuse detection benchmark (MUBench), in order to evaluate the impact of generated artificial examples on recall. We find that the API misuse detector covers the same true positive results with and without the artificial example, i.e., obtains the same recall of 94.7%. Our findings highlight the potential of improving API misuse detection by pattern-guided source code transformation techniques.

Internet of Things based systems (IoT systems for short) are becoming increasingly popular across different industrial domains and their development is rapidly increasing to provide value-added services to end-users and citizens. Little research to date uncovers the core development process lifecycle needed for IoT systems, and thus software engineers find themselves unprepared and unfamiliar with this new genre of system development. To ameliorate this gap, we conducted a mixed quantitative and qualitative research study where we derived a conceptual process framework from the extant literature on IoT, through which 27 key tasks for incorporation into the development processes of IoT systems were identified. The framework was then validated by means of a survey of 127 IoT practitioners from 35 countries across 6 continents with 15 different industry backgrounds. Our research provides an understanding of the most important development process tasks and informs both software engineering practitioners and researchers of the challenges and recommendations related to the development of next-generation of IoT systems.

In recent years, Python has experienced explosive growth in adoption, particularly among open source projects. While Python's dynamically-typed nature provides developers with powerful programming abstractions, that same dynamic type system allows for type-related defects to accumulate in code bases. To aid in the early detection of type-related defects, type annotations were introduced into the Python ecosystem (i.e., PEP-484) and static type checkers like mypy have appeared on the market. While applying a type checker like mypy can in theory help to catch type-related defects before they impact users, little is known about the real impact of adopting a type checker to reveal defects in Python projects. In this paper, we study the extent to which Python projects benefit from such type checking features. For this purpose, we mine the issue tracking and version control repositories of 210 Python projects on GitHub. Inspired by the work of Gao et al. on type-related defects in JavaScript, we add type annotations to test whether detects an error that would have helped developers to avoid real defects. We observe that 15% of the defects could have been prevented by mypy. Moreover, we find that there is no significant difference between the experience level of developers committing type-related defects and the experience of developers committing defects that are not type-related. In addition, a manual analysis of the anti-patterns that most commonly lead to type-checking faults reveals that the redefinition of Python references, dynamic attribute initialization and incorrectly handled Null objects are the most common causes of type-related faults. Since our study is conducted on fixed public defects that have gone through code reviews and multiple test cycles, these results represent a lower bound on the benefits of adopting a type checker. Therefore, we recommend incorporating a static type checker like mypy into the development workflow, as not only will it prevent type-related defects but also mitigate certain anti-patterns during development.

Hutton et al. (2016) argued that computational hydrology can only be a proper science if the hydrological community makes sure that hydrological model studies are executed and presented in a reproducible manner. Hut, Drost and van de Giesen replied that to achieve this hydrologists should not “re-invent the water wheel” but rather use existing technology from other fields (such as containers and ESMValTool) and open interfaces (such as the Basic Model Interface, BMI) to do their computational science (Hut et al., 2017). With this paper and the associated release of the eWaterCycle platform and software package (available on Zenodo: https://doi.org/10.5281/zenodo.5119389, Verhoeven et al., 2022), we are putting our money where our mouth is and providing the hydrological community with a “FAIR by design” (FAIR meaning findable, accessible, interoperable, and reproducible) platform to do science. The eWaterCycle platform separates the experiments done on the model from the model code. In eWaterCycle, hydrological models are accessed through a common interface (BMI) in Python and run inside of software containers. In this way all models are accessed in a similar manner facilitating easy switching of models, model comparison and model coupling. Currently the following models and model suites are available through eWaterCycle: PCR-GLOBWB 2.0, wflow, Hype, LISFLOOD, MARRMoT, and WALRUS While these models are written in different programming languages they can all be run and interacted with from the Jupyter notebook environment within eWaterCycle. Furthermore, the pre-processing of input data for these models has been streamlined by making use of ESMValTool. Forcing for the models available in eWaterCycle from well-known datasets such as ERA5 can be generated with a single line of code. To illustrate the type of research that eWaterCycle facilitates, this paper includes five case studies: from a simple “hello world” where only a hydrograph is generated to a complex coupling of models in different languages. In this paper we stipulate the design choices made in building eWaterCycle and provide all the technical details to understand and work with the platform. For system administrators who want to install eWaterCycle on their infrastructure we offer a separate installation guide. For computational hydrologists that want to work with eWaterCycle we also provide a video explaining the platform from a user point of view (https://youtu.be/eE75dtIJ1lk, last access: 28 June 2022)​​​​​​​. With the eWaterCycle platform we are providing the hydrological community with a platform to conduct their research that is fully compatible with the principles of both Open Science and FAIR science.

As a software system evolves, its architecture tends to decay, leading to the occurrence of architectural elements that become resistant to maintenance or prone to defects. To address this problem, engineers can significantly benefit from determining which architectural elements will decay before that decay actually occurs. Forecasting decay allows engineers to take steps to prevent decay, such as focusing maintenance resources on the architectural elements most likely to decay. To that end, we construct novel models that predict the quality of an architectural element by utilizing multiple architectural views (both structural and semantic) and architectural metrics as features for prediction. We conduct an empirical study using our prediction models on 38 versions of five systems. Our findings show that we can predict low architectural quality, i.e., architectural decay, with high performanceeven for cases of decay that suddenly occur in an architectural module. We further report the factors that best predict architectural quality.

Accident prevention on the manufacturing shop floor is essential. This paper aims to develop a proximity warning system capable of reducing accidents on the manufacturing shop floor, by notifying employers of any possible danger within the workplace. The system consists of an ultrasonic sensor, Arduino microcontroller, alarm system and an easy to understand user interface that can detect and alert workers within the danger zone. The system was developed using the Unified Modelling Language, python programming language and the Arduino software. Preliminary test conducted on volunteer participants revealed that the system is easy to use and provides real-time easy-to-understand audio and visual feedback to workers. The system is useful for reducing accidents on shop floors.

With the rise of cloud computing platforms, the speed of developing software has drastically increased. This increased speed requires new models of operating hardware, as the separation of development and operations departments often leads to bottlenecks in the deployment process. DevOps techniques aim at improving the collaboration between development and operation teams, promising to reduce the time until new products reach the customer and improving software quality. GitOps is a new concept claiming to be the evolution of DevOps. This paper analyzes if GitOps is really an evolution of DevOps, as in making DevOps obsolete. As neither DevOps nor GitOps have a standard definition, this paper synthesizes a definition of both concepts and compares them by their key elements. We find that GitOps is not the evolution of DevOps although they share common concepts. However, both concepts are defined by their use in industry, so additional research is required.

Different web services can be composed to perform increasingly complex tasks (e.g., making an on-line payment). However, existing approaches compose web services with hard-coded control and data flows. To proactively and autonomously compose web services, developers can develop agents. However, the development of agents for service composition is complex, due to the reasons that: 1) developers may not have the knowledge from various domains to identify the necessary tasks to carry out the required web services; and 2) a deep understanding of the agent specific code is required in order to implement agents. To alleviate the required efforts to develop agents, we propose an approach to separate the development of agent specific code from the business logic code in the service composition. More specifically, we provide an easy-to-understand syntax that abstracts agent specific code and automatically generates executable agent code. Our experimental results show that our approach can accurately identify tasks for service composition with an Area Under the Curve (AUC) of 0.88. Our experiments also demonstrate that our approach can correctly generate agent code from seven agent specifications. Finally, our user studies reveal that developers are satisfied with our approach to develop agents for service composition.

An energy efficient information and communication system is a need of the day. Information technology related industries are making efforts to reduce power consumption by improvising both the hardware infrastructure and software systems. The hardware is driven by software; hence, design and development of software may have a significant impact energy need of the overall system. Many times it is observed that complex software performs useless tasks leading to power consumption, referred to as energy leak. The solution of energy leaks for mobile applications has attracted the interest of researchers, but still handling energy leaks issues for applications developed using Java-based technology need to be explored. While designing software during maintenance phase, code smells are introduced which not only reduce performance of the software also may lead to execution of useless code thus enhancing the energy leak. The common practice of the software industry to remove the code smells is use of refactoring strategy. The basic idea of this study is to understand the impact of refactoring on total energy consumption. To explore this hypothesis a set of Java based applications are selected, code smell present in these applications are discovered and a suitable refactoring strategy is applied to reduce the code smell. Power consumption is estimated using an open source tool Microsoft Joulemeter, it monitors energy usage by machine resources and estimates power consumption. The energy consumption before and after refactoring is recorded and statistical t-test is performed to validate the proposed concept.

Computer vision systems have become a key element of modern companies. However, its implantation not only requires specialized hardware components but also software to control the correct performance of all these components. The purpose of this article is to present the design and deployment of a software created to manage the different computer vision systems of any company. First, using our experience in mechanization and industrialization of company processes, a general company specification will be proposed as well as the main software requirements that have to be satisfied. Then, a three-level modular design composed of the core, a configuration module, and user interfaces with functionalities capable of satisfying the defined requirements will be presented. Special attention will be given to time restrictions and components' synchronization. In addition, the different tests that have been carried out to control the correct performance of the software will be shown. The development process will end with a generic, modular, and scalable software able to fit different industrial scenarios by simply modifying a set of input parameters. To illustrate the correct performance of the proposal, the details of its installation in four real companies with different needs will be presented. The proposed work has a practical use in industry and it also provides a thorough description of the main components involved in computer vision systems of real company environments and how to manage them.

The ongoing problem of inconsistency in the stages of system development encourages the development and elaboration of approaches and methods aimed at eliminating the causes of their occurrence. According to the research community, one of the most promising approaches is to involve users in the development process. Six directions in the implementation of the approach to user involvement in the system development process were formed and analyzed in the article. The analysis of the applicability of such approaches and methods to the task of involving the user in the process of developing an information data model is carried out. The problems of this direction were highlighted. To solve these problems, the sensemaking approach principles which is a development of the methodology for sensemaking proposed by Brenda Dervin, are proposed to use. On the basis of the proposed sensemaking approach, the implementation of the proposed approach is shown with the help of the development of the method, a method for constructing the specification of the information model was developed. The steps of the method are represented by methods that implement the idea of involving the user in the development process by analyzing his work with elements of documentation support.

In 2009, Moody introduced nine principles for evaluating, improving and designing cognitively effective notations called the Physics of Notations [49] motivating many research works ever since, being cited more than 1250 times at the time of writing this paper. Many research works have adopted the nine principles of the Physics of Notations to improve existing notations or devise new notations. Modeling is a two-step process that has the goal of communicating a mental concept by a model constructor (step one) to a model reader (step two). A subset of the research works utilizing the Physics of Notations have empirically validated the cognitive effectiveness of the new notations by their readers. However, there lacks any empirical evidence that investigates the effect of using Physics of Notations-enabled notations in model construction. This is a serious matter to be investigated as naturally model construction preludes model comprehension. Poorly constructed models can at best be poorly comprehended by its readers having dire consequences in downstream development activities. This paper reports on three different experiments that use software engineering professionals as subjects. The experiments investigate the effect of using notations that adhere to the Physics if Notations principles on model construction efforts. The results do not indicate an outright advantage for model constructors who utilize Physics of Notations-enabled notations in comparison to using their original versions of these notations.

API misuses are well-known causes of software crashes and security vulnerabilities. However, their detection and repair is challenging given that the correct usages of (third-party) APIs might be obscure to the developers of client programs. This paper presents the first empirical study to assess the ability of existing automated bug repair tools to repair API misuses, which is a class of bugs previously unexplored. Our study examines and compares 14 Java test-suite-based repair tools (11 proposed before 2018, and three afterwards) on a manually curated benchmark (APIREPBENCH) consisting of 101 API misuses. We develop an extensible execution framework (APIARTY) to automatically execute multiple repair tools. Our results show that the repair tools are able to generate patches for 28% of the API misuses considered. While the 11 less recent tools are generally fast (the median execution time of the repair attempts is 3.87 minutes and the mean execution time is 30.79 minutes), the three most recent are less efficient (i.e., 98% slower) than their predecessors. The tools generate patches for API misuses that mostly belong to the categories of missing null check, missing value, missing exception, and missing call. Most of the patches generated by all tools are plausible (65%), but only few of these patches are semantically correct to human patches (25%). Our findings suggest that the design of future repair tools should support the localisation of complex bugs, including different categories of API misuses, handling of timeout issues, and ability to configure large software projects. Both APIREPBENCH and APIARTY have been made publicly available for other researchers to evaluate the capabilities of repair tools on detecting and fixing API misuses.