This study investigates the organizational factors influencing technological readiness for Artificial Intelligence (AI) adoption, using a theoretical lens grounded in Sociotechnical Systems Theory (STS). A survey of 210 participants from educational and industrial institutions in China was analyzed using Partial Least Squares Structural Equation Modeling (PLS-SEM). The results confirm that AI adoption significantly enhances organizational efficiency and employee engagement, which in turn mediate its impact on technological readiness. By incorporating mediation analysis, the study provides a nuanced understanding of the indirect mechanisms through which AI adoption influences readiness, offering both theoretical and managerial insights for AI-enabled transformation. The integration of STS and rigorous empirical modeling presents a methodologically sound and practically relevant contribution to the field.

As artificial intelligence (AI) technologies become increasingly integrated into organizational operations, understanding the factors that drive AI-driven innovation performance is crucial. This study examines the roles of Digital Leadership (DL), Knowledge Management Effectiveness (KME) and AI Integration Capability (AIIC) in promoting Organizational Agility (OA) within Chinese industries. Using a mixed-methods approach and Structural Equation Modeling (SEM) with Smart Partial Least Squares (Smart PLS), the research analyzes data from 540 respondents across various sectors. The findings reveal significant direct effects of DL and AIIC on OA, as well as indirect effects mediated by DL and AIIC. Additionally, the study identifies moderation effects where AI-Driven Innovation Performance (AIDIP) enhances the relationships between KME and AIIC, as well as between AIIC and OA. The results highlight the importance of strategic leadership, effective knowledge management and robust AI integration capabilities in achieving organizational agility. The study contributes to the literature by providing a comprehensive model of AI-driven innovation performance and offers practical insights for organizations seeking to leverage AI technologies for competitive advantage. Limitations and future research directions are discussed, including the potential for global and longitudinal studies to further explore these relationships.

Federated multilabel learning enables the collaborative training of multilabel classification models while preserving client privacy. Existing federated multilabel learning methods either fail to effectively capture label correlations, which significantly affects model performance in scenarios where labels are interdependent, or increase the risk of client privacy leakage due to the transmission of unnecessary client data. To this end, we propose FML-DGCN, a federated multi-label learning approach based on dynamic graph convolutional networks. In the local training phase, a dynamic graph convolutional module is designed and employed to generate label representations specific to the input image, with parameters efficiently optimized by our designed correlation alignment loss. Within the module, we employ a fully connected layer-based network to merge static label embeddings and image features for computing dynamic label graphs, instead of leveraging complex attention-based networks, making it suitable for federated learning environments with limited computing resources. In the federated aggregation phase, clients transmit only model parameters, without sharing any additional information such as scene knowledge, thus lowering the risk of client privacy leakage. Experimental results on four typical multilabel image classification datasets demonstrate the superiority of our approach.

Change-proneness prediction aims to identify source files that deserve developers' attention for early quality improvement, ultimately reducing future maintenance costs. Existing studies have utilized diverse change features and machine learning techniques to construct effective prediction models. However, these approaches do not leverage the grouping of change features for the learning of feature representations; and the roles of dependency files in influencing the change-proneness of the target file are not adequately exploited. To this end, in this paper, we propose a novel approach called DeepCP, which utilizes a deep learning model to predict the change-proneness of source files. The key rationale of DeepCP is that the grouping of change features should be considered when constructing deep learning models, given that feeding the sequence of features directly into models has a detrimental impact on the learning of feature representations. To achieve this, DeepCP utilizes different subnetworks to learn different categories of features and merges the resulting representations with a multi-head attention network to generate the source file representation. Another key rationale of DeepCP is that the features of dependency files should be exploited because the change-proneness of dependency files influences that of the target file due to ripple effects. To accomplish this, DeepCP first learns the representations of the target file and its structurally dependent files and then integrates the resulting representations with an attention network. Our evaluation results demonstrate that DeepCP outperforms the state-of-the-art approach in predicting change-proneness.

Structured Query Language (SQL) is the dominant language for managing relational databases. However, complex SQL queries are hard to write and maintain because of the intricate inter-table and inter-column relations. To this end, we propose a novel query language called SQL#, which allows programmers to construct complex queries module by module and explicitly specify the relations between different modules according to the logical steps of constructing queries. Besides, we design a SQL#-based system, aiming to facilitate the maintenance of SQL# queries. Specifically, the system renders a SQL# program into a hierarchical graph, which could help programmers understand the high-level structures of SQL# programs and the intricate relations between different components within SQL# programs. In addition, the system can ease the generation of the intermediate tables that correspond to the logical steps of constructing queries, which could help programmers debug complex SQL# queries. Notably, the design of SQL# makes it easy for the system to generate the hierarchical graph and the intermediate tables. Controlled experiments suggest that the SQL#-based system reduces the durations of writing and understanding database queries by 79% and 39%, respectively, compared to raw SQL code.

