Search

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.

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

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 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.

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.

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.

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.

The increasing number of products is the trend of current industry. However, the product development process is significantly limited by budget and testing risk. Recently, digital twin has emerged as a promising industrial paradigm that provides an integrated and cohesive view of the product design process. In this paper, we propose a product design framework for Internet of Things (IoT) platforms, namely Digital Twin-aided IoT Platform Design (DTIPD). This framework considers a large number of IoT devices performing different tasks with machine learning (ML) technologies. Each IoT device constructs a particular ML-based model that deals with its task automatically by feeding related data with labels. The challenges of large-scale network management and ground truth shortage at the initial stage of product iteration are addressed. We propose a two-level hierarchical learning process using the real-time model status stored at Digital Twin Servers (DTS), aiming to improve product quality while shortening the development lifecycle. The comprehensive experimental results for both the single-DTS and multiple-DTS scenarios demonstrate the applicability of our framework.

Although the number of aspect-oriented software development techniques and tools proposed by the scientific literature have been increasing since the late 80′s, the evidence about the benefits that the aspect-oriented paradigm have reached in real-world settings is scarce. Our objective is to identify and classify the aspect-oriented software development methodologies used to reduce the effort and costs of moving from traditional approaches to the aspect-oriented approach in real-world settings. We conducted a systematic mapping study (SMS). Our search strategies retrieved a set of 3212 papers out of which 115 were selected as relevant studies. We defined eight categories to classify these studies: aspect-oriented methodologies proposed for early aspects; development early phases covered; notations; modeling techniques; supporting tools; aspect-oriented methodologies used in real-world settings; benefits reported and unsolved issues. As a result, 39 named methodologies were reported; they cover the business modeling (14 papers), requirements (93 papers), test cases (1 paper) and design (41 papers) phases of the software development life cycle (SDLC); we found 36 different notations, with UML as the most mentioned (66 papers); 22 modeling techniques were found, where the use cases were the ones that appeared the most, on 43 occasions; 43 support tools of which none was repeated in more than 3 articles; 15 applications in real-world settings; 17 benefits, modularization being the most mentioned with 4 occurrences; and 15 pending improvement opportunities. Finally, we have obtained conclusions: the literature analyzed demonstrates that there are no prevailing standards on methodologies and notations, beyond that the most employed are those belonging to the OMG; we have not found any methodology that includes all phases of the SDLC; the diagrams corresponding to OMG’s standards account for 78% of the results in the facet of modeling techniques; there are no tools that have the greatest predilection and the most used is mentioned only three times; in addition, 41% of the articles do not mention any tool; the evidence of aspect-oriented methodologies application in real-world settings reached just the 10%, although the declared benefits are coincident with those promised in the aspect-orientated literature. The mentioned pending issues can guide new studies (RQ8).

Systems integrators and vendors of industrial components need to establish a security-by-design approach, which includes the assessment and subsequent treatment of security risks. However, conducting security risk assessments along the engineering process is a costly and labor-intensive endeavor due to the complexity of the system(s) under consideration and the lack of automated methods. This, in turn, hampers the ability of security analysts to assess risks pertaining to cyber-physical systems (CPSs) in an efficient manner. In this work, we propose a method that automatically identifies security risks based on the CPS's data representation, which exists within engineering artifacts. To lay the foundation for our method, we present security-focused semantics for the engineering data exchange format AutomationML (AML). These semantics enable the reuse of security-relevant know-how in AML artifacts by means of a formal knowledge representation, modeled with a security-enriched ontology. Our method is capable of automating the identification of security risk sources and potential consequences in order to construct cyber-physical attack graphs that capture the paths adversaries may take. We demonstrate the benefits of the proposed method through a case study and an open-source prototypical implementation. Finally, we prove that our solution is scalable by conducting a rigorous performance evaluation.

This work proposes a cloud solution to build an Internet of Things (IoT) platform applied in a greenhouse crop production context. Real-time and historical data, as well as prediction models, can be accessed by means of RESTful (Representational State Transfer) web services developed for such a purpose. Forecasting is also provided following a Greenhouse Models as a Service (GMaaS) approach. Currently, our GMaaS tool provides forecasting based on computational models developed for inside climate, crop production and irrigation processes. Traditionally, such models are hardcoded in applications or are embedded in software tools to be used as Decision Support Systems (DSS). However, using a GMaaS approach, models are available as RESTful services to be used as needed. In addition, the proposed platform allows users to register new IoT devices and their greenhouse data in the FIWARE platform, providing a cloud scale solution for the case study. RESTful services of the proposed platform are also used by a web application allowing users to interact easily with the system.

