Search

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

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

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

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

Robots artificially replicate human capabilities thanks to their software, the main embodiment of intelligence. However, engineering robotics software has become increasingly challenging. Developers need expertise from different disciplines as well as they are faced with heterogeneous hardware and uncertain operating environments. To this end, the software needs to be variable—to customize robots for different customers, hardware, and operating environments. However, variability adds substantial complexity and needs to be managed—yet, ad hoc practices prevail in the robotics domain, challenging effective software reuse, maintenance, and evolution. To improve the situation, we need to enhance our empirical understanding of variability in robotics. We present a multiple-case study on software variability in the vibrant and challenging domain of service robotics. We investigated drivers, practices, methods, and challenges of variability from industrial companies building service robots. We analyzed the state-of-the-practice and the state-of-the-art—the former via an experience report and eleven interviews with two service robotics companies; the latter via a systematic literature review. We triangulated from these sources, reporting observations with actionable recommendations for researchers, tool providers, and practitioners. We formulated hypotheses trying to explain our observations, and also compared the state-of-the-art from the literature with the-state-of-the-practice we observed in our cases. We learned that the level of abstraction in robotics software needs to be raised for simplifying variability management and software integration, while keeping a sufficient level of customization to boost efficiency and effectiveness in their robots’ operation. Planning and realizing variability for specific requirements and implementing robust abstractions permit robotic applications to operate robustly in dynamic environments, which are often only partially known and controllable. With this aim, our companies use a number of mechanisms, some of them based on formalisms used to specify robotic behavior, such as finite-state machines and behavior trees. To foster software reuse, the service robotics domain will greatly benefit from having software components—completely decoupled from hardware—with harmonized and standardized interfaces, and organized in an ecosystem shared among various companies.

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

We present a Research Software Engineering (RSE) workflow for developing research software in Computational Science and Engineering (CSE) in university research groups. Their members have backgrounds from different scientific disciplines and often no education in RSE. Research software development lasts many years, contrary to team members leaving regularly. Combining and re-using ideas and results from others is a fundamental principle of science. In CSE research software embodies research ideas. As CSE research advances, research software should grow sustainably over the years. To increase the sustainability of research software, our workflow simplifies the investigation and integration of research ideas, ensures reproducibility and new functionality does not impair existing one. These practices speed up research and increase the quality of scientific output. Our CSE-RSE workflow is simple, effective and largely ensures the FAIR principles.The workflow uses established practices and tools, pragmatically adapted for CSE research software: version-control, secondary-data standards, continuous integration and containerization., {"references":["https://knowledge-base.nfdi4ing.de/"]}

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.

The software industry has made significant efforts in recent years to enhance software quality in businesses. The use of proactively defect prediction in the software will assist programmers and white box testing in detecting issues early, saving time and money. Conventional software defect prediction methods focus on traditional source code metrics such as code complexities, lines of code, and so on. These capabilities, unfortunately, are unable to retrieve the semantics of source code. In this paper, we have presented a novel Correlation Clustering fine-tuned CNN (CCFT-CNN) model based on testing Metrics. CCFT-CNN can predict the regions of source code that contain faults, errors, and bugs. Abstract Syntax Tree (AST) tokens are extracted as testing Metrics vectors from the source code. The correlation among AST testing Metrics is performed and clustered as a more relevant feature vector and fed into Convolutional Neural Network (CNN). Then, to enhance the accuracy of defect prediction, fine-tuning of the CNN model is performed by applying hyperparameters. The result analysis is performed on the PROMISE dataset that contains samples of open-source Java applications such as Camel Dataset, Jedit dataset, Poi dataset, Synapse dataset, Xerces dataset, and Xalan dataset. The result findings show that the CCFT- CNN model increases the average F-measure by 2% when compared to the baseline model.

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

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

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

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

