Quantum machine learning (QML) has attracted growing interest for their ability to achieve superior performance with significantly fewer parameters. However, the high cost and scarcity of current hardware push inference to cloud-hosted quantum devices, creating a tension between verifiability and confidentiality. This work proposes a novel framework that converts quantum neural network operations into classical arithmetic circuits that faithfully approximate genuine quantum computations. By encrypting these circuits with zero-knowledge proofs, it ensures computational validity while concealing internal parameters. Experimental results show that our classical circuits achieve fidelity above 0.9996 and total variation distance below 1% compared to actual quantum computations, verifying the practicality of trustworthy and privacy-preserving quantum inference.

Abstract As Solidity becomes the dominant language for blockchain smart contracts, efficient debugging grows increasingly critical. However, current Solidity debugging remains inefficient: developers must compile, deploy, set up transactions, and trace bytecode execution step by step. This process is too slow for practical use. To address this challenge, this paper presents SolQDebug , the first edit-time debugging assistant for Solidity designed for interactive analysis within a single contract/transaction context, providing abstract value summaries with millisecond feedback directly on source code. Developers specify symbolic interval inputs through annotations and compare them against abstract interpretation results, thereby capturing multiple input scenarios over various execution paths in a single analysis. SolQDebug was evaluated on 30 real-world functions from DAppSCAN, achieving millisecond-scale feedback. This paper also synthesizes experimental observations on annotation patterns for arithmetic operations and loop constructs into practical guidelines. These results demonstrate that SolQDebug serves as an effective edit-time debugging assistant for Solidity development.

The rapid adoption of Verifiable Credentials (VCs) has intensified privacy and security challenges in digital verification, as traditional systems often require full credential disclosure, creating privacy risks and expanding the attack surface. Ensuring end-to-end privacy, security, and verifiability in such systems remains a significant challenge. This paper introducesZK-Sandbox, a Zero-Knowledge Data Sandbox System that integrates zero-knowledge proofs (ZKPs), decentralized identifiers (DIDs), and blockchain anchoring to enable credential validation and verifiable badge issuance without exposing underlying data. ZK-Sandbox supports complex predicate evaluation by securely aggregating multiple VCs from trusted issuers, processing them via JSON Web Token signature verification, Circom-based zk-SNARK circuits, and Docker-isolated execution. The system issues VC-compatible ZK-Badges, cryptographically bound to a Poseidon hash and anchored to a blockchain-registered DID, containing only abstracted verification results. Experimental evaluation confirms 100% validation accuracy, complete detection of tampered submissions, and efficient performance–averaging 326 ms issuance latency, 570 ms off-chain verification, and 4.45 s on-chain verification. These results demonstrate that ZK-Sandbox is a privacy-by-design, scalable, and regulation-aligned solution for self-sovereign digital credential ecosystems.

Web3 authentication stacks largely inherit ECDSA centric single-signature workflows that limit security and efficiency, while custody of identity data often remains application controlled rather than self-sovereign. We present S-Auth, an authentication layer that combines BIP340 Schnorr signatures with Decentralized Identifiers (DID), Verifiable Credentials (VC), and Content addressing (CID). The proposed solution utilizes Schnorr digital signatures, which have demonstrated improved security and efficiency over traditional schemes. The contributions of this work are as follows. Firstly, we apply the BIP340 standard to Schnorr digital signatures, bolstering security against various attacks including strong unforgeability under chosen message attack (SUF-CMA), non-malleability, linearity, related-key at tacks, hash collision, fault injection, nonce exfiltration, resource exhaustion, and domain separation. Secondly, we leverage the linearity property of Schnorr signatures to enable multi-signature aggregation and batch verification, addressing the inefficiency of existing schemes that rely on single signatures and thereby also enhancing privacy. Third, we combine the blockchain with DID, VC, and IPFS to provide a secure and self-sovereign identity that can be authenticated. Experiments comparing ECDSA, Ed25519, Schnorr, and BIP340 show that S-Auth reduces signature artifacts via aggregation, improves verifier throughput with batching, and decreases anchoring overhead while preserving user-controlled identity. S-Auth provides a self-sovereign, efficient, and secure authentication mechanism suitable for Web3 environments.

