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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

Business process compliance ensures that the processes of an organisation are designed and executed according to the rules that govern it. We faced the challenge of building a compliance management system for a process-aware organisation and identified several needs that, despite having been identified in the literature, were only partially satisfied by existing approaches. The variability in the types of rules generally restricts the existing support for compliance checking to specific types of rules, a concrete phase of the business process management lifecycle, or certain information systems (ISs) for data retrieval. Motivated by this, we designed a conceptual framework for compliance checking that relies on the use of mashups for rule specification and checking, with the following advantages: (i) an open-ended set of rules can be specified by designing and connecting mashup components; (ii) (parts of) the definitions of the rules can be reused as needed; and (iii) the mashup-based compliance checking system can be integrated with ISs of the organisation, enabling the verification of actual facts on actions performed during the execution of a process (e.g., the existence of a document in a location). Design-time and run-time implementations of the framework were conducted and tested in a real setting.

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.

Due to the conflicting nature of quality measures, there are always multiple refactoring options to fix quality issues. Thus, interaction with developers is critical to inject their preferences. While several interactive techniques have been proposed, developers still need to examine large numbers of possible refactorings, which makes the interaction time-consuming. Furthermore, existing interactive tools are limited to the "objective space" to show developers the impacts of refactorings on quality attributes. However, the "decision space" is also important since developers may want to focus on specific code locations. In this paper, we propose an interactive approach that enables developers to pinpoint their preference simultaneously in the objective (quality metrics) and decision (code location) spaces. Developers may be interested in looking at refactoring strategies that can improve a specific quality attribute, such as extendibility (objective space), but they are related to different code locations (decision space). A plethora of solutions is generated at first using multi-objective search that tries to find the possible trade-offs between quality objectives. Then, an unsupervised learning algorithm clusters the trade-off solutions based on their quality metrics, and another clustering algorithm is applied to each cluster of the objective space to identify solutions related to different code locations. The objective and decision spaces can now be explored more efficiently by the developer, who can give feedback on a smaller number of solutions. This feedback is then used to generate constraints for the optimization process, to focus on the developer's regions of interest in both the decision and objective spaces. The manual validation of selected refactoring solutions by developers confirms that our approach outperforms state of the art refactoring techniques.

The development and evaluation of Mission Engineering Threads (METs) require an understanding of the operational context for which a system-of-systems (SoS) will be employed as well as an assessment that the performance of a complex SoS is effective and safe. The information describing the design and performance parameters of the systems within the SoS is distributed in many different physical locations, and is represented in a variety of formats, both structured and unstructured. Because of this dynamic on the structuring of the data to include differing ontology frameworks, it is necessary to develop a framework and toolset to handle the automated extraction of information from disparate information sources. In addition, this extracted information needs to be categorized properly into defined data types as represented in the specific MET to correctly capture the appropriate context of the mission scenario. Semantic technique solutions will be researched, analysed, and applied as a means to infer new facts from existing facts and data. These techniques are particularly powerful when the amount of data and/or the relationships and constraints among data are too cumbersome and complex for human understanding and reasoning. Using the characteristics of wine as an example, we present our framework to show how it enables rapid and contextually relevant extraction, and represents complex information in a user-friendly format.

With today's rapidly-evolving cloud landscape embracing continuous integration and delivery, users of cloud systems must monitor software running on their containers and virtual machines (VMs) to ensure compliance, security, and efficiency. Traditional solutions to this problem rely on manually-created rules that identify software installations and modifications, but these require expert authors and are often unmaintainable. Recently, automated techniques for software discovery have emerged. Some techniques use examples of software to train machine learning models to predict which software has been installed on a system. Others leverage knowledge of packaging practices to aid in discovery without requiring any pre-training, but these practice-based methods cannot provide precise-enough information to perform discovery by themselves. This paper introduces Praxi, a new software discovery method that builds upon the strengths of prior approaches by combining the accuracy of learning-based methods with the efficiency of practice-based methods. In tests using samples collected on real-world cloud systems, Praxi correctly classifies installations at least 97.6% of the time, while running 14.8 times faster and using 87% less disk space than a similar learning-based method. Using a diverse software dataset, this paper quantitatively compares Praxi to systematic rule-, learning-, and practice-based methods, and discusses the best uses for each.