Requirements Engineering is one of the fundamental activities in the software development process and is oriented toward what should be produced. One of the development team’s most common problems is a lack of communication regarding an understanding of the discourse domain and how to integrate and process excessive information originating from different sources. This may lead to errors of omission and the consequent production of incomplete and inconsistent artifacts, which will have a direct effect on the quality of the software. The use of machine learning techniques helps the development team produce successful software on the basis of the acquisition of knowledge and human experience with which to understand the domain of the application. This paper, therefore, presents a proposal for a new methodological process oriented toward the construction of a vocabulary concerning the application domain. The authors propose to do this by employing Natural Language Processing (NLP), ontologies and heuristics that will lead to the production of a Lexicon that is common to analysts and customers, both of whom will understand the universe of discourse, thus mitigating problems of completeness. This objective has been achieved by carrying out a Systematic Literature Review of the artificial intelligence techniques employed in the requirements engineering process, which led to the discovery that 41.37% use NLP, while 55.71% apply ontologies such as semantic reasoners which help solve the problem of language ambiguity, the structures in specifications or the identification of key concepts with which to establish traceability links. However, the review also showed that the problems regarding the comprehension and completeness of requirements problems have yet to be resolved.

Altering handwritten documents is receiving special attention from researchers because it is useful in several sensitive crime applications such as the identification of suicide notes, fraudulent certificates, fake answer scripts, bank and property documents etc. This paper aims at developing a robust method for detecting altered text in handwritten document images in noisy and blurry environments. This study considers ten classes of handwritten text affected by multiple forgery operations with noise and blur as follows: (i) Normal-original text, (ii) Copy-paste forgery, (iii) Insertion forgery, (iv) Copy-paste and insertion forgery, (v) Noisy text, (vi) Blurred text, (vii) Copy-paste forgery with noise, (viii) Copy-paste forgery with blur, (ix) Insertion forgery with noise and (x) Insertion with blur. For ten-class classification, the proposed work explores the combination of statistical, gradient and texture features with a Bayesian classifier. The proposed approach works based on the premise that altered content in noisy and blurry handwritten documents exhibits inconsistent patterns of pixel arrangements while the original text exhibits a regular pattern of pixel arrangements. Comprehensive experiments on our dataset of 10-class and three standard datasets, namely, a dataset of forged handwritten text, a dataset of altered receipt images, and a dataset of forged IMEI number images are conducted to show effectiveness and robustness of the proposed approach compared to the state-of-the-art methods.

Configuration errors are some of the main reasons for software failures. Some configuration options may even negatively impact the software’s security, so that if a user sets the options inappropriately, there may be a huge security risk for the software. Recent studies have proposed mapping option read points to configuration options as the first step in alleviating the occurrence of configuration errors. Sadly, most available techniques use humans, and the rest require additional input, like an operation manual. Unfortunately, not all software is standardized and friendly. We propose a technique based on program and static analysis that can automatically map all the configuration options of a program just by reading the source code. Our evaluation shows that this technique achieves 88.6%, 97.7%, 94.6%, 94.8%, and 92.6% success rates with the Hadoop modules Common, Hadoop distributed file system, MapReduce, and YARN, and also PX4, when extracting configuration options. We found 53 configuration options in PX4 that were not documented and submitted these to the developers. Compared with published work, our technique is more effective in mapping options, and it may lay the foundation for subsequent research on software configuration security. Validerad;2023;Nivå 2;2023-04-20 (joosat);Funder: National Key R&D Program of China (grant no. 2020YFB100560); National Natural Science Foundation of China (grant no. U21A20463); Fundamental Research Funds for the Central Universities of China (grant no, KKJB320001536)Licens fulltext: CC BY License

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

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

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

Security requirements Engineering (SRE) is an activity conducted during the early stage of the SDLC. SRE involves eliciting, analyzing, and documenting security requirements. Thorough SRE can help software engineers incorporate countermeasures against malicious attacks into the software’s source code itself. Even though all security requirements are considered relevant, implementing all security mechanisms that protect against every possible threat is not feasible. Security requirements must compete not only with time and budget, but also with the constraints they inflect on a software’s availability, features, and functionalities. Thus, the process of security requirements prioritization becomes an integral task in the discipline of risk-analysis and trade-off-analysis. A sound prioritization technique provides guidance for software engineers to make educated decisions on which security requirements are of topmost importance. Even though previous research has proposed various security requirement prioritization techniques, none of the existing research efforts have provided a detailed survey and comparative analysis of existing techniques. This paper uses a literature survey approach to first define security requirements engineering. Next, we identify the state-of-the-art techniques that can be adopted to impose a well-established prioritization criterion for security requirements. Our survey identified, summarized, and compared seven (7) security requirements prioritization approaches proposed in the literature.

