The proliferation of misinformation on video-sharing platforms demands robust detection of video fake news. Existing methods struggle to integrate external world knowledge with internal multimodal cues, limiting their generalization and robustness. In this work, we propose TrueLens, a new framework for video fake news detection that gathers and consolidates dual-level evidence \zznotethrough three primary components, \ie, External Precedent Retriever, Adversarial Contrastor, and Internal Evidential Logic Fusion. At the external level, the External Precedent Retriever first decomposes the query video into textual, visual, and audio queries while leveraging multimodal large language models (MLLMs) to enhance the overall semantic representation. It then applies an entropy-guided multimodal retrieval mechanism to identify the two most similar reference videos from a gallery of real and fake samples, \ie, one real and one fake video. The Adversarial Contrastor integrates these references with the input video through contrastive attention, enhancing contextual reasoning. At the internal level, our Evidential Logic Fusion module aggregates multimodal signals from the Adversarial Contrastor to produce consistent, robust predictions. Extensive experiments on three benchmarks show that the proposed TrueLens consistently surpasses competitive baselines under both temporal and event settings by a clear margin, yielding up to a +21.60% F1 improvement under the event setting and achieving 93.73%, 90.64%, and 98.83% accuracy on the FakeSV, FakeTT, and FVC datasets under the temporal setting. The code for our project is available at https://github.com/JunyiChen-ai/TrueLens.

This paper presents Hydra, a dynamic BFT protocol that allows replicas to join and leave the system dynamically. It addresses the limitations of traditional static BFTs in managing membership changes and can be used to simplify the implementation of many features in modern blockchain applications. Hydra relies on weaker assumptions to achieve standard properties compared to the existing solution Dyno and introduces a configuration auto-transition protocol to ensure liveness. Through temporary configurations and explicitly defined replica responsibilities for request handling, Hydra pipelines membership requests alongside regular requests and realizes clarity, achieving a more efficient and smoother configuration transitions. It also employs a non-blocking configuration discovery mechanism, enabling new replicas to participate in consensus quickly. We formally prove Hydra's correctness under the dynamic BFT model. Experimental results demonstrate Hydra's ability to maintain throughput fluctuations within 5% during various replica join and leave scenarios, outperforming Dyno and existing BFT system supporting reconfiguration in both stability and efficiency. Hydra effectively manages scenarios that Dyno circumvents with stronger assumptions and quickly restores throughput to normal levels.

The rapid growth of blockchain technology has driven the widespread adoption of smart contracts; however, their inherent vulnerabilities have led to significant financial losses. Traditional auditing methods, while essential, struggle to keep pace with the increasing complexity and scale of smart contracts. Large language models (LLMs) offer promising capabilities for automating vulnerability detection, but their adoption is often limited by high computational costs. Although prior work has explored leveraging large models through agents or workflows, relatively little attention has been given to improving the performance of smaller, fine-tuned models—a critical factor for achieving both efficiency and data privacy. In this paper, we introduce HKT-SmartAudit, a framework for developing lightweight models optimized for smart contract auditing. It features a multi-stage knowledge distillation pipeline that integrates classical distillation, external domain knowledge, and reward-guided learning to transfer high-quality insights from large teacher models. A single-task learning strategy is employed to train compact student models that maintain high accuracy and robustness while significantly reducing computational overhead. Experimental results show that our distilled models outperform both commercial tools and larger models in detecting complex vulnerabilities and logical flaws, offering a practical, secure, and scalable solution for smart contract auditing. The source code is available in the GitHub repository1.

Recent advances in large language models (LLMs) offer promising potential for automating formal methods. However, applying them to formal verification remains challenging due to the complexity of specification languages, the risk of hallucinated output, and the semantic gap between natural language and formal logic. We introduce PAT-Agent, an end-to-end framework for natural language autoformalization and formal model repair that combines the generative capabilities of LLMs with the rigor of formal verification to automate the construction of verifiable formal models. In PAT-Agent, a Planning LLM first extracts key modeling elements and generates a detailed plan using semantic prompts, which then guides a Code Generation LLM to synthesize syntactically correct and semantically faithful formal models. The resulting code is verified using the Process Anal y sis Toolkit (PAT) model checker against user-specified properties, and when discrepancies occur, a Repair Loop is triggered to iteratively correct the model using counterexamples. To improve flexibility, we built a web-based interface that enables users, particularly non-FM-experts, to describe, customize, and verify system behaviors through user-LLM interactions. Experimental results on 40 systems show that PAT-Agent consistently outperforms baselines, achieving high verification success with superior efficiency. The ablation studies confirm the importance of both planning and repair components, and the user study demonstrates that our interface is accessible and supports effective formal modeling, even for users with limited formal methods experience.

