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.

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

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.

SWForum.eu Way Forward Workshop: Future Challenges in Software Engineering, held on 27 June 2023 at the Politecnico di Milano (POLIMI), in the Dipartamento di Elettronica, Informazione e Bioingegneria (DEIB), featured a dynamic agenda that encompassed a comprehensive range of topics and discussions. With a focus on emerging trends, technological advancements, and industry insights, the event provided a platform for attendees to gain a deeper understanding of the challenges and opportunities awaiting the software engineering community. Unlock the power of knowledge sharing! Embrace the opportunity to showcase your expertise and connect with peers on Online SW-Forum, an accessible and free platform. With our thriving community of nearly 3,000 SWForum members, your contributions will have a far-reaching impact. Let's amplify your voice by spreading this valuable information through your networks and channels. Together, we can create a ripple effect of knowledge and collaboration. Follow us on our pages: 🎓LinkedIn company/SWForumEU 💬Twitter: @SWforumEU ₪ Website: www.SWForum.eu

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.

The topology of isosurfaces changes at isovalues of critical points, making such points an important feature when building contour trees or Morse-Smale complexes. Hexahedral elements with linear interpolants can contain additional off-vertex critical points in element bodies and on element faces. Moreover, a point on the face of a hexahedron which is critical in the element-local context is not necessarily critical in the global context. In ‘`Exploring Scalar Fields Using Critical Isovalues’' Weber et al. introduce a method to determine whether critical points on faces are also critical in the global context, based on the gradient of the asymptotic decider in each element that shares the face. However, as defined, the method of Weber et al. contains an error, and can lead to incorrect results. In this work we correct the error.

Gaze-control and gaze-assistance in software development tools have so far been explored in the setting of code editing, but other developer activities like code review could also benefit from this kind of tool support.In this paper, we present GANDER, a platform for user studies on gaze-assisted code review. As a proof of concept, we extend the platform with an assistant that highlights name relationships in the code under review based on gaze behavior, and we perform a user study with 7 participants. While the participants experience the interaction as overwhelming and lacking explicit actions (seen in other similar user studies), the study demonstrates the platform's capability for mobility, real-time gaze interaction, data logging, replay and analysis.

Replication package of paper ""Can Code Summarization Succeed with Unseen Projects? Harnessing the Power of Latest Large Language Models"", which is under-reviewed at ASE 2023. &nbsp

In the context of developing machine learning models, until and unless we have the required data engineering and machine learning development competencies as well as the time to train and test different machine learning models and tune their hyperparameters, it is worth trying out the automatic machine learning features provided by several cloud-based and cloud-agnostic platforms. This paper explores the possibility of generating automatic machine learning models with low-code experience. We developed criteria to compare different machine learning platforms for generating automatic machine learning models and presenting their results. Thereafter, lessons learned by developing automatic machine learning models from a sample dataset across four different machine learning platforms were elucidated. We also interviewed machine learning experts to conceptualize their domain-specific problems that automatic machine learning platforms can address. Results showed that automatic machine learning platforms can provide a fast track for organizations seeking the digitalization of their businesses. Automatic machine learning platforms help produce results, especially for time-constrained projects where resources are lacking. The contribution of this paper is in the form of a lab experiment in which we demonstrate how low-code platforms can provide a viable option to many business cases and, henceforth, provide a lane that is faster than the usual hiring and training of already scarce data scientists and to analytics projects that suffer from overruns. Validerad;2023;Nivå 2;2023-06-30 (hanlid)

Metrics are now one of the most widely used and effective decision making tools. They make it easy to understand large amounts of data and convey information, however, metrics can be both beneficial and harmful depending on their sourcing and use. The technical and social aspects of this thesis portfolio center around the use and outcome of metrics based on financial data. The technical report focuses on a newer, beneficial use of metrics in software engineering: using a finance platform’s performance metrics to increase speed and accuracy to increase revenue and client productivity. The results of the technical project will be beneficial to engineers interacting with the platform by adding a way to easily track performance and quantifiably justify the adoption of a new platform. The STS report analyzes a potential harmful effect of metrics, examining how while metrics generated by banks’ loan approval machine learning algorithms speed up decision making processes, they also disproportionately reject minority applicants. The analysis in the STS research can point out one of the drawbacks of using metrics without vetting the process with which they were calculated and understanding the social context within which it is used. It is important to analyze how biases in society can be displayed in data, which is used to create metrics that inform decisions that impact society, creating a self-perpetuating cycle of marginalization. The combination of the technical research and STS research will explore an avenue of increasing speed and efficiency in many aspects of society while providing a framework on how to be cognizant of the effects that metrics may have on their users.

Automation has played a critical role in the development and success of the internet. As the internet has grown more complex, software developers have used automation tools to streamline tasks and minimize human error, leading to improved reliability and scalability. Two salient examples of automation on the internet include integration testing and AI censorship software. Integration testing is a crucial step in software development that evaluates the ability of different components to function together. With efficient and automated integration testing procedures, companies can detect and fix issues early in the development process, reducing the risk of problems arising later. Another example of automation on the internet, AI censorship software, is used by all major social media platforms to moderate content on their sites and to enforce their community guidelines. This automated software is often circumvented by censorship slang, a form of resistance that alters and disguises language to convey messages that might otherwise be prohibited. This undergraduate thesis portfolio contains a capstone report describing the author’s design and implementation of an advanced resource retention system for integration testing and a sociotechnical research paper that investigates the effect of AI censorship on internet language.