International audience; The Internet of Things (IoT) aims for connecting Anything, Anywhere, Anytime (AAA). This assumption brings about several software engineering challenges that constitute a serious obstacle to its wider adoption. The main feature of the Internet of Things (IoT) is genericity w.r.t the variability of software and hardware technologies. Model-Driven Engineering (MDE) is a paradigm that advocates using models to address software engineering problems. It can help to meet the genericity of the IoT from a software engineering perspective. Existing MDE approaches for the IoT focus only on modeling the internal behavior of things but lack a comprehensive approach dedicated to network modeling. In the present paper, we introduce a network-oriented methodology based on MDE to unify the IoT's heterogeneous concepts. Fundamentally, we avoid the intrinsic heterogeneity of the IoT by separating the network's specification (i.e., the things, the communication scheme, and its constraints) from its concrete implementation (i.e., the low-level artifacts such as source code and documentation). Technically, the methodology relies on a model-based Domain-Specific Language (DSL) and a code generator. The former enables the modeling of the network's specification, and the latter provides a procedure to generate the low-level artifacts from this specification. Our results show that this methodology makes IoT's software engineering more rigorous, helps prevent bugs earlier, and saves time.

Handwritten image-based writer age estimation is a challenging task due to the various writing styles of different individuals, use of different scripts, varying alignment, etc. Unlike age estimation using face recognition in biometrics, handwriting-based age classification is reliable and inexpensive because of the plain backgrounds of documents. This paper presents a novel model for deriving the phase spectrum based on the Harmonic Wavelet Transform (HWT) for age classification on handwritten images from 11 to 65 years. This includes 11 classes with an interval of 5 years. In contrast to the Fourier transform, which provides a noisy phase spectrum due to loss of time variations, the proposed HWT-based phase spectrum retains time variations of phase and magnitude. As a result, the proposed HWT-based phase spectrum preserves vital information of changes in handwritten images. In order to extract such information, we propose new phase statistics-based features for age classification based on the understanding that as age changes, writing style also changes. The features and the input images are fed to a VGG-16 model for age classification. The proposed method is tested on our own dataset and three standard datasets, namely, IAM-2, KHATT and that of Basavaraja et al. to demonstrate the effectiveness of the proposed model compared to the existing methods in terms of classification rate. The results of the proposed and existing methods on different datasets show that the proposed method outperforms the existing methods in terms of classification rate.

Fine-Grained Visual Categorization (FGVC) aims to distinguish between extremely similar subordinate-level categories within the same basic-level category. Existing research has proven the great importance of the discriminative features in FGVC but ignored the contributions for correct classification from other features, and the extracted features always contain more information about the obvious regions but less about subtle regions. In this paper, firstly, a novel module named forcing module is proposed to force the network to extract more diverse features for FGVC, which generates a suppression mask based on the class activation maps to suppress the most distinguishable regions, so as to force the network to extract other secondary distinguishable features as the final features. The forcing module consists of the original branch and the forcing branch. The original branch focuses on the primary discriminative regions while the forcing branch focuses on secondary discriminative regions. Secondly, in order to solve the problem that information of small-scale distinguishable features is lost seriously after multi-layer down-sampling, according to the class activation maps of the first prediction, the object is cropped and scaled as the second input. To reduce the prediction error, the first and second prediction probabilities are fused as the final prediction result. Experimental results indicate that the proposed method not only outperforms the baseline model by a large margin (3.7%, 5.9%, 3.1% respectively) on CUB-200-2011, Stanford-Cars, and FGVC-Aircraft, but also achieves state-of-the-art performance on FGVC-Aircraft.

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

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

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

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

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

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

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

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

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

Застосування показників програмного коду дозволяє розробникам програмного забезпечення і керівникам проектів оцінювати різні функції програмного забезпечення, яке буде створено або вже існує, прогнозувати робоче навантаження, визначати складність і надійність програмного забезпечення і надавати кількісні характеристики якості розроблюваних програмних систем. У працях останніх років пропонуються різні методи вирішення цієї проблеми. Утім досі немає ефективного підходу до вимірювання складності програмного забезпечення. Подано стислий огляд існуючих метрик складності програмного забезпечення. Запропоновано новий гібридний метод обчислення складності програмного забезпечення, який об’єднує ключові характеристики метрик Холстеда, Маккабі і SLOC, а також дозволяє більш ефективно оцінювати складність. The use of code metrics allows software developers and project managers to evaluate various features of the software (to be built or already in existence), predict workload, determine software complexity and reliability, and quantify the quality of software systems being developed. Articles written in recent years have proposed various methods for solving this problem. However, there is still no very effective approach to measuring software complexity. This article provides a brief overview of existing software complexity metrics and proposes a new hybrid method for computing software complexity. The proposed hybrid method for evaluating software complexity combines the key features of the Halsted, Maccabe, and SLOC metrics and also allows for a more efficient assessment of complexity.