The Internet of Things (IoT) system gathers data through diverse smart devices and sensors to make thorough decisions tailored to specific needs. Yet, in intricate IoT setups, privacy infringement occurs through various means like data collection, initial data handling, and data sharing. Therefore, the concealment of data during transmission should receive sufficient attention. The communication approach that merges blockchain technology with covert communication has shown progress in addressing the aforementioned issues. However, this integration has also led to challenges, such as low-data embedding rates and distinctive features in blockchain transactions containing covert data. To seek a solution with high-embedding rates that do not make generated transactions stand out distinctly, this article analyzes the Ethereum transaction field formats, identifies the input data field with high concealment and large capacity as the embedding target, then proposes a data covert transmission scheme based on hybrid embedding in contract fields. This scheme utilizes LSB steganography to embed high-capacity covert data in images, and embeds the URL of the image into the input data field of the Ethereum smart contract transaction, thereby increasing the embedding rates. Subsequently, to further enhance the concealment of this scheme, a data embedding method based on contract relationships is proposed. Through this technique, for the first time, covert data transmission is achieved solely through the invocation relationships of smart contracts within the blockchain covert communication environment, instead of directly embedding covert data into transactions. This method results in transactions that are theoretically indistinguishable from regular transactions, greatly enhancing the security of the scheme. Finally, an evaluation of undetectability, embedding rate, and scalability was conducted for the proposed schemes, concluding that the schemes presented in this article have significant advantages in all three areas.

A design model is the abstract representation of an actual process or software product. Although some software faults can be found by diagnosing design models before implementation, repairing the design models is time-consuming to software developers. To achieve faster software development, this paper introduces an automated approach to generally repair design models diagnosed by model checking. Model checkers are used to detect faults such as unreachable goals and violated properties in design models. Such faults are eliminated in parallel by insertion, modification and deletion operators found by constraint solving and predictive models. The outcomes of model repair are evaluated using the ISO/IEC 25010 software quality metrics. Experimental results have demonstrated that the proposed approach can eliminate unreachable goals and invariant violations in various design models while preserving their model quality. The effectiveness and performance of such design model repair processes depend mainly on the complexity of design model, the efficiency of constraint solver and the accuracy of predictive model. This study indicates that model-driven software development can be more efficient by automating model diagnosis, fault elimination and quality evaluation. • The repair of software design models is automated by formal methods. • Model checking simultaneously uncovers multiple faults in design models. • Model faults are eliminated by insertion, modification and deletion operators. • Predictions and constraint solving improve the correctness of repair. • Automated model diagnosis and repair preserve the quality of design models.

Blockchain’s inherent immutability, while transformative, creates critical security risks in smart contracts, where undetected vulnerabilities can result in irreversible financial losses. Current auditing tools and approaches often address specific vulnerability types, yet there is a need for a comprehensive solution that can detect a wide range of vulnerabilities with high accuracy. We propose LLM-SmartAudit, a novel framework that leverages Large Language Models (LLMs) to automate smart contract vulnerability detection and analysis. Using a multi-agent conversational architecture with a buffer-of-thought mechanism, LLM-SmartAudit maintains a dynamic record of insights generated throughout the audit process. This enables a collaborative system of specialized agents to iteratively refine their assessments, enhancing the accuracy and depth of vulnerability detection. To evaluate its effectiveness, LLM-SmartAudit was tested on three datasets: a benchmark for common vulnerabilities, a real-world project corpus, and a CVE dataset. It outperformed existing tools with 98% accuracy on common vulnerabilities and demonstrates higher accuracy in real-world scenarios. Additionally, it successfully identifies 12 out of 13 CVEs, surpassing other LLM-based methods. These results demonstrate the effectiveness of multi-agent collaboration in automated smart contract auditing, offering a scalable, adaptive, and highly efficient solution for blockchain security analysis.

This paper presents SCareGPT, an advanced smart contract auditing tool that harnesses domain-specific GPT Assistant technology to enhance vulnerability detection and analysis. We created a standardized dataset featuring 100 labeled vulnera-ble smart contracts and performed comparative benchmarks between SCareGPT and ten traditional smart contract vulnerability detection tools. Our findings demonstrate that SCareGPT excels beyond these competitors in the majority of assessed vulnerability categories, affirming its superiority and utility in the rapidly evolving domain of smart contract security.

The rise of large language models (LLMs) has expanded the possibilities for generative tasks. While LLMs excel at tasks like information retrieval and question-answering, conventional code generation LLMs often struggle to maintain fidelity to prompts, leading to coding hallucinations that produce inaccurate results. In this study, we present Self Coder, a self-guided, single-agent framework for code generation utilising the OpenAI Assistant API built upon GPT-4. By tapping into a comprehensive Python code knowledge base, Self Coder creates an initial draft and refines it iteratively through a feedback loop using the Code Interpreter tool. This approach minimizes contextual inconsistencies and significantly reduces errors, achieving state-of-the-art results on the HumanEval and MBPP datasets, outperforming other code generation frameworks.