Proof of Authority (PoA) is a widely adopted consensus algorithm for permissioned blockchain networks, where a group of trusted entities governs the network. PoA is known for achieving rapid consensus with minimal computational and energy requirements. However, existing PoA variants such as Aura and Clique suffer from low transaction throughput in high workload conditions and provide limited randomness in leader selection. They are also vulnerable to time and order manipulation attacks. To overcome these limitations, this paper introduces a novel PoA-based consensus algorithm called Proof of Random Leader (PoRL), which utilizes a verifiable random function to enhance transaction throughput, improve scalability, and ensure fair and unpredictable leader selection. The proposed PoRL algorithm was implemented in Python and evaluated using a network of six consensus nodes with varying computational capabilities. The performance of PoRL was assessed based on key metrics, including security, consistency, availability, fault tolerance, block time, and transaction throughput. Experimental results indicate that PoRL achieves lower consensus times and higher transaction throughput compared to Aura and Clique, making it a more efficient solution for permissioned blockchain networks. The findings of this study provide valuable insights for blockchain practitioners in selecting the most suitable PoA implementation based on their specific network requirements.

Integrating blockchain technology with the Internet of Things (IoT) facilitates seamless interaction between IoT devices and systems to securely share, access, and exchange data. However, ensuring adequate access control within blockchain-enabled IoT (BIoT) systems remains a significant challenge. It is often difficult to adapt existing access control mechanisms to the dynamic and context-dependent nature of IoT environments, necessitating a robust context-aware approach to ensure adequate security and the privacy of resources within BIoT systems. In this paper, we propose a novel smart contract-enabled context-aware access control (SC-CAAC) scheme for BIoT systems. It utilizes context-aware access control models that consider contextual information, including user profile, purpose, date, time, location, resource, and operating environment specifications, to make access control decisions. Smart contracts dynamically enforce access control policies and manage access permissions, ensuring that sensitive data and resources are accessible only to authorized users. The proposed scheme leverages the immutability, transparency, and decentralization of a blockchain that is shared by multiple participants in a consortium network, removing the need for a central authority to record and audit access control policies and decisions and promoting accountability and trust. The implementation and evaluation of our proposed scheme using the Hyperledger Besu blockchain demonstrates its effectiveness and scalability in real-world scenarios.

There is rising global demand for the deployment of a central bank digital currency (CBDC) system to achieve financial stability. However, striking a balance between privacy, transparency, and auditability in such a system is technically difficult. We propose a CBDC system based on a consortium blockchain that adopts a privacy-preserving, transparent unspent transaction output (UTXO) model. The proposed system satisfies the travel rule of payment, unlike existing cryptocurrencies. Unlike the conventional UTXO approach, users use wallet-linked addresses for transactions rather than their actual wallet addresses. Each transacting address is generated using two keys: a random private key computed by the sender and the recipient's public key. The final private key is known only to the recipient, and it is required to spend the UTXO received using the address. Thus, each user holds only a single authorized public key and address, which eases regulatory compliance in the network without compromising anonymity and privacy. To manage the blockchain, the central bank and several certificate authorities execute the energy-efficient Clique consensus algorithm. Only the central bank supplies money to the network. A prototype of the system was implemented using Python-Flask, and it outperformed the state-of-the-art systems by providing a smaller transaction size (665 B) and lower verification time (9 ms).