Component Based Software Engineering has one main sole motive of making the development process of software systems as easy as possible and to achieve this objective work needs to be done in previous systems to identify the concerns and limitations which can be overcome using this software engineering based approach. In this paper to support concept of component based system a domain is chosen that covers the GIS systems. GIS (Geographic Information Systems) are commonly used for development of map based applications these systems are widely used across the web and in various organizations. With the development and deepening of GIS, traditional GIS systems showed the challenges on isolation, sealing, interoperability and the limitations, thereby hindering further development and application of GIS technology. In this paper framework for component based GIS system is proposed. This framework is having rich graphical interface and user data can be easily retrieved from the connected database and displayed in the browser.

Indubitably, security is an integral aspect of the development of quality software. More importantly, usability is also an elemental and pivotal factor for developing quality software. In fact, it has been noticed that most of the practitioners are trying to develop a highly secure design while maintaining high usability. Unfortunately, the highly secure design of software becomes worthless because the usability of software is very low. Further, usable security is in more demand due to the increasing usage of computers with enhanced usability and need of security in it too. When improving the usability with security of software, underlying security and usability attributes play an important role. For this reason, usable security assessment employs security and usability attributes to achieve the desired security solutions with usability. Different consecutive versions of two software have been taken in this work to assess usable security. Authors are using Fuzzy-AHP methodology to assess the priorities and overall usable-security. In addition, the impact of the security on usability and impact of the usability on security have been evaluated quantitatively. The results obtained and conclusions are useful for practitioners to improve usable-security of software.

As increasingly complex software is developed every day, a growing number of companies use static analysis tools to reason about program properties ranging from simple coding style rules to more advanced software bugs, to multi-tier security vulnerabilities. While increasingly complex analyses are created, developer support must also be updated to ensure that the tools are used to their best potential. Past research in the usability of static analysis tools has primarily focused on usability issues encountered by software developers, and the causes of those issues in analysis tools. In this article, we adopt a more user-centered approach, and aim at understanding why software developers use analysis tools, which decisions they make when using those tools, what they look for when making those decisions, and the motivation behind their strategies. This approach allows us to derive new tool requirements that closely support software developers (e.g., systems for recommending warnings to fix that take developer knowledge into account), and also open novel avenues for further static-analysis research such as collaborative user interfaces for analysis warnings.

Developing and optimizing software applications for high performance and energy efficiency is a very challenging task, even when considering a single target machine. For instance, optimizing for multicore-based computing systems requires in-depth knowledge about programming languages, application programming interfaces, compilers, performance tuning tools, and computer architecture and organization. Many of the tasks of performance engineering methodologies require manual efforts and the use of different tools not always part of an integrated toolchain. This paper presents Pegasus, a performance engineering approach supported by a framework that consists of a source-to-source compiler, controlled and guided by strategies programmed in a Domain-Specific Language, and an autotuner. Pegasus is a holistic and versatile approach spanning various decision layers composing the software stack, and exploiting the system capabilities and workloads effectively through the use of runtime autotuning. The Pegasus approach helps developers by automating tasks regarding the efficient implementation of software applications in multicore computing systems. These tasks focus on application analysis, profiling, code transformations, and the integration of runtime autotuning. Pegasus allows developers to program their strategies or to automatically apply existing strategies to software applications in order to ensure the compliance of non-functional requirements, such as performance and energy efficiency. We show how to apply Pegasus and demonstrate its applicability and effectiveness in a complex case study, which includes tasks from a smart navigation system.

In the recent years, the advances in mobile technology have brought an exorbitant change in daily lifestyle of individuals. Smartphones/mobile devices are rampant in all aspects of human life. This has led to an extreme demand for developing software that runs on mobile devices. The developers have to keep up with this high demand and deliver high-quality app on time and within budget. For this, estimation of development and testing of apps play a pivotal role. In this paper, a Systematic Literature Review (SLR) is conducted to highlight development and testing estimation process for software/application. The goal of the present literature survey is to identify and compare existing test estimation techniques for traditional software (desktop/laptop) and for mobile software/application. The characteristics that make mobile software/application different from traditional software are identified in this literature survey. Further, the trend for developing the software is towards agile, thus this study also presents and compares estimation techniques used in agile software development for mobile applications. The analysis of literature review suggests filling a research gap to present formal models for estimating mobile application considering specific characteristics of mobile software.

In the past twenty years, dozens of collaboration-based languages have emerged. Often they have an abstraction to denote a collaboration. Most of them use a form of single inheritance to build collaboration from another one. In this model, when a collaboration uses another one, every role class in the sub collaboration inherits from a role class in the super collaboration which has the same name. This affects the reusability of roles and collaborations and makes them semi interactive. To overcome this problem, this paper uses a new collaboration-based language named Set Oriented Programming (SOP). In SOP, collaborations, instead of being inherited, are composed with each other. To improve the reusability of SOP roles and to make them interactive, events are used. Events cause interaction of roles by crosscutting them. Moreover, a new context problem is discussed and dynamic context solution is proposed by delegations. Finally, we show that events improve the reusability and delegations concur context problem.