The emergence of Virtual Prototypes (VPs) at the Electronic System Level (ESL) has played a major role in modernizing the System-on-Chips (SoCs) design process to raise design productivity and reduce time-to-market. A VP is an abstract and executable software model implemented typically using SystemC and its Transaction Level Modeling (TLM) framework. However, this modern VP-based design process still has weaknesses, in particular, due to the significant manual effort involved for design understanding, analysis and modeling tasks which is both time consuming and error-prone. This paper introduces an automated and fast design understanding approach that enables designers to trace detailed information of the VPs’ structure and behavior. Experimental results including a real-world VP-based SoC show the advantages of our approach such as its accuracy, applicability, and scalability.

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.

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.

The potential benefits of autonomous systems are obvious. However, there are still major issues to be dealt with before developing such systems becomes a commonplace engineering practice, with accepted and trustworthy deliverables. We argue that a solid, evolving, publicly available, community-controlled foundation for developing next-generation autonomous systems is a must, and term the desired foundation Autonomics. We focus on three main challenges: (i) how to specify autonomous system behavior in the face of unpredictability; (ii) how to carry out faithful analysis of system behavior with respect to rich environments that include humans, physical artifacts, and other systems; and (iii) how to build such systems by combining executable modeling techniques from software engineering with artificial intelligence and machine learning.

Service activities carried out by the Academic and Student Administration Bureau (BAAK) STMIK Widuri for students who will carry out field placement program (KKP) are currently still carried out conventionally, this makes the process of making KKP cover letters and also assignments for supervisors takes time, which is quite long and less efficient. To overcome these problems, it is necessary to create a web-based application system that can simplify and speed up the activities of student KKP administration services. In this study, observations were made on the current system modeled using Business Process Modeling Notation (BPMN) and Data Flow Diagrams (DFD). The problem analysis process uses the Root Cause Analysis (RCA) method. The system design runs with UML diagrams, namely Use Case, Activity and Deployment Diagrams. Making a prototype with a high fidelity concept using the PHP programming language, HTML 5, CSS, jQuery, Bootstrap and DataTables frameworks and the Chart.js library. This research resulted in a prototype that describes the overall functionality of the Online MPA system, interactive and has an attractive interface.

The Academic Administration division (BAA) plays a role in the process of issuing student certificates at the National University. Although the data has been computerized, the process of issuing the letter is still manual so it is less effective and efficient. Students must come to the BAA unit to apply for the issuance of a student certificate, including for data correction purposes if needed. This will require more effort for students in terms of time, energy and material. This research is to design a Web-Based Student Certificate Making System that can simplify the service process and submission of a certificate for students at the National University. This system is integrated and responsive and is accessed online. The application was developed with the waterfall model and utilizes the Unified Modeling Language (UML) tool and uses the PHP programming language. The result of this study is the existence of a web-based certificate application design that can facilitate students in obtaining student certificates at the National University. The results of testing the application using the white-box and black-box methods, indicate that the logic and functionality of the application is running well and can be used by the BAA unit of the National University.

Computers have become a huge requirement to support human performance. Computers also often experience Hardware damage such as processors, VGA, motherboards, memory, mouse, keyboards, hard disks, optical drives, monitors. Until now, many computer users still do not have sufficient knowledge of the initial diagnosis of computer Hardware damage which causes a lot of computer users to pay a lot of money to find out and repair the damage that occurs to Computer Hardware. In this Expert System application research development, the authors use a combination of two inference methods, namely the Forward Chaining method and the Certainty Factor Method. The programming tools used in the development of this Expert System application is using the Sublime Text 3 application while the database uses MySQL with PHP as the programming language. The purpose of this Expert System application is made to assist computer users in making an initial diagnosis of a damaged computer Hardware along with the causes and solutions to overcome the damage.

In response to the increasing calls for algorithmic accountability, UML2PROV is a novel approach to address the existing gap between application design, where models are described by UML diagrams, and provenance design, where generated provenance is meant to describe an application’s flows of data, processes and responsibility, enabling greater accountability of this application. The originality of UML2PROV is that designers are allowed to follow their preferred software engineering methodology to create the UML Diagrams for their application, while UML2PROV takes the UML diagrams as a starting point to automatically generate: (1) the design of the provenance to be generated (expressed as PROV templates); and (2) the software library for collecting runtime values of interest (encoded as variable-value associations known as bindings), which can be deployed in the application without developer intervention. At runtime, the PROV templates combined with the bindings are used to generate high-quality provenance suitable for subsequent consumption. UML2PROV is rigorously defined by an extensive set of 17 patterns mapping UML diagrams to provenance templates, and is accompanied by a reference implementation based on Model Driven Development techniques. A systematic evaluation of UML2PROV uses quantitative data and qualitative arguments to show the benefits and trade-offs of applying UML2PROV for software engineers seeking to make applications provenance-aware. In particular, as the UML design drives both the design and capture of provenance, we discuss how the levels of detail in UML designs affect aspects such as provenance design generation, application instrumentation, provenance capability maintenance, storage and run-time overhead, and quality of the generated provenance. Some key lessons are learned such as: starting from a non-tailored UML design leads to the capture of more provenance than required to satisfy provenance requirements and therefore, increases the overhead unnecessarily; alternatively, if the UML design is tailored to focus on addressing provenance requirements, only relevant provenance gets to be collected, resulting in lower overheads.