Regression testing is an important but costly activity for verifying a programme with the changed code. Regression test selection (RTS) aims to reduce this cost by selecting only the test cases affected by the changes. Among the several ways of selecting such affected test cases, call graphs have been statically constructed to select the test cases at the method‐level granularity. However, RTS techniques will reduce the cost of regression testing less than expected unless the call graphs are efficiently one‐to‐one matched with the test cases. In this study, the authors propose overlap‐aware rapid type analysis (ORTA). ORTA is designed to minimise the redundant cost of creating the matched call graphs using rapid type analysis (RTA). The one‐to‐one matching and ORTA were evaluated on 1487 commits selected from 30 Java projects. RTA‐based RTS with the one‐to‐one matching selected 46.90% fewer test cases with 2.76% longer end‐to‐end time of regression testing than without the one‐to‐one matching. The time increased with the one‐to‐one matching was reduced by 22.58% when ORTA substituted for RTA. ORTA achieved the cost reduction while removing 82.77% of the duplicate edges that RTA created on 993 commits.

Mutation testing aims to evaluate the fault detection capability of a test suite. This evaluation substitutes faults with mutants by transforming program code to be defective. Evidences of the relationship between the detection rates of mutants and real faults have supported the use of mutants. It has also been known that the test suite size was a significant factor affecting the relationship. Our study revealed that the selection of the mutated code was another factor affecting the relationship. We generated mutants by transforming the code modified to fix defects, while the modified code was located at three granularity levels. The experiments conducted on the defects4j dataset demonstrated that the granularity level caused a significant difference in the relationship; the detection rate of mutants was more strongly correlated with and more indicative of the fault detection capability at a fine level than at a coarse level. Moreover, the influence of the test suite size was different at each granularity level. These findings implied a strong correlation between the detection rates of mutants and real faults, independently of test suite size, when the error-prone code was located precisely.

Summary In recent years, software development environments have changed from being driven by professional developers to being driven by technical end users. One of the key issues in end‐user‐driven software development environments is how to guarantee the quality of the software artifacts. Measuring the quality of developed software requires the correct specification of a quality range the software is expected to meet. However, technical end users are non‐professionals in engineering techniques for software requirements, and training a developer to be an expert in requirements engineering in a short period of time is difficult. This paper proposes a new software development life cycle based on reutilizing previously evaluated software requirements assets from completed projects. End‐User Requirements Engineering with Collaborative Animation, a tool that was developed to support the proposed software development life cycle, is described and demonstrated by application to three projects. The results from real cases are used as the basis for a discussion on the efficiency enhancement of requirements work, an increased rate of reusing legacy software requirements assets, and an improvement in the technical end user's individual competency level using the End‐User Requirements Engineering with Collaborative Animation. Copyright © 2017 John Wiley & Sons, Ltd.

To facilitate software quality assurance, defect prediction metrics, such as source code metrics, change churns, and the number of previous defects, have been actively studied. Despite the common understanding that developer behavioral interaction patterns can affect software quality, these widely used defect prediction metrics do not consider developer behavior. We therefore propose micro interaction metrics (MIMs), which are metrics that leverage developer interaction information. The developer interactions, such as file editing and browsing events in task sessions, are captured and stored as information by Mylyn, an Eclipse plug-in. Our experimental evaluation demonstrates that MIMs significantly improve overall defect prediction accuracy when combined with existing software measures, perform well in a cost-effective manner, and provide intuitive feedback that enables developers to recognize their own inefficient behaviors during software development.

Although the factors that need to be focused on for a successful software project appear to be difficult to define, risk management has become one of the key activities for achieving such success because significant risk is involved in each software development phase. Software project failures are often a result of insufficient and ineffective risk information regarding the future. To overcome this, software risk prediction should be performed in advance to allow project managers insight into providing more valuable information for decision making, such as scope coverage, resource allocation, and schedule changes. In this research, we propose a risk prediction model from the perspective of quality using a software repository. We evaluated the risk threat level by mapping some defect attributes that exist in the defect lifecycle, defined their risk threat transition states, and applied a Markov chain for predicting the potential risk level. We evaluated the proposed approach using practical real-industry mobile software projects. The experimental results confirm that our approach is applicable to software threat risk estimation.