As static data-flow analysis becomes able to report increasingly complex bugs, using an evergrowing set of complex internal rules encoded into flow functions, the analysis tools themselves grow more and more complex. In result, for users to be able to effectively use those tools on specific codebases, they require special configurations—a task which in industry is typically performed by individual developers or dedicated teams. To efficiently use and configure static analysis tools, developers need to build a certain understanding of the analysis' rules, i.e., how the underlying analyses interpret the analyzed code and their reasoning for reporting certain warnings. In this article, we explore how to assist developers in understanding the analysis' warnings, and finding weaknesses in the analysis' rules. To this end, we introduce the concept of rule graphs that expose to the developer selected information about the internal rules of data-flow analyses. We have implemented rule graphs on top of a taint analysis, and show how the graphs can support the abovementioned tasks. Our user study and empirical evaluation show that using rule graphs helps developers understand analysis warnings more accurately than using simple warning traces, and that rule graphs can help developers identify causes for false positives in analysis rules.

[EN]Artificial intelligence, and the ability to learn optimized solutions that comply with a set of safety rules, could facilitate the human-based design process of safety-critical systems. However, the reconciliation of state-of-the-art artificial intelligence technology with current safety standards and safety engineering processes is a challenge to be addressed. This publication describes a method based on optimization and on formal verification for the design of safety-critical systems that are defined by Boolean algebra. Several diverse optimization techniques and a hybrid of these approaches are used to find an optimized design that considers performance requirements, availability rules and complies with all defined safety rules. Subsequently, this solution is translated into an alternative knowledge representation that can be formally verified and developed in compliance with currently considered safety standards. This method is evaluated with a simplified safety-critical case study., 10.13039/501100003329-Ministerio de Economa y Competitividad (Grant Number: PID2019-104156GB-I00) 10.13039/501100003086-Eusko Jaurlaritza (Grant Number: KK-2019-00035) 10.13039/100010661-Horizon 2020 Framework Programme (Grant Number: 761758 and 872944)

Mutation testing has been widely used to assess the fault-detection effectiveness of a test suite, as well as to guide test case generation or prioritization. Empirical studies have shown that, while mutants are generally representative of real faults, an effective application of mutation testing requires “traditional” operators designed for programming languages to be augmented with operators specific to an application domain and/or technology. The case for Android apps is not an exception. Therefore, in this paper we describe the process we followed to create (i) a taxonomy of mutation operations and, (ii) two tools, MDroid+ and MutAPK for mutant generation of Android apps. To this end, we systematically devise a taxonomy of 262 types of Android faults grouped in 14 categories by manually analyzing 2,023 software artifacts from different sources (e.g., bug reports, commits). Then, we identified a set of 38 mutation operators, and implemented them in two tools, the first enabling mutant generation at the source code level, and the second designed to perform mutations at APK level. The rationale for having a dual-approach is based on the fact that source code is not always available when conducting mutation testing. Thus, mutation testing for APKs enables new scenarios in which researchers/practitioners only have access to APK files. The taxonomy, proposed operators, and tools have been evaluated in terms of the number of non-compilable, trivial, equivalent, and duplicate mutants generated and their capacity to represent real faults in Android apps as compared to other well-known mutation tools.

Identifying refactoring operations in source code changes is valuable to understand software evolution. Therefore, several tools have been proposed to automatically detect refactorings applied in a system by comparing source code between revisions. The availability of such infrastructure has enabled researchers to study refactoring practice in large scale, leading to important advances on refactoring knowledge. However, although a plethora of programming languages are used in practice, the vast majority of existing studies are restricted to the Java language due to limitations of the underlying tools. This fact poses an important threat to external validity. Thus, to overcome such limitation, in this paper we propose RefDiff 2.0, a multi-language refactoring detection tool. Our approach leverages techniques proposed in our previous work and introduces a novel refactoring detection algorithm that relies on the Code Structure Tree (CST), a simple yet powerful representation of the source code that abstracts away the specificities of particular programming languages. Despite its language-agnostic design, our evaluation shows that RefDiff's precision (96%) and recall (80%) are on par with state-of-the-art refactoring detection approaches specialized in the Java language. Our modular architecture also enables one to seamless extend RefDiff to support other languages via a plugin system. As a proof of this, we implemented plugins to support two other popular programming languages: JavaScript and C. Our evaluation in these languages reveals that precision and recall ranges from 88% to 91%. With these results, we envision RefDiff as a viable alternative for breaking the single-language barrier in refactoring research and in practical applications of refactoring detection.