This article introduces a unified and flexible experimental framework for massive online experimentation of control education. The new architecture adopts a front-end and back-end separation scheme based on React at frontend and Nginx at backend, and a single page application has been achieved to improve user experience. Multiple features and supporting technologies which provide a flexible, interactive, and real-time platform with enhanced sense of presence and user experience are discussed. The design and implementation of the proposed system are depicted in detail. With the implementation of online algorithm design, the unified framework enables all the functionalities such as web-based algorithm design, parameter tuning, visual configuration of customized user interface, and real-time control with remote and virtual laboratories, which cover the entire process in control education experimentation. A case study with students from two universities shows that the implemented online laboratory framework can support massive students with minimum maintenance required.

The combination of diverse data types and analysis tasks in genomics has resulted in the development of a wide range of visualization techniques and tools. However, most existing tools are tailored to a specific problem or data type and offer limited customization, making it challenging to optimize visualizations for new analysis tasks or datasets. To address this challenge, we designed Gosling—a grammar for interactive and scalable genomics data visualization. Gosling balances expressiveness for comprehensive multi-scale genomics data visualizations with accessibility for domain scientists. Our accompanying JavaScript toolkit called Gosling.js provides scalable and interactive rendering. Gosling.js is built on top of an existing platform for web-based genomics data visualization to further simplify the visualization of common genomics data formats. We demonstrate the expressiveness of the grammar through a variety of real-world examples. Furthermore, we show how Gosling supports the design of novel genomics visualizations. An online editor and examples of Gosling.js, its source code, and documentation are available at https://gosling.js.org.

Ontology verification refers to the activity where an ontology is tested against its ontology requirements to ensure that it is built correctly in compliance with its ontology requirements specification. Therefore, it is an important activity that should be performed in any ontology development process. Since manual verification can be a time-consuming and repetitive task, testing processes to automatically verify an ontology facilitate this activity. Moreover, the involvement of not only ontology engineers during the ontology verification process , but also domain experts and users, can provide valuable feedback to avoid misunderstandings and lack of information. This paper proposes a method for ontology verification that defines the testing activities to be performed. The method uses a testing language based on lexico-syntactic patterns to facilitate the definition of tests and an ontology to store and publish such tests. Moreover, this verification testing method proposes an online tool to execute tests on one or more ontologies. The method was compared in terms of time and errors by user evaluation with other tools for ontology verification; the evaluation showed that the tools that use testing languages had better results in terms of reducing errors in the verification activity compared to the tools that do not.

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.

Made available in DSpace on 2022-05-01T07:59:06Z (GMT). No. of bitstreams: 0 Previous issue date: 2021-12-01 The fourth industrial revolution aims to achieve greater productivity, also seeking to improve the quality and efficiency of production processes. For this, the use of information and automation technologies together becomes indispensable. Collaborative automation through the sharing and use of services has been a recent paradigm in the quest to obtain a distributed, flexible and integrated on network architecture. In this article, the development of control and automation applications as a service using a Microservices Oriented Architecture is investigated. The architecture is elaborated using the Moleculer framework, which simplifies the development of microservices and applications that make up the Microservice Oriented Architecture used in this work. The development and evaluation of several services are presented, such as Data Acquisition (DAQ), Programmable Logic Controller (PLC) and PID Controller (PIDPlus). The experimental results in different scenarios demonstrated the feasibility of implementing control and automation applications as a service. A relevant advantage that this type of architecture provides is interoperability through automatic network communication between applications and microservices, which is required for Industry 4.0. Sao Paulo State University (UNESP) National Service for Industrial Learning (SENAI) Federal Institute of Sao Paulo (IFSP) Sao Paulo State University (UNESP)