Bug-related research, e.g., fault localization, program repair, and software testing, relies heavily on high-quality and large-scale software bug repositories. The importance of such repositories is twofold. On one side, real-world bugs and their associated patches may inspire novel approaches for finding, locating, and repairing software bugs. On the other side, the real-world bugs and their patches are indispensable for rigorous and meaningful evaluation of approaches to software testing, fault localization, and program repair. To this end, a number of software bug repositories, e.g., iBUGS and Defects4J, have been constructed recently by mining version control systems and bug tracking systems. However, fully automated construction of bug repositories by simply taking bug-fixing commits from version control systems often results in inaccurate patches that contain many bug-irrelevant changes. Although we may request experts or developers to manually exclude the bug-irrelevant changes (as the authors of Defects4J did), such extensive human intervention makes it difficult to build large-scale bug repositories. To this end, in this paper, we propose an automatic approach, calledBugBuilder, to construct bug repositories from version control systems. Different from existing approaches, it automatically extracts complete and concise bug-fixing patches and excludes bug-irrelevant changes. It first detects and excludes software refactorings involved in bug-fixing commits.BugBuilderthen enumerates all subsets of the remaining part, and discards invalid subsets by compilation and software testing. If exactly a single subset survives the validation, this subset is taken as the complete and concise bug-fixing patch for the associated bug. In case multiple subsets survive, BugBuilder employs a sequence of heuristics to select the most likely one. Evaluation results on 809 real-world bug-fixing commits in Defects4J suggest thatBugBuildersuccessfully extracted complete and concise bug-fixing patches from forty-three percent of the bug-fixing commits, and its precision (99%) was even higher than human experts. We also built a bug repository, called GrowingBugs, with the proposed approach. The resulting repository serves as evidence of the usefulness of the proposed approach, as well as a publicly available benchmark for bug-related research.

High-quality and large-scale repositories of real bugs and their concise patches collected from real-world applications are critical for research in software engineering community. In such a repository, each real bug is explicitly associated with its fix. Therefore, on one side, the real bugs and their fixes may inspire novel approaches for finding, locating, and repairing software bugs; on the other side, the real bugs and their fixes are indispensable for rigorous and meaningful evaluation of approaches for software testing, fault localization, and program repair. To this end, a number of such repositories, e.g., Defects4J, have been proposed. However, such repositories are rather small because their construction involves expensive human intervention. Although bug-fixing code commits as well as associated test cases could be retrieved from version control systems automatically, existing approaches could not yet automatically extract concise bug-fixing patches from bug-fixing commits because such commits often involve bug-irrelevant changes. In this paper, we propose an automatic approach, called BugBuilder, to extracting complete and concise bug-fixing patches from human-written patches in version control systems. It excludes refactorings by detecting refactorings involved in bug-fixing commits, and reapplying detected refactorings on the faulty version. It enumerates all subsets of the remaining part and validates them on test cases. If none of the subsets has the potential to be a complete bug-fixing patch, the remaining part as a whole is taken as a complete and concise bug-fixing patch. Evaluation results on 809 real bug-fixing commits in Defects4J suggest that BugBuilder successfully generated complete and concise bug-fixing patches for forty percent of the bug-fixing commits, and its precision (99%) was even higher than human experts.

Secure password storage is a vital aspect in systems based on password authentication, which is still the most widely used authentication technique, despite some security flaws. In this paper, we propose a password authentication framework that is designed for secure password storage and could be easily integrated into existing authentication systems. In our framework, first, the received plain password from a client is hashed through a cryptographic hash function (e.g., SHA-256). Then, the hashed password is converted into a negative password. Finally, the negative password is encrypted into an encrypted negative password (ENP) using a symmetric-key algorithm (e.g., AES), and multi-iteration encryption could be employed to further improve security. The cryptographic hash function and symmetric encryption make it difficult to crack passwords from ENPs. Moreover, there are lots of corresponding ENPs for a given plain password, which makes precomputation attacks (e.g., lookup table attack and rainbow table attack) infeasible. The algorithm complexity analyses and comparisons show that the ENP could resist lookup table attack and provide stronger password protection under dictionary attack. It is worth mentioning that the ENP does not introduce extra elements (e.g., salt); besides this, the ENP could still resist precomputation attacks. Most importantly, the ENP is the first password protection scheme that combines the cryptographic hash function, the negative password, and the symmetric-key algorithm, without the need for additional information except the plain password.

Most of the community detection methods require the global information of the original network to be available, however, it is often expensive (even no way) to obtain the global information of the network in many real-world networks. So, the local community detection, only based on the local information, becomes especially important. The local community is the community in the network to which a given starting node belongs. Some local community detection methods have been proposed. However, these methods did not consider the characteristics of the local community during the local community formation. In this paper, we analyze the formation of the local community and propose two local community detection algorithms based on the dynamic membership function. Each of the algorithms is divided into three stages: 1) the initial stage, 2) the middle stage, and 3) the closing stage. At the initial stage, we design a dynamical membership function to detect local community and nodes with the greatest neighborhood intersect rate could be added to the local community. At the middle stage, we design another dynamical membership function, and the goal of this stage is to make the connection of the node in the local community closest. At the closing stage, the third dynamical membership function is provided, and the local community is further improved by collecting some nodes that should not be omitted. We test our algorithms on several synthetic datasets and real datasets; the results show that the local communities detected by our method are closer to the real local communities.