Mobile platforms are rapidly and continuously changing, with support for new sensors, APIs, and programming abstractions. Static analysis is gaining a growing interest, allowing developers to predict properties about the run-time behavior of mobile apps without executing them. Over the years, literally hundreds of static analysis techniques have been proposed, ranging from structural and control-flow analysis to state-based analysis.In this paper, we present a systematic mapping study aimed at identifying, evaluating and classifying characteristics, trends and potential for industrial adoption of existing research in static analysis of mobile apps. Starting from over 12,000 potentially relevant studies, we applied a rigorous selection procedure resulting in 261 primary studies along a time span of 9 years. We analyzed each primary study according to a rigorously-defined classification framework. The results of this study give a solid foundation for assessing existing and future approaches for static analysis of mobile apps, especially in terms of their industrial adoptability.Researchers and practitioners can use the results of this study to (i) identify existing research/technical gaps to target, (ii) understand how approaches developed in academia can be successfully transferred to industry, and (iii) better position their (past and future) approaches for static analysis of mobile apps.

The effective implementation of Industry 4.0 requires the reformulation of industrial processes in order to achieve the vertical and horizontal digitalization of the value chain. For this purpose, it is necessary to provide tools that enable their successful implementation. This paper therefore proposes a data-centric, distributed, dynamically scalable reference architecture that integrates cutting-edge technologies being aware of the existence of legacy technology typically present in these environments. In order to make its implementation easier, we have designed a metamodel that collects the description of all the elements involved in a digital platform (data, resources, applications and monitoring metrics) as well as the necessary information to configure, deploy and execute applications on it. Likewise, we provide a tool compliant to the metamodel that automates the generation of configuration, deployment and launch files and their corresponding transference and execution in the nodes of the platform. We show the flexibility, extensibility and validity of our software artefacts through their application in two case studies, one addressed to preprocess and store pollution data and the other one, more complex, which simulates the management of an electric power distribution of a smart city.

Aiming at the problems of incomplete description, ambiguity and inconsistency in the traditional requirements analysis method based on prototype system in software development, this paper proposes a requirement analysis method based on prototype portrait, introduces the process of obtaining the software requirement specification and designing the software by using the prototype portrait method according to the user’s requirements, and formalizes the process of the method, and develops the software with the prototype portrait requirement document approved by the customer, so as to ensure the correctness of the designed functional requirements. The practical results show that the requirement analysis method based on prototype portrait overcomes the problems of long development cycle and high failure rate existing in the traditional requirements analysis method of prototype system, and improves the quality and cycle of software development.

Programmers often leverage data structure libraries that provide useful and reusable abstractions. Modular verification of programs that make use of these libraries naturally rely on specifications that capture important properties about how the library expects these data structures to be accessed and manipulated. However, these specifications are often missing or incomplete, making it hard for clients to be confident they are using the library safely. When library source code is also unavailable, as is often the case, the challenge to infer meaningful specifications is further exacerbated. In this paper, we present a novel data-driven abductive inference mechanism that infers specifications for library methods sufficient to enable verification of the library's clients. Our technique combines a data-driven learning-based framework to postulate candidate specifications, along with SMT-provided counterexamples to refine these candidates, taking special care to prevent generating specifications that overfit to sampled tests. The resulting specifications form a minimal set of requirements on the behavior of library implementations that ensures safety of a particular client program. Our solution thus provides a new multi-abduction procedure for precise specification inference of data structure libraries guided by client-side verification tasks. Experimental results on a wide range of realistic OCaml data structure programs demonstrate the effectiveness of the approach.

Considering extract-transform-load (ETL) as a complex and evolutionary process, development teams must conscientiously and rigorously create log strategies for retrieving the most value of the information that can be gathered from the events that occur through the ETL workflow. Efficient logging strategies must be structured so that metrics, logs, and alerts can, beyond their troubleshooting capabilities, provide insights about the system. This paper presents a configurable and flexible ETL component for creating logging mechanisms in ETL workflows. A pattern-oriented approach is followed as a way to abstract ETL activities and enable its mapping to physical primitives that can be interpreted by ETL commercial tools.

In the curriculum of a Computer Engineering program, concepts like parallelism, concurrency, consistency, or atomicity are usually addressed in separate courses due to their thoroughness and extension. Isolating such concepts in courses helps students not only to focus on specific aspects, but also to experience the reality of working with modern computer systems, where those concepts are often detached in different abstraction levels. However, due to such an isolation, it exists a risk of inducing to the students an absence of interactions between these concepts, and, by extension, between the different abstraction levels of a system. This paper proposes a learning experience showcasing the interactions between abstraction levels addressed in laboratory sessions of different courses. The driving example is a parallel ray tracer. In the different courses, students implement and assemble components of this application from the algorithmic level of the tracer to the assembly instructions required to guarantee atomicity. Each lab focuses on a single abstraction level, but shows students the interactions with the rest of the levels. Technical results and student learning outcomes through the analysis of surveys validate the proposed experience and confirm the students learning improvement with a more integrated view of the system.