Big data analytics technologies are rapidly expanding across all industry sectors as organisations try to make analytics an integral part of their everyday decision-making. Although there are many software tools and libraries to assist analysts and software engineers in developing solutions, organisations are looking for flexible analytics platforms that can address their specific objectives and requirements. To minimise costs, such platforms also need to co-exist with existing IT infrastructures and reuse knowledge and resources already accumulated within the organisation. To address such needs, this paper proposes the Data Analytics Solution Engineering (DASE) framework—a knowledge-driven approach supported by semantic web technologies for requirements engineering, design and development of new data analytics platforms. It includes a meta-model that captures data analytics platform requirements via a Knowledge Base, a set of guidelines that organisations can follow in engineering data analytics platforms and a reference architecture that demonstrates how to use these guidelines. We evaluate the DASE framework through two case studies and demonstrate how it can facilitate knowledge-based and requirements-driven data analytics platform engineering. The resulting data analytics platforms are observed to be user friendly, easy to maintain and flexible in handling changes to requirements. This work contributes to the body of knowledge in knowledge-driven requirements engineering, and data analytics platform engineering by providing a meta-model and a reference architecture that can be tailored to different analytics application domains.

Exponential smoothing has been one of the most popular forecasting methods usedto support various decisions in organizations, in activities such as inventory man-agement, scheduling, revenue management, and other areas. Although its relativesimplicity and transparency have made it very attractive for research and practice,identifying the underlying trend remains challenging with significant impact on theresulting accuracy. This has resulted in the development of various modifications oftrend models, introducing a model selection problem. With the aim of addressingthis problem, we propose the complex exponential smoothing (CES), based on thetheory of functions of complex variables. The basic CES approach involves only twoparameters and does not require a model selection procedure. Despite these simpli-fications, CES proves to be competitive with, or even superior to existing methods.We show that CES has several advantages over conventional exponential smooth-ing models: it can model and forecast both stationary and non-stationary processes,and CES can capture both level and trend cases, as defined in the conventionalexponential smoothing classification. CES is evaluated on several forecasting com-petition datasets, demonstrating better performance than established benchmarks.We conclude that CES has desirable features for time series modeling and opens newpromising avenues for research. CC BY 4.0Attribution 4.0 InternationalFirst published: 02 August 2022Correspondence: Ivan Svetunkov, Centre for Marketing Analytics and Forecasting, Lancaster University Management School, Lancaster, Lancashire, LA1 4YX, UK. Email: i.svetunkov@lancaster.ac.uk

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

Contribution: Determine and analyze the gap between software practitioners' education outlined in the 2014IEEE/ACM Software Engineering Education Knowledge (SEEK) and industrial needs pointed by Wikipedia articles referenced in Stack Overflow (SO) posts. Background: Previous work has uncovered deficiencies in the coverage of computer fundamentals, people skills, software processes, and human-computer interaction, suggesting rebalancing. Research Questions: 1) To what extent are developers' needs, in terms of Wikipedia articles referenced in SO posts, covered by the SEEK knowledge units? 2) How does the popularity of Wikipedia articles relate to their SEEK coverage? 3) What areas of computing knowledge can be better covered by the SEEK knowledge units? 4) Why are Wikipedia articles covered by the SEEK knowledge units cited on SO? Methodology: Wikipedia articles were systematically collected from SO posts. The most cited were manually mapped to the SEEK knowledge units, assessed according to their degree of coverage. Articles insufficiently covered by the SEEK were classified by hand using the 2012 ACM Computing Classification System. A sample of posts referencing sufficiently covered articles was manually analyzed. A survey was conducted on software practitioners to validate the study findings. Findings: SEEK appears to cover sufficiently computer science fundamentals, software design and mathematical concepts, but less so areas like the World Wide Web, software engineering components, and computer graphics. Developers seek advice, best practices and explanations about software topics, and code review assistance. Future SEEK models and the computing education could dive deeper in information systems, design, testing, security, and soft skills., Comment: 9 pages, 2 figures

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.