Customer requirements are critical factors in the success of a software project. Owing to their importance, several methods for understanding customer requirements have been studied in requirements engineering. Although previous studies have mainly focused on the elicitation and analysis of requirements, a method for validating elicited requirements from the customers' perspective has not been actively studied. In this paper, we propose a customer requirements validation (Curve) method using the mental model technique, which is used for analyzing customers' behaviors and their mental states. The Curve provides clear criteria for requirements validation, an integrated framework for evaluating requirements, and it enables prioritization of key requirements based on customers' inner needs. Through this method it is possible to produce software products that better satisfy customers' true needs.

The concept of adaptation and self-adaptation of systems, in particular at runtime has caught the attention of the research community at large, both inside the area of SPL as well as outside SPL in areas like models-at-runtime, selfadaptive systems, ubiquitous computing, etc.

In emerging domains such as ubiquitous computing, service robotics, unmanned space & water exploration, or medical and life-support devices, software is becoming increasingly complex with extensive variation in both requirements and resource constraints. Developers face growing pressure to deliver high-quality software with additional functionality on tight schedules ever more economically.

ABSTRACT Botnets are a disastrous threat because they execute malicious activities such as distributed denial‐of‐service, spam email, malware downloads (such as eggdownloads), and spying by exploiting zombie PCs under their control. Botnets infect PCs on a huge scale by initially scanning the service ports of vulnerable applications for the purpose of propagation, which is leveraged as the size of the botnet increases. Therefore, it is of crucial importance to detect botnet‐propagation activities early and to determine the expectedsize of the attack. To address this issue, this paper proposes to recreate botnets' port‐scanning patterns using a simple text classifier that represents these patterns as a kind of matrix. The patterns obtained are then used to train a hidden Markov model and to perform early detection using the trained model. Early detection is achievable by catching the onset of suspicious propagation immediately, and a size estimate is obtained by monitoring fluctuations in botnet size. With this approach, early‐detection rates increased to more than 30.6% on average, with a low false negative rate (less than 6%) and an F‐measure greater than 96%. This significant improvement in performance will contribute to preventing botnet propagation in its earliest stages. Copyright © 2011 John Wiley & Sons, Ltd.

There is a common belief that developers' behavioral interaction patterns may affect software quality. However, widely used defect prediction metrics such as source code metrics, change churns, and the number of previous defects do not capture developers' direct interactions. We propose 56 novel micro interaction metrics (MIMs) that leverage developers' interaction information stored in the Mylyn data. Mylyn is an Eclipse plug-in, which captures developers' interactions such as file editing and selection events with time spent. To evaluate the performance of MIMs in defect prediction, we build defect prediction (classification and regression) models using MIMs, traditional metrics, and their combinations. Our experimental results show that MIMs significantly improve defect classification and regression accuracy.

Battery exhaustion attack is a ldquodenial of servicerdquo attack on mobile devices, causing more battery discharge than normally necessary. The excessive discharge arises out of the limitation in battery capacity. Researches have been conducted to discover the cause of the abnormal usage of handset battery by employing power estimation techniques. It is also important, however, to automatically respond to the attack and maintain the power discharge at the normal level. In this study, we introduce a method designed to detect the defective process and to self-correct the abnormality by stopping or delaying the suspicious actions. The proposed system monitors system calls and the power usage of a local process, and delays activation of the abnormal system calls until the system calls can be run without hampering the battery life. The benefit of our proposed method lies in that it autonomously protects the expected battery lifespan during a battery exhaustion attack without shutting down operation of falsely detected programs.

Over the past few years, a considerable number of studies have been made on the Return on Security Investment (ROSI) in connection with security policy. However, it is necessary to quantity types of projected damages, cyber threats, security safeguards and ROSI, since the size of information system and its investment factors are growing continuously. Accordingly, in this paper, we propose a way of effective security investment for a higher ROSI, focusing on how to efficiently conduct assessment with use of the Analytic Hierarchy Process (AHP)-based Canonical Correlation Analysis (CCA). The CCA is a means of measuring the linear relationship between relevant cyber threats and corresponding security-safeguarding methods. Finally, we illustrate how such analyses can be used for determination of which security-safeguarding method functions most efficiently, as alternative to the current security investment policy.