Maintenance engineers deal with increasingly complex automated production systems (aPSs). Such systems are characterized by an increasing computerization or the addition of robots that collaborate with human workers. The effects of changing or replacing components of such systems are difficult to assess since there are complex interdependencies between process parameters and the state of the components. This paper proposes a model-based training system that visualizes these interdependencies using domain-independent SysML models. The training system consists of a virtual training system for initial training and an online support system for assistance during maintenance or changeover procedures. Both systems use structural SysML models to visualize the state of the machine at a certain step of a procedure. An evaluation of the system in a changeover procedure against a paper-based manual showed promising results regarding effectiveness, usability and attractiveness., 25 pages, https://www.sciencedirect.com/science/article/pii/S0957415818300801

Web service composition allows developers to create applications via reusing available services that are interoperable to each other. The process of selecting relevant Web services for a composite service satisfying the developer requirements is commonly acknowledged to be hard and challenging, especially with the exponentially increasing number of available Web services on the Internet. The majority of existing approaches on Web Services Selection are merely based on the Quality of Service (QoS) as a basic criterion to guide the selection process. However, existing approaches tend to ignore the service design quality, which plays a crucial role in discovering, understanding, and reusing service functionalities. Indeed, poorly designed Web service interfaces result in service anti-patterns, which are symptoms of bad design and implementation practices. The existence of anti-pattern instances in Web service interfaces typically complicates their reuse in real-world service-based systems and may lead to several maintenance and evolution problems. To address this issue, we introduce a new approach based on the Multi-Objective and Optimization on the basis of Ratio Analysis method (MOORA) as a multi-criteria decision making (MCDM) method to select Web services based on a combination of their (1) QoS attributes and (2) QoS design. The proposed approach aims to help developers to maintain the soundness and quality of their service composite development processes. We conduct a quantitative and qualitative empirical study to evaluate our approach on a Quality of Web Service dataset. We compare our MOORA-based approach against four commonly used MCDM methods as well as a recent state-of-the-art Web service selection approach. The obtained results show that our approach outperforms state-of-the-art approaches by significantly improving the service selection quality of top- k selected services while providing the best trade-off between both service design quality and desired QoS values. Furthermore, we conducted a qualitative evaluation with developers. The obtained results provide evidence that our approach generates a good trade-off for what developers need regarding both QoS and quality of design. Our selection approach was evaluated as “relevant” from developers point of view, in improving the service selection task with an average score of 3.93, compared to an average of 2.62 for the traditional QoS-based approach.

Context Automotive software architectures describe distributed functionality by an interaction of software components. One drawback of today’s architectures is their strong integration into the onboard communication network based on predefined dependencies at design time. The idea is to reduce this rigid integration and technological dependencies. To this end, service-oriented architecture offers a suitable methodology since network communication is dynamically established at run-time. Aim We target to provide a methodology for analysing hardware resources and synthesising automotive service-oriented architectures based on platform-independent service models. Subsequently, we focus on transforming these models into a platform-specific architecture realisation process following AUTOSAR Adaptive. Approach For the platform-independent part, we apply the concepts of design space exploration and simulation to analyse and synthesise deployment configurations, i. e., mapping services to hardware resources at an early development stage. We refine these configurations to AUTOSAR Adaptive software architecture models representing the necessary input for a subsequent implementation process for the platform-specific part. Result We present deployment configurations that are optimal for the usage of a given set of computing resources currently under consideration for our next generation of E/E architecture. We also provide simulation results that demonstrate the ability of these configurations to meet the run time requirements. Both results helped us to decide whether a particular configuration can be implemented. As a possible software toolchain for this purpose, we finally provide a prototype. Conclusion The use of models and their analysis are proper means to get there, but the quality and speed of development must also be considered.

Online product configurators, the prevailing toolkits used to realize mass customization, embody an advanced manufacturing strategy that provides customized products with the efficiency of mass production. Essentially, a product configuration system elicits customer needs and maps those needs to product attribute specifications. However, existing configurators require that customers have the necessary domain knowledge to configure their products, which hinders the application of these configurators in current customer-centric product design and manufacturing processes. In this article, we propose a needs-based configurator mechanism that leverages online product-review text from social media. We build a source model that maps product reviews to attribute specifications using a hybrid bidirectional long short-term memory network that incorporates relevant product information at word and character levels. Transfer learning is then deployed to adapt the source model to the target customer needs-specifications mapping. Our experimental results show that the transfer-learning operation significantly improves the configurator performance.