Cloud platforms provide extendable and flexible orchestration capabilities for microservices by consolidating multiple computing resources, e.g., multiple service instances can be deployed redundantly to form server clusters, so that if a cloud node or service instance fails unexpectedly, a copy of the service on another node can take over the failed instance to ensure persistent reliability of the system. However, such redundant deployments in cloud may result in unbalanced utilisation of resources, which complicates software quality assessment on cloud nodes. Moreover, the maximisation of the quality of service (QoS) is recognised as a NP problem, making cloud services difficult to be optimised in real-time. To solve these problems, this paper proposes a scheduling combination method for microservices on cloud platforms based on a dual-layer QoS evaluation model, which renders the dual superposition effect of cloud nodes and service instances on system quality. The advantage of the model is that it considers the coupling relationship between cloud hardware or software quality. Further, to optimise QoS in cloud environments based on the model, a hybrid Vision-improved Ant Colony-Genetic algorithm called VACG is proposed to solve the combination optimisation problem and find optimum composition solutions. Our experimental results demonstrate that the scheduling policy based on the dual-layer QoS model surpasses another non-scheduling policy on the metrics of system QoS index and service level agreement conflicts. Additionally, it is found that VACG has a 17.13% and 27.03% of improvement on the optimisation accuracy over a genetic algorithm and ant colony optimisation respectively, as well as higher computational efficiency and stability.

Summary The automation of programming, which lies at the intersection of software engineering and artificial intelligence, enables machines to automatically generate programs that satisfy given requirements. In the context of B formal design modeling, one of the challenges is the refactoring of substitutions in design specifications, which often uses state transitions to describe how program or system statuses change during execution. This paper proposes a condition and substitution refactoring algorithm for the B formal specification language. The aim of the work is to automatically derive B operational predicates based on given transitions. The work has been extremely useful to machine‐driven formal design model repair as well as automated design specification generation. Given a set of state transitions, common relations of their state variables can be discovered and clustered into a number of classes. These relations can be further used to synthesize substitutions that derive new states from existing states. To restrict application domains of the synthesized substitutions, conditions that guard these substitutions are generated using first‐order logic. We have implemented the proposed algorithm as an extension to the ProB model checker. Experiments were conducted based on the B model public dataset. The evaluation results demonstrated that our solution is able to synthesize conditions and substitutions for various sets of state transitions in a wide range of B models.

The evolutionary architecture supports software systems to make small functional changes frequently and reliably. With fitness functions defined, we can ensure that the architectural goals are met as the system evolves. However, some functionality changes cause architectural changes, which impact a large part of the software system. Therefore, we aim at ensuring that changes in the architectural design do not impact the existing functionalities, while new functionalities are incorporated into the new design. This paper proposes an approach to automate architectural design refactoring that supports changes in functionalities. Our approach applies formal modeling and verification to refactor and verify the evolution process of software systems. The proposed algorithms help to automatically refactor the design by referencing the given architecture design. With our appproach, the evolution process can be planned and formally verified to guarantee that the system can evolve safely to support functionality changes. We evaluated our approach with four real-world systems. The results show the effectiveness of our refactoring approach to support new functional properties.

As a newly proposed computational paradigm of membrane computing, cP systems are used to solve several NP-complete and PSPACE-complete problems in linear or sub-linear time theoretically. Most cP systems proposed in previous studies lack of automated verification support. In this paper, we present cPV, the first software implementation for cP system simulation and verification. cPV offers multiple features, which include modelling, simulation, automated verification of properties such as absence of deadlock, confluence, termination, determinism, and goal reachability. As an extensible framework, modules in cPV are loosely coupled, where new verification algorithms, reduction techniques, and property specifications can be easily extended. To evaluate cPV, we constructed two benchmark datasets that cover several important aspects of cP systems. The experimental results demonstrated effective automatic verification support to the membrane computing problem domain.

Automated model repair techniques enable machines to synthesise patches that ensure models meet given requirements. B-repair, which is an existing model repair approach, assists users in repairing erroneous models in the B formal method, but repairing large models is inefficient due to successive applications of repair. In this work, we improve the performance of B-repair using simultaneous modifications, repair refactoring, and better classifiers. The simultaneous modifications can eliminate multiple invariant violations at a time so the average time to repair each fault can be reduced. Further, the modifications can be refactored to reduce the length of repair. The purpose of using better classifiers is to perform more accurate and general repairs and avoid inefficient brute-force searches. We conducted an empirical study to demonstrate that the improved implementation leads to the entire model process achieving higher accuracy, generality, and efficiency.

Context and motivation: Multiple-viewed requirements modeling method describes the system to-be from different perspectives. Some requirements models are then specified in various UML diagrams. Question/problem: Managing those models can be tedious and error-prone, since a lot of CASE tools provide poor support for reasoning and consistency checking. Principal ideas/results: Ontology is a formal notation for describing concepts and their relations in a domain. Since software requirements are a kind of knowledge, we propose to adopt a knowledge engineering approach for managing the consistency of requirements models. In this paper, an ontology for three most commonly used UML diagrams is developed in Web Ontology Language (OWL). The transformation of UML class, sequence and state diagrams to OWL knowledge base is presented. Owing to the underlying logical reasoning capability of OWL, a semantic query language, SPARQL (SPARQL Protocol and RDF Query Language), is used to query the knowledge base for consistency checking. Contribution: This paper introduces a semantic web-based knowledge engineering approach to represent and manage software requirements knowledge in OWL. By experimenting with a concrete software system, we demonstrate the feasibility and applicability of this knowledge approach.