Prevention is normally recognized as one of the best defense strategy against malicious hackers or attackers. The desire of deploying better prevention mechanisms has motivated many security researchers and practitioners, who are studies threat trend analysis models. However, threat trend is not directly revealed from the time-series data because the trend is implicit in its nature. Besides, traditional time-series analysis, which predicts the future trend pattern by relying exclusively on the past trend pattern, is not appropriate for predicting a trend pattern in dynamic network environments (e.g., the Internet). Thus, supplemental environmental information is required to uncover a trend pattern from the implicit (or hidden) raw data. In this paper, we propose cyber threat trend analysis model using hidden Markov model (HMM) by incorporating the supplemental environmental information into the trend analysis.

In this paper we show how Theory-W and the WinWin requirements negotiation approach have influenced software engineering education in a number of institutions worldwide. After a short summary of Theory-W and the WinWin negotiation model, processes, and tools the paper discusses how students can benefit from WinWin in their software engineering education. We explore different options for teaching the approach and present concrete examples and experiences from different universities

This paper shows the feasibility of SQL/MDR development. Previous approach has several problems such as complicated exchanging mechanism, dependent description to local MDR systems, high cost for adding new systems, etc. Until now, the advantages of SQL/MDR have been qualitatively shown in several papers. In this paper, its merits are illustrated in quantitative views. Especially, we focus on the query modeling cost to do this; we define several factors and evaluation model. Through the quantitative evaluation, the reason why SQL/MDR is required for exchanging metadata can be explicitly identified.

This paper presents cross-platform 3D game engines, game server and situation-aware middleware, which are essential components of ubiquitous game environments. These components enable situation-aware cross-platform game development, where a seamless game service can be provided if any of the supported platforms is available.

Sensors in ubiquitous computing provide a new opportunity to extend existing RFID capabilities to situation-awareness. This paper proposes several alternatives of the situation-aware radio frequency identification (SA-RFID) system architecture and analyzes the pros and cons of each alternative.

Many routing protocols for wireless sensor network have been proposed, with the purpose of achieving efficient routing. However, when the mobility increases rapidly and the network topology becomes more complex, they have to utilize broadcasting method for packet routing, but the overhead grows rapidly. In this paper, we propose dynamic enclose cell (DEC) routing algorithm to decrease the overhead of routing by constructing the cells with sensor nodes. Compared to existing routing protocols, the DEC routing algorithm is expected to decrease overheads and retain stable networks in high mobility.

Many software projects have failed because their requirements were poorly negotiated among stakeholders. The paper proposes a systematic model, called "multi-criteria preference analysis requirements negotiation (MPARN)" to assist stakeholders to evaluate, negotiate, and agree upon alternatives among stakeholders during requirements analysis using multi-criteria preference analysis techniques. The eight-step MPARN model is applied to requirements gathered for an industrial-academic repository system. An initial analysis demonstrates that multi-criteria preference analysis methodology with the WinWin model potentially increases stakeholders' levels of cooperation and trust by providing a systematic approach to the design of a better negotiation process, as well as focusing on unbiased aspects within a requirements negotiation.

Many organizations would benefit from enterprise-wide, shared information systems. It is common for these organizations to have in place a number of smaller information systems, each of which solves a portion of the problem. Typically, these smaller systems will have been developed independently of one another. As a result, they exhibit many forms of heterogeneity, which pose many impediments to integration. In this paper, we propose and justify an architecture suitable for integrating these smaller systems into a shared information system. The architecture must, to varying degrees of importance, be flexible, responsive, space-efficient, scalable, easy to use, and reliable. The integration effort must also be taken into account. Illustrations are taken from an ongoing case study in which two systems that operate on complementary areas of risk management are being integrated and extended.