Teaching parallel programming and HPC is a difficult task. There is a large number of sophisticated hardware and software components, each complex on their own and often showing non-intuitive interaction when used in combination. We consider education in HPC among the more difficult topics in computer science due to the fact that larger distributed memory systems are ubiquitous yet inaccessible and intangible to students. In this work, we present the Cluster Coffer, a miniature cluster computer based on 16 ARM compute boards that we believe is suitable for reducing the entry barrier to HPC in teaching and public outreach. We discuss our design goals for providing a portable, inexpensive system that is easy to maintain and repair. We outline the implementation path we took in terms of hardware and software, in order to provide others with the information required to reproduce and extend our work. Finally, we present two use cases for which the Cluster Coffer has been used multiple times, and will continue to be used in the upcoming years.

Programming courses usually focus on software-engineering problems like software decomposition and code maintenance. While computer-science lessons emphasize algorithm complexity, technological problems are usually neglected although they may significantly affect the performance in terms of wall time. As the technological problems are best explained by hands-on experience, we present a set of homework assignments focused on a range of technologies from instruction-level parallelism to GPU programming to cluster computing. These assignments are a product of a decade of development and testing on live subjects – the students of three performance-related software courses at the Faculty of Mathematics and Physics of the Charles University in Prague.

This article presents a methodology to formalize the behavior of the machines composing a production line, and to automatically generate their virtual prototypes for efficient and correct plant simulation. The approach exploits assume-guarantee reasoning through contracts to model the interaction between the different components of a production line. The approach is guided by a well-known taxonomy of industrial machines and associated manufacturing processes to identify each elementary action related to a specific machine. Contracts enable to build executable models of all the machines available in the production line by using automatic synthesis. The generated models can be integrated into a state-of-the-practice industrial plant simulation software to estimate and validate the production line's behavior. The presentation of the methodology is supported by a running example based on a real production line, showing the step-by-step application of the approach to a concrete scenario.

This paper presents an automated, domain-independent, metamorphic testing platform called MTKeras. In this paper, we report on an investigation demonstrating the effectiveness and usability of MTKeras through five case studies in the four domains of image classification, sentiment analysis, search engines and database management systems. We also report on the effectiveness of combining metamorphic relation (input) patterns in individual metamorphic relations, enhancing the failure-finding abilities of the individual relations. The results of our experiments support combining patterns, and the use of MTKeras. The research reported in this paper shows the applicability of metamorphic relation patterns, and introduces a practical tool for the research community.

Different types of agile approaches and LEAN methodologies have guided the development of solutions based on a minimum viable product mainly from the product design and development body of the knowledge. However, these approaches offer generic practices for a wide variety of solutions. This study presents an original proposal that provides a vertical solution for the conception of a minimum viable multimedia system, with a practice expressed in the graphic notation language of Essence. The study presents a contribution through a case study related to the clarity about the flow of activities, techniques, and specific tools that the practitioners must use to define a minimum viable multimedia system. This work also contributes to the criteria unification of the teamwork to carry out the follow-up of the progress in realizing the activities necessary to complete the job needed for the conception of the minimum viable multimedia system, using an MS-value sub-alpha.

A Service Level Agreement (SLA) regulates the provisioning of a service by defining a set of guarantees. Each guarantee sets a Service Level Objective (SLO) on some service metrics, and optionally a compensation that is applied when the SLO is unfulfilled or overfulfilled. Currently, there are software tools and research proposals that use the information about compensations to automate and optimise certain parts of the service management. However, they assume that compensations are well defined, which is too optimistic in some circumstances and can lead to undesirable situations. In this article we discuss about the notion of validity of guarantees with a compensation, which we refer to as compensable guarantees (CG). We describe an abstract model of CGs and we provide a technique that leverages constraint satisfaction problem solvers to automatically validate them. We also present a materialisation of the model of CGs in iAgree, a language to specify SLAs and a tooling support that implements our whole approach. An assessment over 319 CGs taken from 24 real-world SLAs suggests that the expressiveness and effectiveness of our proposal can pave the way for using CGs in a safer and more reliable way.