Software architectural designs are usually changed over time to support emerging technologies and to adhere to new principles. Architectural migration is an important activity that helps to transform the architectural styles applied during a system’s design with the result of modernising the system. If not performed correctly, this process could lead to potential system failures. This article presents an automated approach to refactoring architectural design and to planning the evolution process. With our solution, the architectural design can be refactored, ensuring that system functionality is preserved. Furthermore, the architectural migration process allows the system to be safely and incrementally transformed. We have evaluated our approach with five real-world software applications. The results prove the effectiveness of our approach and identify factors that impact the performance of architectural verification and migration planning. An interesting finding is that planning algorithms generate migration plans that differ in term of their relative efficiency.

Software architecture design usually needs to be migrated to new architectural styles when new technologies and principles are adopted to enhance the qualities of the software system. The architectural migration is an evolution process, which the system is gradually and incrementally changed while the functionalities are still preserved. Planning the migration towards a new design is an important and challenging task. This paper presents an automated planning approach for architectural migration by applying AI planning and model checking technique. Our approach can automatically generate migration plans that can be used to find evolution path towards the new architecture designs. We have demonstrated our approach with a real-world system and found that it works effectively.

Spreadsheets are one of the most widely used data management tools. Although intuitive and easy to use, they suffer from a number of issues. Numerous publications indicate that most spreadsheets contain errors and that spreadsheet-based data shadow systems lead to problems such as the “spreadmart dilemma” creating inconsistent views on organizational data. In this paper, we describe “ The Semantic Spreadsheet ”, a new data model for a semantically accurate spreadsheet system. Unlike the existing data models, the described model is a presentation independent data model based on the Resource Description Framework (RDF) that avoids the spreadmart dilemma by providing a semantically sound data structure. We describe the set-theoretic and relational algebraic operations on the data model and show how it can improve data integrity.

The B method has facilitated the development of software by specifying the design of software as abstract machines and formally verifying the correctness of the abstract machines. The quality of B abstract machines can significantly impact the quality of final software products. In this paper, we propose a set of criteria for measuring the quality of B abstract machines based on ISO/IEC 25010, which is one of the latest international standards for evaluating software quality in software engineering. These criteria evaluate abstract machines using a number of general-purpose and domain-independent equations and model checking techniques, so that the quality of abstract machines can be quantified as vectors. The proposed criteria are implemented as a B model quality evaluator, and they are explained and justified using a number of examples.

The architecture smells are the poor design practices applied to the software architecture design. The smells in software architecture design can be cascaded to cause the issues in the system implementation and significantly affect the maintainability and reliability attribute of the software system. The prevention of architecture smells at the design phase can therefore improve the overall quality of the software system. This paper presents a framework that supports the detection of architecture smells based on the formalization of architecture design. Our modeling specification supports representing both structural and behavioral aspect of software architecture design; it allows the smells to be analyzed and detected with the provided tools. Our framework has been applied to seven architecture smells that violate different design principles. The evaluation has been conducted and the result shows that our detection approach gives accurate results and performs well on different size of models. With the proposed framework, other architecture smells can be defined and detected using the process and tools presented in this paper.

This paper proposes a probabilistic reachability repair solution that enables abstract machines to automatically evolve and satisfy desired requirements. The solution is a combination of the B-method, machine learning and program synthesis. The B-method is used to formally specify an abstract machine and analyse the reachability of the abstract machine. Machine learning models are used to approximate features hidden in the semantics of the abstract machine. When the abstract machine fails to reach a desired state, the machine learning models are used to discover missing transitions to the state. Inserting the discovered transitions into the original abstract machine will lead to a repaired abstract machine that is capable of achieving the state. To obtain the repaired abstract machine, a set of insertion repairs are synthesised from the discovered transitions and are simplified using context-free grammars. Experimental results reveal that the reachability repair solution is applicable to a wide range of abstract machines and can accurately discover transitions that satisfy the requirements of reachability. Moreover, the results demonstrate that random forests are efficient machine learning models on transition discovery tasks. Additionally, we argue that the automated reachability repair process can improve the efficiency of software development.

Software architecture design plays a vital role in software development, as it gives an overview of how the software system should be constructed and executed at runtime.The verification of software architecture design is hence important but it is an error-prone task that heavily relies on knowledge and experience of the software architect, especially for a large software system that its behaviour is complex.Automated verification can be a solution to this problem, however, the specification language must be expressive enough to describe the behaviour of different design entities.This paper presents an enhancement of an architecture description language supported by PAT.The enhancement aims to improve the expressiveness of the language, in order to support the automated behaviour verification of software architecture design.With this enhancement, different behaviour of specific component and connector can be thoroughly checked and traced.The implementation of this enhancement is presented to demonstrate how the standard model checking engine such as PAT can be extended to support an architecture description language.We evaluated our approach with a case study and the result is presented.