Negotiating the right balance between conflicting requirements is often a key to the successful software projects. For large projects, requirements negotiation can be especially difficult to do effectively and efficiently when combining input from non-co-located experts and reaching consensus among the different stakeholders (e.g., end-users, developers, software assurance, customers) as well as among the different aspects of software requirements (e.g., functionality, non-functional quality, and infrastructure). Stakeholder perception conflicts about requirements issues should be identified and resolved in early stage of the project life-cycle to achieve a shared vision of the requirements. A technique for effective and efficient requirements conflict identification and resolution is needed. In this paper, we discuss the issues of applying visualization technique to requirements conflict identification and resolution problems with exploration of potential solution approaches. The following visualization issues are discussed: (1) stakeholders' perception representation and consensus measurement, (2) perception visualization, (3) conflict identification, and (4) conflict resolution.

Describes the application of the WinWin paradigm to identify and resolve conflicts in a series of real-client, student-developer digital library projects. The paper is based on a case study of the statistical analysis of 15 projects and an in-depth analysis of one representative project. These analyses focus on the conflict resolution process, stakeholders' roles and their relationships to quality artifacts, and tool effectiveness. We show that stakeholders tend to accept satisfactory rather than optimal resolutions. Users and customers are more proactive in stating win conditions, whereas developers are more active in working toward resolutions. Further, we suggest that knowledge-based automated aids have potential to significantly enhance process effectiveness and efficiency. Finally, we conclude that such processes and tools have theoretical and practical implications in the quest for better software requirements elicitation.

Many software projects have failed because their requirements were poorly negotiated among stakeholders. Requirements negotiation is more critical than other factors such as tools, process maturity, and design methods. The WinWin negotiation model successfully supports general requirements negotiation. However, making decisions to evaluate alternatives is still an ad-hoc process. This paper presents a systematic model, called Multi-Criteria Preference Analysis Requirements Negotiation (MPARN) to assist stakeholders to evaluate, negotiate and agree upon alternatives among stakeholders using multi-criteria preference analysis techniques.

Effective and efficient requirements negotiation is a key to the success of software development efforts. For large projects, this can be especially difficult to do effectively and efficiently when combining input from non-co-located experts and reaching consensus among the different stakeholders (e.g., end-users, developers, software assurance, customers) as well as among the different aspects of software requirements (e.g., functionality, nonfunctional quality, and infrastructure). Stakeholder perception conflicts about requirements issues should be identified and resolved in the early stage of the project lifecycle to achieve a shared vision of the requirements. We discuss the issues and potential solution approaches for software requirements negotiation problems through visualization. The representation of stakeholder perceptions, visualization of the perceptions, and conflict identification and resolution in the visualized perceptions are discussed.

A two-layer adaptive wrapping technique is proposed in this paper to migrate legacy energy management system (EMS) modules into reusable components, and therefore transforming the legacy system into a component-based system. Meanwhile, an XML-based database wrapping technique is proposed to provide a flexible data exchange solution. These techniques help not only maintaining the reliability but also increasing the reusability of the legacy EMS during the software evolution process.

The paper presents an initial design of the "Plug-n-Analyze" framework for the tradeoff analysis in determining architecture alternatives that have different strength and weakness on quality attributes. The framework provides: (i) architecture alternative negotiation aids among multiple stakeholders; (ii) visualization aids for understanding complicated interactions and tradeoff dependencies among quality attributes; and (iii) a general environment by integrating independent analysis methods by simply "plugging" and generating architecture options for fully "analyzing".

The process of resolving cost-requirements conflicts is difficult because of incompatibilities among stakeholders' interests and priorities, complex cost requirements dependencies, and an exponentially increasing option space for larger systems. The paper describes an exploratory knowledge-based tool,the Software Cost Option Strategy Tool (S-COST), for assisting stakeholders to surface appropriate cost resolution options, to visualize the options, and to negotiate a mutually satisfactory balance of requirements and cost. S-COST operates in the context of the USC-CSE WinWin system (a groupware support system for determining software and system requirements as negotiated win conditions), QARCC (a support system for identifying conflicts in quality requirements), and COCOMO (constructive cost estimation model). Initial analyses of its capabilities indicate that its semiautomated approach provides users with improved capabilities for addressing cost-requirements issues.