Необхідний рівень безпеки машин і механізмів досягається за рахунок використання відповідних систем управління безпекою промислового обладнання, в тому числі програмованих електронних. Такі системи зазвичай включають в себе різноманітні охоронні пристрої для управління налаштуваннями промислового обладнання. Оскільки електронні системи управління в даний час вважаються найбільш перспективними системами управління в цій області, вивчення параметрів безпеки їх прикладної підтримки визначає актуальність даного дослідження. У цьому дослідженні проаналізовано основні вимоги стандартів IEC 61508 та IEC 62061 на відповідність сучасним вимогам безпеки вбудованого та прикладного програмного забезпечення для електронних систем управління машинами та механізмами. Дане дослідження пропонує алгоритм покрокового впровадження програмного забезпечення для електронних систем управління машинами відповідно до базових стандартів безпеки як для вбудованого, так і прикладного програмного забезпечення. Тестування визначено як основний метод перевірки прикладного програмного забезпечення. За результатами аналізу було встановлено, що специфікація вимог безпеки, як вбудованого, так і прикладного програмного забезпечення, повинна висвітлювати необхідні характеристики кожної підсистеми, надаючи інформацію, що дозволяє вибрати обладнання, що відповідає існуючим вимогам безпеки. Наводяться відповідні рекомендації щодо специфіки практичного застосування цих стандартів. The required level of safety of machines and mechanisms is achieved through the use of appropriate safety management systems for industrial equipment, including programmable electronic ones. Such systems usually include a variety of security devices for managing industrial equipment settings. Since electronic control systems are currently considered the most promising control systems in this area, the study of the security parameters of their application support determines the relevance of this study. This study analyses the main requirements of IEC 61508 and IEC 62061 standards for compliance with modern safety requirements of embedded and applied software for electronic control systems of machines and mechanisms. This study proposes an algorithm for step-by-step implementation of software for electronic machine control systems in accordance with basic security standards for both built-in and application software. Testing has been determined as the main method of verification of application software. Based on the results of the analysis, it was found that the specification of security requirements, both built-in and application software, should highlight the necessary characteristics of each subsystem, providing information that allows choosing the equipment that meets existing security requirements. Relevant recommendations are given on the specifics of practical application of these standards.

Context: Multiple types of processing units (e.g., CPUs, GPUs and FPGAs) can be used jointly to achieve better performance in computational systems. However, these units are built with fundamentally different characteristics and demand attention especially towards software deployment. Objective: The goal of this work is to summarize the state-of-the-art of software deployment on heterogeneous platforms. We provide an overview of the research area by searching for and categorizing relevant studies, as well as discussing gaps and trends of the field. We are interested in the main concerns (RQ1) and the approaches used (RQ2) when deploying software on heterogeneous platforms. Method: In order to achieve our goal, we performed a systematic mapping study, which refers to a method for reviewing literature with basis on predefined search strategies and a multi-step selection process. Results: We selected and analyzed 146 primary studies from multiple sources and found that the area of research is dominated by solution proposals. The majority of the studies discuss concerns about scheduling, the quality of the software, and its architecture. A large number of studies focuses on the problem of scheduling tasks and processes. We found approaches that are applied at different binding times (i.e., design time, runtime, orthogonal). Conclusion: The evaluation of the proposed solutions in an industrial context is missing. Also, the proposed methods have not been evaluated in development processes. Most of the methods address a particular concern, or a few concerns, while there is a lack of a holistic approach.

The rapid adoption and the diversification of cloud computing technology exacerbate the importance of a sound experimental methodology for this domain. This work investigates how to measure and report performance in the cloud, and how well the cloud research community is already doing it. We propose a set of eight important methodological principles that combine best-practices from nearby fields with concepts applicable only to clouds, and with new ideas about the time-accuracy trade-off. We show how these principles are applicable using a practical use-case experiment. To this end, we analyze the ability of the newly released SPEC Cloud IaaS benchmark to follow the principles, and showcase real-world experimental studies in common cloud environments that meet the principles. Last, we report on a systematic literature review including top conferences and journals in the field, from 2012 to 2017, analyzing if the practice of reporting cloud performance measurements follows the proposed eight principles. Worryingly, this systematic survey and the subsequent two-round human reviews, reveal that few of the published studies follow the eight experimental principles. We conclude that, although these important principles are simple and basic, the cloud community is yet to adopt them broadly to deliver sound measurement of cloud environments.

Automation system engineering becomes more complex, due to the trend toward more flexible, reconfigurable, and modular design approaches, like Industry 4.0. For the modeling and design of the according software, two standards are present: IEC 61131-3 and IEC 61499. In order to satisfy the requirements for modern, large scale, highly distributed applications while also supporting still existing legacy systems, the demand for a combined development framework arises, where the best of breed tool can be chosen for a given automation task. Considering that, the IEC 61499 model is extended to allow the dual development and execution of IEC 61131-3 programs, and enabling easy and correct interaction between the two paradigms. In order to verify the validity of the chosen approach, an IEC 61499 development tool and a runtime environment is modified to support IEC 61131-3. A sample application is implemented, which comprises a pure IEC 61131-3 part with a 1 ms cycle time, a pure IEC 61499 part, and a part with interaction between both subparts, in order to evaluate possible interference between the runtime parts. Experimental results show that no interference is occurring, and the chosen development approach allows the seamless integration of IEC 61131-3 and IEC 61499 in one combined development framework.