Program monitoring aims at making sure the functionalities of the software are always correctly performed during runtime. Semantic Web provides a context enriched framework for data representation and manipulation. This paper proposed the use of ontological rules and reasoning engines to monitor the dynamic behaviours of computer systems in handling of exceptional circumstances, both positive and negative, that occur at runtime within the software processes. A prototype framework was proposed on how to integrate the rule based monitoring technique together with the targeted system. To validate the proposed solution, a light control system case study together with the Unity game engine were used to develop a simulation environment for the evaluation purpose. Compared to existing solutions, the approach outlined can provide an effective software behavioural monitoring outcome.

The B-method provides facilities for the design, development and automated verification of software systems, but the repair of faulty abstract machines of B is still a manual task. This paper proposes B-repair, a method that supports the computer-assisted repair of faulty abstract machines. Based on model checking, the B-repair system can generate possible repairs, evaluate the repairs and apply the repairs to faulty B machines. The generation of repairs is based on two formal templates, namely isolation and revision. Moreover, the evaluation of repairs is based on machine learning techniques, such as logistic models, residual neural networks and random forests. The machine learning models learn from the state graph of the original abstract machine, which are used to estimate the quality of repairs. Users are able to select satisfactory repairs and apply the selected repairs to the original machine. Using such a computer-assisted methodology, the B-repair method improves the efficiency of software development using the B-method. The B-repair method has been validated using different real-world models, and the validation result has shown that B-repair can suggest a number of repairs with realistic meanings.

Designing software architecture is a knowledgeintensive task that typically involves textual and diagrammatic notation.Using these kinds of notation is often inconsistent, misleading, and ambiguous.Ontology representation is, therefore, a suitable approach, as it can semantically define architectural design model that can be automatically verified through reasoning.However, a large-scale software system is usually complex and applies more than one architectural styles with various behavioral patterns.Therefore, the scalability of automated verification for a complex software architecture design is a challenge.We propose an approach that helps to formally define complex architectural design model and automate different verifications such as consistency checking, architectural styles recognition, and behavioral sequence inference.Ontology Web Language (OWL) is used to semantically define basic architectural elements and architectural styles, while a set of rules defined in Semantic Web Rule Language (SWRL) helps to capture behavioral pattern according to style.We evaluated the scalability of our approach.The result shows that different levels of complexity in architectural design model has a minor impact on the verification performance. I.

Young drivers are one of the highest risk groups for being involved in car accidents.BackPocketDriver (BPD) is an Android application that aims at encouraging young drivers to adopt and hone safe driving skills.Smartphone sensors are used to monitor driver behaviour, including speed, turning, acceleration and braking.The journey data is analysed for unsafe behaviour with user feedback, which includes journey review, positive reinforcement using textual messages, goal setting and points scoring.To achieve this, behavioural change techniques were studied in relation to gamification, and several features were implemented into BackPocketDriver including achievements, leader board, quizzes, friends system, etc. Evaluations in terms of functional comparisons with related tools were conducted to measure the advantages of the proposed solution.The BPD app provides effective improvements to youth driving. I.

Multiple-viewed requirements modeling allows requirement engineers to acquire the requirements of a system from different perspectives.Requirements are then specified in various UML models.Maintaining the requirements knowledge encoded in UML notations is tedious and error-prone, since most UML CASE tools provide poor support for reasoning and query.Ontology is a formal notation for describing concepts and their relations in a domain.Since requirement is a kind of knowledge, we propose to use knowledge engineering approach for managing the consistency and completeness of UML models.In this paper, an ontology for UML diagrams is coded in a semantic web language, OWL (Web Ontology Language).The transformation of UML Class Diagram, Sequence Diagram and State Diagram to OWL knowledge base is presented.In the end, a semantic query language, SPARQL, is used to query the knowledge base.We demonstrate the feasibility of this approach through an example software system.

This paper briefly reviews the construction of Ruby on Rails applications, identifies the pitfalls of existing tools, and proposes the design and development of a lean cross-platform desktop application, along with an evaluation of the prototype.

With the growing in size and complexity of modern computer systems, the need for improving the quality at all stages of software development has become a critical issue.The current software production has been largely depended on manual code development.Despite the slow development process, the errors introduced by the programmers contribute to a substantial portion of defects in the final software product.This paper explores the possibility of generating code and assertion constraints from formal design models and use them to verify the implementation.We translate Z formal models into their OCL counter-parts and Java assertions.With the help of existing tools, we demonstrate various checking at different levels to enhance correctness.

This paper describes the design and implementation of a PDF extraction tool, which provides the functionalities of meta-data creation, bibliography extraction, HTML conversion and key phrase classification.Evaluation results showed high accuracy rates and good performance measurements.

With the growing in size and complexity of modern computer systems, the need for improving the quality at all stages of software development has become a critical issue. The current software production has been largely dependent on manual code development. Despite the slow development process, the errors introduced by the programmers contribute to a substantial portion of defects in the final software product. This paper investigates the synergy of generating code and assertion constraints from formal design models and use them to verify the implementation. We translate Z formal models into their OCL counterparts and Java assertions. With the help of existing tools, we demonstrate various checkings at different levels to enhance correctness.