Electronic waste generated from Information and Communication Technologies (ICT) has become a global issue as this represents a negative impact on both environment and human health. Consequently, it is noticeably useful to develop tools to soften such impact. Therefore, this article presents a rules-based system implemented in Prolog aiming at guiding ICT devices users towards good practices on electronic waste management to diminish the negative impact. The methodologies employed include exploratory, descriptive, and experimental. Even though the system developed in Prolog was found to be deficient with user interface, it is also functional and efficient, including features like usability and maintainability. In conclusion, it was found that waste recollection systems may be useful for both environmental management processes in different countries and also positive business opportunities.

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.

This paper discusses an implementation of a declarative style of programming for sensor-based applications, involving the acquisition and aggregation of context. We describe an implementation of LogicCAP integrating Prolog with the ContextToolkit, and its on-going extensions, considering applications in the mobile environment, distributed evaluation, and dynamic sensor binding issues. We also propose LogicCAP as a declarative language for context (and sensor) mashups with the situation as the aggregating abstraction.

Testing is more than simply demonstrating a program is correct. We must constantly challenge ourselves to make ourselves better. Likewise, we must also challenge our programs and our ideas. Testing is how we bring science into our craft and replace guesses and myths with real knowledge about how the world works. Building good tests can take a lot of time and effort, and Oracle databases present unique challenges for building reproducible test cases. Luckily, Oracle provides many tools to help us test, such as SQL, PL/SQL, the data dictionary, dynamic performance views, and much more.

Software implements a significant proportion of functionality in factory automation. Thus, efficient development and the reuse of software parts, so-called units, enhance competitiveness. Thereby, complex control software units are more difficult to understand, leading to increased development, testing and maintenance costs. However, measuring complexity is challenging due to many different, subjective views on the topic. This paper compares different complexity definitions from literature and considers with a qualitative questionnaire study the complexity perception of domain experts, who confirm the importance of objective measures to compare complexity. The paper proposes a set of metrics that measure various classes of software complexity to identify the most complex software units as a prerequisite for refactoring. The metrics include complexity caused by size, data structure, control flow, information flow and lexical structure. Unlike most literature approaches, the metrics are compliant with graphical and textual languages from the IEC 61131-3 standard. Further, a concept for interpreting the metric results is presented. A comprehensive evaluation with industrial software from two German plant manufacturers validates the metrics' suitability to measure complexity., 8 pages, https://ieeexplore.ieee.org/abstract/document/9444196/

Building information modelling (BIM) represents a workflow whose application on a construction project will enable all involved players to compile as well as work with information on every aspect of a building in a common model/database. Through BIM, the entire building can be virtually designed and built on a computer. BIM touches every part of a building’s life cycle starting from the design phase well into the construction phase and beyond that into asset management. This research examines the experiences of early adopters of BIM and use that insight to introduce BIM, specially focusing on the structural analysis and design stage of a building. The study demonstrates how all structural design activities can be integrated with each other and how cross-discipline collaboration with the architect can be achieved through the adoption of BIM without leaving ones customary structural design platform. As a demonstration, a sample building is modelled using Revit along with conventional structural software packages ETABS and SAFE. Plugins and applications were developed for these software packages to facilitate interoperability amongst them so that they all act together as a single platform. Modelling, analysis, design and clash detections were facilitated by applying BIM. Major benefits of employing BIM in a structural design project are illustrated through this research.

Messaging Software systems (MSS) are one of the most popular tools used by huge amount of people. They could be used for personal communication and for business purposes. Building an own MSS system requires analysis of the quality attributes and considering adaptation to the changing environment. In this paper an overview of existing MSS architecture was done. Data model was developed to support historical and real time data storage and processing. An own approach to build Adaptive Microservice MSS based on the messaging middleware and NoSQL database was proposed.

In this article, we address how the production of model transformations (MT) can be accelerated by automation of transformation synthesis from requirements, examples, and metamodels. We introduce a synthesis process based on metamodel matching, correspondence patterns between metamodels, and completeness and consistency analysis of matches. We describe how the limitations of metamodel matching can be addressed by combining matching with automated requirements analysis and model transformation by example (MTBE) techniques. We show that in practical examples a large percentage of required transformation functionality can usually be constructed automatically, thus potentially reducing development effort. We also evaluate the efficiency of synthesised transformations. Our novel contributions are: The concept of correspondence patterns between metamodels of a transformation. Requirements analysis of transformations using natural language processing (NLP) and machine learning (ML). Symbolic MTBE using “predictive specification” to infer transformations from examples. Transformation generation in multiple MT languages and in Java, from an abstract intermediate language.