PurposeNew Zealand building code may be serving its purpose to an extent, there is still a need to develop a framework to improve the use and application of building code for better building performance and services. This study aims to validate the identified parameters in the developed framework to improve building code practice in New Zealand.Design/methodology/approachSubject matter experts interview was conducted with key stakeholders that use building code, standards and other associated compliance documents.FindingsThe findings from this study establish the importance of improving the building code, and the efficacy of validated framework helps to identify the areas with the most pressing needs within the building regulatory system. All the subject matter experts unanimously agreed on educating and training the building code users. Besides, the validated framework will enable the policy decision-makers in the building regulatory system to promote the use of building code and the utilisation of its potentials in reducing disaster while increasing the built environment resilience. The study concludes that the designed framework will create more robust strategy implementations to enhance innovative solutions embedded in performance-based building code.Originality/valueThis study originality centres on the practical application of an evidence-based framework for performance-based building code, standards and other related compliance documents.

A future-state architectural strategy designed to support chatbot integration with service delivery systems.

A panoramic view of a popular platform for C program analysis and verification.

Software architectural designs are usually changed over time to support emerging technologies and to adhere to new principles. Architectural migration is an important activity that helps to transform the architectural styles applied during a system’s design with the result of modernising the system. If not performed correctly, this process could lead to potential system failures. This article presents an automated approach to refactoring architectural design and to planning the evolution process. With our solution, the architectural design can be refactored, ensuring that system functionality is preserved. Furthermore, the architectural migration process allows the system to be safely and incrementally transformed. We have evaluated our approach with five real-world software applications. The results prove the effectiveness of our approach and identify factors that impact the performance of architectural verification and migration planning. An interesting finding is that planning algorithms generate migration plans that differ in term of their relative efficiency.

This paper presents a prototype of a centralized contactless traffic violation apprehension system composed of an artificial intelligence (AI) engine and a web application. The AI engine collects traffic data, primarily traffic violation data, through a contactless approach by using different video and image processing techniques and AI algorithms in its three modules: license plate detection, optical character recognition (OCR), and number coding violation detection. The web application consolidates all the data produced by the AI engine and provides a graphical user interface (GUI) for data management, visualization, and analysis. This contactless apprehension system aims to automate, standardize, and streamline the existing processes of law enforcement agencies and institutions for a more efficient apprehension of traffic violators and help them improve their traffic planning and management in the congested areas of the Philippines.

The discipline of reverse engineering integrated circuits (ICs) is as old as the technology itself. It grew out of the need to analyze competitor’s products and detect possible IP infringements. In recent years, the growing hardware Trojan threat motivated a fresh research interest in the topic. The process of IC reverse engineering comprises two steps: netlist extraction and specification discovery. While the process of netlist extraction is rather well understood and established techniques exist throughout the industry, specification discovery still presents researchers with a plurality of open questions. It therefore remains of particular interest to the scientific community. In this paper, we present a survey of the state of the art in IC reverse engineering while focusing on the specification discovery phase. Furthermore, we list noteworthy existing works on methods and algorithms in the area and discuss open challenges as well as unanswered questions. Therefore, we observe that the state of research on algorithmic methods for specification discovery suffers from the lack of a uniform evaluation approach. We point out the urgent need to develop common research infrastructure, benchmarks, and evaluation metrics.

Financiado para publicación en acceso aberto: Universidade da Coruña/CISUG [Abstract] Even though different applications based on Geographic Information Systems (GIS) provide different features and functions, they all share a set of common concepts (e.g., spatial data types, operations, services), a common architecture, and a common set of technologies. Furthermore, common structures appear repeatedly in different GIS, although they have to be specialized in specific application domains. Multilevel modeling is an approach to model-driven engineering (MDE) in which the number of metamodel levels is not fixed. This approach aims at solving the limitations of a two-level metamodeling approach, which forces the designer to include all the metamodel elements at the same level. In this paper, we address the application of multilevel modeling to the domain of GIS, and we evaluate its potential benefits. Although we do not present a complete set of models, we present four representative scenarios supported by example models. One of them is based on the standards defined by ISO TC/211 and the Open Geospatial Consortium. The other three are based on the EU INSPIRE Directive (territory administration, spatial networks, and facility management). These scenarios show that multilevel modeling can provide more benefits to GIS modeling than a two-level metamodeling approach. Xunta de Galicia; IN852A 2018/14 Xunta de Galicia; ED431G 2019/01 This work has been partially funded by grants: MICIU/FEDER-UE, MAGIST: PID2019-105221RB-C41; MICIU/FEDER-UEBIZDEVOPSGLOBAL: RTI-2018-098309-B-C32, Xunta de Galicia/FEDER-UE, ConectaPeme, GEMA: IN852A 2018/14; MINECOAEI/FEDER-UE Datos 4.0: TIN2016-78011-C4-1-R; MINECOAEI/FEDER-UE Velocity: TIN2016-77158-C4-3-R; CITIC research center funded by XUNTA and EU through the European Regional Development Fund- Galicia 2014-2020 Program, grant ED431G 2019/01. Funding for open access charge: Universidade da Coruña/CISUG.