The incorporation of peer code reviews as being part of a developer's work flow, and hence the software development lifecycle, has steadily grown in popularity over the past three decades. During the process of statically inspecting code, developers of a codebase are able to collaboratively detect possible code defects, as well as use code reviews as a means of transferring knowledge to improve the overall understanding of a system. The uptake of such practices is dependent on several factors, specifically the availability of tools that aid in providing an easy-to-use and intuitive platform to perform code reviews, and is readily accessible to members of a project. This paper briefly explores the act of code review, identifies the pitfalls of existing code review tools, and proposes the design and development of a web-based code review application, along with the evaluation of the prototype. The code review tool developed, Fistbump, targets the popular Git based repository hosting service, GitHub, and provides a versatile tool to coordinate and manage discussions between the owner of a pull request and the elected participants of a review.

Understanding existing pieces of software is a challenge faced by many software developers regardless of their experience. This project researches into existing reverse engineering tools used for code comprehension and identifies the limitations of the current approaches. Furthermore, a prototype implementation was developed to extract design models from available source code in order to achieve better program comprehension. The design and implementation of the model extraction tool were defined, with a focus on Java systems and an agile methodology. This tool was realised by extending the existing open source diagrammatic software, UMLet, with a set of features to aid in code comprehension. Finally, the prototype implementation was evaluated against the related tools in the field as well as by a group of professional experts.

Model Driven Engineering (MDE), despite having many advantages, is often overlooked by programmers due to lack of proper understanding and training in the matter.This paper investigates the advantages and disadvantages of MDE and looks at research results showing the adoption rates of design models.In light of the findings, an educational tool, namely Lorini, was developed to provide automated code generation from the design models.The implemented tool consists in a plug-in for the Astah framework aimed at teaching Java programming to students through UML diagrams.It features instantaneous code generation from three types of UML diagrams, code-diagram matching, a feedback panel for error displays and on-the-fly compilation and execution of the resulting program.Evaluation of the tool indicated it to be successful with unique educational features and intuitive to use.

With the growing in size and complexity of modern computer systems, the need for improving the quality at all stages of software development has become a critical issue. The current software production has been largely dependent on manual code development. Despite the slow development process, the errors introduced by the programmers contribute to a substantial portion of defects in the final software product. Model-driven engineering (MDE), despite having many advantages, is often overlooked by programmers due to lack of proper understanding and training in the matter. This paper investigates the advantages and disadvantages of MDE and looks at research results showing the adoption rates of design models. It analyzes different tools used for automated code generation and displays the reasons that led to technical decisions such as the programming language or design model used. In light of the findings, an educational tool, namely Lorini, was developed to provide automated code generation from the design models. The implemented tool consists of a plug-in for the Astah framework aimed at teaching Java programming to students through UML diagrams. It features instantaneous code generation from three types of UML diagrams, code-diagram matching, a feedback panel for error displays and on-the-fly compilation and execution of the resulting program. We also explore the possibility of generating assertion constraints from the design model and use them to verify the implementation. Evaluation of the tool indicated it to be successful with unique educational features and intuitive to use.

The advance of analytics technology has attracted more attention and adoption from sports, although modeling and analyzing the dynamic (and uncertain) behaviors of sports are challenging. Formal methods have been strongly recommended to deal with complex systems by their rigorous semantics and powerful reasoning capabilities. In this paper, we present our initiative as the first to apply probabilistic model checking techniques to strategy analytics for tennis based on Markov Decision Processes (MDP). Our approach can derive insights such as prediction of winning chances and identification of best improvement. We evaluate the effectiveness of our approach through real-life case study.

Model checking has been pervasive and successful in finding bugs in hardware and software systems, including real-time and probabilistic systems. Applying model checking to decision making is relative new and has an excellent potential to be compliment to data analytics and other Artificial Intelligent (AI) or Operational Research (OR) based decision making techniques. Our last 8 years research has focused on the development of PAT (Process Analysis Toolkit) [18] whichsupports modelling languages that combine the expressiveness of event, state, time and probability based modeling techniques to which model checking can be directly applied. The next direction for PAT is to move from verification to analytics, we call it "Event Analytics" with a special focus on "Strategy Analytics".

Semantic Web Services (SWS) introduce a semantic layer to the current web infrastructure, enabling the automated processing of web tasks. Different frameworks have been proposed for designing SWS, however, there has been little research in the area of testing SWS. Generating test cases for SWS is challenging due to its dynamic nature and abstract views, evaluating the test cases is equally essential in order to ensure the quality of the test suite. In this paper, we propose a goal oriented generation and mutation based evaluation approach towards SWS testing. This way, the generation (model-based) and evaluation (code-based) procedures are totally independent to each other, which further provides a much accurate measurement on the results. In addition, a tool support has been developed to automate the major steps in the proposed solution.

Model checking provides a way to automatically verify hardware and software systems, whereas the goal of planning is to produce a sequence of actions that leads from the initial state to the desired goal states. Recently research indicates that there is a strong connection between model checking and planning problem solving. In this paper, we investigate the feasibility of using different model checking tools and techniques for solving classic planning problems. To achieve this, we carried out a number of experiments on different planning domains in order to compare the performance and capabilities of various tools. Our experimental results indicate that the performance of some model checkers is comparable to that of state-of-theart planners for certain categories of problems. In particular, a new planning module with specifically designed searching algorithm is implemented on top of the established model checking framework, Process Analysis Toolkit (PAT), to serve as a planning solution provider for upper layer applications. A case study on a public transportation management system has been developed to demonstrate the idea of using the PAT model checker as a planning service.

It is often necessary to combine multiple scores into a joint decision in many real-world applications. To that end, an essential challenge is to build a proper weighted scoring rule, which assigns more weight to the more important scores and derives

Conventional k-means only considers pair wise similarity during cluster assignment, which aims to minimizing the distance of points to their nearest cluster centroids. In high dimensional space like document datasets, however, two points may be nearest neighbors without belonging to the same class. Thus pair wise similarity alone is often insufficient for class prediction in such space. To that end, in this paper, we propose to augment k-means with pair wise constraints generated from group similarity-based hyper clique patterns, which consist of strongly affiliated objects and serve as more reliable seeds for classification. Experiments with real-world datasets show that, with such constraints from quality hyper clique patterns, we can improve the clustering results in terms of various external criteria. Also, our experiments indicate that even if few constraints are violated in the original result of k-means, imposing many quality constraints may still bring gain of performance.

Semistructured data has become more and more prominent in the fast growing areas of web information technology. XML has been used as a standard format for semistructured data in representing and exchanging information in various applications. However, the lack of formality and verification support in the design of a good semistructured data model may hinder its development. For example, redundant data in XML must be removed or minimized to avoid inconsistent and inefficient information processing. Normalization algorithms have been developed to overcome these problems by transforming the schema of a semistructured document into a better form. Therefore, it is essential to ensure that a transformed schema model preserves the same information that its original form holds. In this paper, we present an approach to investigate and verify the no-data-loss property of semistructured data normalization. We encode the verification criteria in the Semantic Web Rule Language (SWRL) and make use of its ontology reasoning engine to provide automated support for the checking process. In summary, our approach not only investigates the information preserving aspect of semistructured data normalization, but also provides a scalable and automated solution towards the problem.

The dramatic expansion of semistructured data has led to the development of database systems for manipulating the data. Despite its huge potential, there is still a lack of formality and verification support in the design of good semistructured databases. Like traditional database systems, developed semistructured database systems should contain minimal redundancies and update anomalies, in order to store and manage the data effectively. Several normalization algorithms have been proposed to satisfy these needs, by transforming the schema of the semistructured data into a better form. It is essential to ensure that the normalized schema remains semantically equivalent to its original form. In this paper, we present tool support for reasoning about the correctness of semistructured data normalization. The proposed approach uses the ORA-SS data modeling notation and defines its correctness criteria and rules in the PVS formal language. It further utilizes the PVS theorem prover to perform automated checking on the normalized schema, checking that functional dependencies are preserved, no data is lost and no spurious data is created. In summary, our approach not only investigates the characteristics of semistructured data normalization, but also provides a scalable and automated first step towards reasoning about the correctness of normalization algorithms on semistructured data.

Software Architecture represents the high level description of a system in terms of components, external properties and communication. Despite its importance in the software engineering process, the lack of formal description and verification support limits the value of developing architectural models. Automated formal engineering methods can provide an effective means to precisely describe and rigorously verify intended structures and behaviors of software systems. In this paper, we present an approach to support the design and verification of software architectural models using the Alloy analyzer. Based on our earlier work, we propose a fundamental library for specifying system structures in terms of different architectural styles. We illustrate use of the architecture style library in modeling and verifying a complex system that utilizes multi-style structures. To promote scalability, we use model decomposition to parallelize the verification process. Results show that our approach enhances the performance of verifying models significantly.

Verification techniques like SAT-based bounded model checking have been successfully applied to a variety of system models. Applying bounded model checking to compositional process algebras is, however, not a trivial task. One challenge is that the number of system states for process algebra models is not statically known, whereas exploring the full state space is computationally expensive. This paper presents a compositional encoding of hierarchical processes as SAT problems and then applies state-of-the-art SAT solvers for bounded model checking. The encoding avoids exploring the full state space for complex systems so as to deal with state space explosion. We developed an automated analyzer which combines complementing model checking techniques (i.e., bounded model checking and explicit on-the-fly model checking) to validate system models against event-based temporal properties. The experiment results show the analyzer handles large systems.

This paper proposes a novel heterogeneous software architecture FTA (fault tolerant architecture). FTA incorporates idealized fault tolerant component concept and coordinated error recovery mechanism in the early system design phase. It can be reused in the high level model design of specific mission critical distributed systems with reliability requirements. The formal model of FTA in the Object-Z language is presented to provide precise idioms to the system designers. Formal proof using the Object-Z reasoning rules are constructed to demonstrate the fault tolerant properties of FTA. By analyzing the customization process, we also present a FTA template, expressed in x-frames using XVCL (XML-based variant configuration language) methodology, to automate the customization process. We apply a sales control system case study to illustrate the customization of FTA.

This paper reports a recent research investigation on an integrated formal approach to model and verify sensor constraints in the context awareness systems.

Dynamic reconfiguration is the process of making changes to software at run-time. The motivation for this is typically to facilitate adaptive systems which change their behavior in response to changes in their operating environment or to allow systems with a requirement for continuous service to evolve uninterrupted. To enable development of reconfigurable applications, we have developed OpenRec, a framework which comprises a reflective component model plus an open and extensible reconfiguration management infrastructure. Recently we have extended OpenRec to verify whether an intended (re)configuration would result in an application's structural constraints being satisfied. Consequently OpenRec can automatically veto proposed changes that would violate configuration constraints. This functionality has been realized by integrating OpenRec with the ALLOY Analyzer tool via a service-oriented architecture. ALLOY is a formal modelling notation which can be used to specify systems and associated constraints. In this paper, we present an overview of the OpenRec framework. In addition, we describe the application of ALLOY to modelling re-configurable component based systems and highlight some interesting experiences with integrating OpenRec and the ALLOY Analyzer

This paper proposes a novel heterogeneous software architecture GFTSA (Generic Fault Tolerant Software Architecture) which can guide the development of safety critical distributed systems. GFTSA incorporates an idealized fault tolerant component concept, and coordinated error recovery mechanism in the early system design phase. It can be reused in the high level model design of specific safety critical distributed systems with reliability requirements. To provide precise common idioms & patterns for the system designers, formal language Object-Z is used to specify GFTSA. Formal proofs based on Object-Z reasoning rules are constructed to demonstrate that the proposed GFTSA model can preserve significant fault tolerant properties. The inheritance & instantiation mechanisms of Object-Z can contribute to the customization of the GFTSA formal model. By analyzing the customization process, we also present a template of GFTSA, expressed in x-frames using the XVCL (XML-based Variant Configuration Language) methodology to make the customization process more direct & automatic. We use an LDAS (Line Direction Agreement System) case study to illustrate that GFTSA can guide the development of specific safety critical distributed systems

Research on features has received much attention in the domain engineering community. Feature modeling plays an important role in the design and implementation of complex software systems. However, the presentation and analysis of feature models are still largely informal. There is also an increasing need for methods and tools that can support automated feature model analysis. This paper presents a formal engineering approach to the specification and verification of feature models. A formal semantics for the feature modeling language is defined using first-order logic. It provides a precise and rigorous formal interpretation for the graphical notation. In addition, further validation of the semantics using the Z/EVES theorem prover is presented. Finally, we demonstrate that the consistency of a feature model and its configurations can be automatically verified by encoding the semantics into the Alloy Analyzer. A case study of the Key Word in Context (KWIC) index systems feature model is presented to illustrate the verification process.

Semantic Web is regarded as the next generation of the World Wide Web. It provides not only the structure of the Web but also meaningful semantics for the information presented. To make semantic Web services understandable for distributed agents, formal definitions of the ontologies and their consistencies are essential. However, the existing tools for reasoning about semantic Web ontologies are still primitive. We believe that mature software engineering tools, such as theorem provers, can contribute to the reasoning phase. In this paper, we present an approach of encoding the semantic Web ontology (DAML+OIL) into the generic theorem prover Isabelle/HOL for automatic reasoning. Furthermore, a translation tool was developed to transform semantic Web ontologies into their extended Isabelle theories. With additional intermediate lemmas, Isabelle can be used to perform both subsumption (class) level and instantiation (instance) level reasoning of the semantic Web ontologies.

Formal modeling techniques can be used to define and verify software architectures precisely. The paper applies the integrated formal specification technique, Timed Communicating Object Z (TCOZ), to generic software architecture modeling and verification.

The challenge for system specification is how to visually and precisely capture static, dynamic and real-time system properties in a highly structured way. Timed Communicating Object-Z (TCOZ) is an integrated formal notation that build on Object-Z's strengths in modeling complex data structures, and on Timed CSP's strengths in modeling real-time interactions. In this paper, we demonstrate approaches of using XML/XSL as a transformation tool to visualize TCOZ models into various UML diagrams and to animate TCOZ specifications with a multi-paradigm programming language-Oz.

This paper presents the XML/XSL approach to the developmentofaweb environment for the formal specification language Object-Z. The projection techniques and tools from Object-Z (in XML) to UML (in XMI) are developed using XSL Transformations (XSLT). Furthermore, Object-Z (itself) is used to specify and design the essential functionalities of the web environment and the projection tools to UML. In a sense, the paper also demonstrates a formal approach to modeling web applications. Keywords Object-Z, XML/XSL/XMI, UML 1.