In Audio-Visual Event Localization (AVEL) task, various cross-modal attentions (CMA) were proposed to capture the bilateral correlations of audio and visual segments. However, existing CMA approaches are inefficient since they require two sets of independent attention parameters. Besides, existing works often ignore the semantic alignment between audio and audible objects, leading to the suboptimal localization results. In this letter, a novel network with a cross co-attention (CCA) and a dynamic audio-object semantic alignment (DAOSA) strategy is proposed to tackle these issues. Unlike existing CMA methods, CCA calculates the co-attention between audio and visual segments to capture the bilateral correlations via a group of parameters. To align the semantics of audio and audio-related objects, DAOSA proposes a dynamic threshold scheme to adaptively select the highly relevant audio-object pairs as positivity while regarding other pairs as negativity. Then, DAOSA optimizes the semantic alignment of positive pairs by contrastive learning. Experiments across different datasets demonstrate the effectiveness of proposed method, which also outperforms several state-of-the-art models.

Reducing test inputs that trigger bugs is crucial for efficient debugging. Delta debugging is the most popular approach for this purpose. When test inputs need to conform to certain specifications, existing delta debugging practice encounters a validity problem: it blindly applies reduction rules, producing a large number of invalid test inputs that do not satisfy the required specifications. This overall diminishing effectiveness and efficiency becomes even more pronounced when the specifications extend beyond syntactical structures. Our key insight is that we should leverage input generators, which are aware of these specifications, to generate valid reduced inputs, rather than straightforwardly performing reduction on test inputs. In this article, we propose a generator-based delta debugging method, namely GReduce, which derives validity-preserving reducers. Specifically, given a generator and its execution, demonstrating how the bug-inducing test input is generated, GReduce searches for other executions on the generator that yield reduced, valid test inputs. The evaluation results on five benchmarks (i.e., graphs, DL models, JavaScript programs, SymPy, and algebraic data types) show that GReduce substantially outperforms state-of-the-art syntax-based reducers including Perses and T-PDD, and also outperforms QuickCheck, SmartCheck, as well as the state-of-the-art choice-sequence-based reducer Hypothesis, demonstrating the effectiveness, efficiency, and versatility of GReduce.

Bidirectional live programming systems (BLP) enable developers to modify a program by directly manipulating the program output, so that the updated program can produce the manipulated output. One state-of-the-art approach to BLP systems is operation-based, which captures the developer's intention of program modifications by taking how the developer manipulates the output into account. The program modifications are usually hard coded for each direct manipulation in these BLP systems, which are difficult to extend. Moreover, to reflect the manipulations to the source program, these BLP systems trace the modified output to appropriate code fragments and perform corresponding code transformations. Accordingly, they require direct manipulation users be aware of the source code and how it is changed, making “direct” manipulation (on output) be “indirect”. In this paper, we resolve this problem by presenting a novel operation-based framework for bidirectional live programming, which can automatically fuse direct manipulations into the source code, thus supporting code-insensitive direct manipulations. Firstly, we design a simple but expressive delta language DM capable of expressing common direct manipulations for output values. Secondly, we present a fusion algorithm that propagates direct manipulations into the source functional programs and applies them to the constants whenever possible; otherwise, the algorithm embeds manipulations into the “proper positions” of programs. We prove the correctness of the fusion algorithm that the updated program executes to get the manipulated output. To demonstrate the expressiveness of DM and the effectiveness of our fusion algorithm, we have implemented FuseDM, a prototype SVG editor that supports GUI-based operations for direct manipulation, and successfully designed 14 benchmark examples starting from blank code using FuseDM.

Many bidirectional programming languages, which are mainly functional and relational, have been designed to support writing programs that run in both forward and backward directions. Nevertheless, there is little study on the bidirectionalization of object-oriented languages that are more popular in practice. This paper presents the first bidirectional object-oriented language that supports programmatic and direct manipulation of objects. Specifically, we carefully extend a core object-oriented language, which has a standard forward evaluation semantics, with backward updating semantics for class inheritance hierarchies and references. We formally prove that the bidirectional evaluation semantics satisfies the round-tripping properties if the output is altered consistently. To validate the utility of our approach, we have developed a tool called BiOOP for generating HTML documents through bidirectional GUI design. We evaluate the expressiveness and effectiveness of BiOOP for HTML webpage development by reproducing ten classic object-oriented applications from a Java Swing tutorial and one large project from GitHub. The experimental results show the response time of direct manipulation programming on object-oriented programs that produce HTML webpages is acceptable for developers.

In model-driven low-code development, developers obtain the initial system implementation by generating the source code from models and then modify the generated code for custom-ization. In the subsequent development, the models may evolve so the code must be re-generated. How to merge the modified code with the newly generated code is an important issue. Existing model-driven development tools simply discard the code changed by developers or preserve developers' code based on some special annotations manually appended by developers. This paper pro-poses MerGen, a smart code merger for the generated code. Mer-Gen relies on universal unique identifiers that are associated with the generated code entities (i.e., types, fields, and methods) to pair the parts to be merged. Then, MerGen computes the digest of an entity in the normalized form to automatically determine whether the entity has been changed. Finally, MerGen uses a two-way re-factoring-based merging algorithm to merge the semantic code changes, rather than directly merging the code textually. We im-plement a prototype tool for the Eclipse Modeling Framework (EMF) and conduct a case study to evaluate the feasibility and the effectiveness of MerGen. The study results show that MerGen can effectively merge the modified code with the newly generated code compared with the default code merger of the EMF.

Similarity-based model matching is the foundation of model versioning. It pairs model elements based on a distance metric (e.g., edit distance). Because it is expensive to calculate the distance between two elements, a similarity-based matcher usually suffers from performance issues when the model size increases. This paper proposes a hash-based approach to accelerate similarity-based model matching. Firstly, we design a novel similarity-preserving hash function that maps a model element to a 64-bit hash value. If two elements are similar, their hashes are also very close. Secondly, we propose a 3-layer index structure and a query algorithm to quickly filter out impossible candidates for the element to be matched based on their hashes. For the remaining candidates, we employ the classical similarity-based matching algorithm to determine the final matches. Our approach has been realized and integrated into EMF Compare. The evaluation results show that our hash function is effective to preserve the similarity between model elements and our matching approach reduces 16%--72% of time costs while assuring the matching results consistent with EMF Compare.

High performance numerical simulation programs are widely used to simulate actual physical processes on high performance computers for the analysis of various physical and engineering problems. They are usually regarded as non-testable due to their high complexity. This paper reports our real experience and lessons learned from testing five simulation programs that will be used to design and analyze nuclear power plants. We applied five testing approaches and found 33 bugs. We found that property-based testing and metamorphic testing are two effective methods. Nevertheless, we suffered from the lack of domain knowledge, the high test costs, the shortage of test cases, severe oracle issues, and inadequate automation support. Consequently, the five programs are not exhaustively tested from the perspective of software testing, and many existing software testing techniques and tools are not fully applicable due to scalability and portability issues. We need more collaboration and communication with other communities to promote the research and application of software testing techniques.

When building enterprise applications on Java frameworks (e.g., Spring), developers often specify components and configure operations with a special kind of XML files named "deployment descriptors (DD)". Maintaining such XML files is challenging and time-consuming; because (1) the correct configuration semantics is domain-specific but usually vaguely documented, and (2) existing compilers and program analysis tools rarely examine XML files. To help developers ensure the quality of DD, this paper presents a novel approach---Xeditor---that extracts configuration couplings (i.e., frequently co-occurring configurations) from DD, and adopts the coupling rules to validate new or updated files.

In this paper, we present a new self-destructing data system, called retrograde storage. This system can randomly store messages into a storage pool built on frequently colliding hash table (FCHT) as an alternative way of DHT, and each message will be covered promptly after the expiry of validity period. This approach makes the message unrecoverable by multiple-pass Gutmann method and supports general secret sharing or encryption with counting control for personal data privacy. Moreover, we give a fundamental mathematical model of birth-death processes, in which we provide a detailed performance analysis by some theorems, including erasure distribution, recovery probability, secure erasure time, capacity of recycle pool. Experimental results indicated that our system is more efficient and accurate for controlling message self-destruction cycle, and makes it hard or impossible to recover data in a forensic investigation.

The smart contract is an interdisciplinary concept that concerns business, finance, contract law and information technology. Designing and developing a smart contract may require the close cooperation of many experts coming from different fields. How to support such collaborative development is a challenging problem in blockchain-oriented software engineering. This paper proposes SPESC, a specification language for smart contracts, which can define the specification of a smart contract for the purpose of collaborative design. SPESC can specify a smart contract in a similar form to real-world contracts using a natural-language-like grammar, in which the obligations and rights of parties and the transaction rules of cryptocurrencies are clearly defined. The preliminary study results demonstrated that SPESC can be easily learned and understood by both IT and non-IT users and thus has greater potential to facilitate collaborative smart contract development.

Bidirectional model transformation (BX) plays a vital role in Model-Driven Engineering. A major challenge in conventional relational and bidirectionalization-based BX approaches is the ambiguity issue, i.e., the backward transformation may not be uniquely determined by the consistency relation or the forward transformation. A promising solution to the ambiguity issue is to adopt putback-based bidirectional programming, which realizes a BX by specifying the backward transformation. However, existing putback-based approaches do not support multiple conversions of the same node (namely a shared node). Since a model is a graph, shared nodes are very common and inevitable. Consequently, existing putback-based approaches cannot be directly applied to bidirectional model transformation. This paper proposes a novel approach to BX. We define a new model-merging-based BX combinator, which can combine two BXs owning shared nodes into a well behaved composite BX. Afterwards, we propose a putback-based BX language XMU to address the ambiguity issue, which is built on the model-merging-based BX combinator. We present the formal semantics of XMU which can be proven well behaved. Finally, a tool support is also introduced to illustrate the usefulness of our approach.

The bidirectional model transformation (BX) comprises a forward transformation get and a backward transformation put. Given that get may be an information-loss transformation, the behavior of put may be uncertain. An uncertain put produces many valid outputs that fit different application scenarios. This paper proposes an approach to variability management in BX to enable put to generate an output model with several variation points that can be configured to adapt this output for different uses. Firstly, this paper proposes a variability metamodel and management framework, which are used to characterize and configure variation points in a transformation result model. Secondly, this paper extends a BX language to specify a BX with variability. Thirdly, this paper presents a BX engine, which can execute a BX with variability and generate a model that contains variation points. Lastly, an evaluation is presented to show the feasibility and scalability of our approach.

Model-oriented operations, such as model transformation, model query, and model comparison, are the core of Model-Driven Engineering. Their scalability becomes an important issue when they are to be applied in industry. Large-scale models, however, are not widely available, making it hard to test the performance and coverage of those operations without any bias. To do so, one must be able to generate large models, which are syntactically correct, as test inputs efficiently and randomly. This paper proposes a parallel approach to generating large random model, which improves on our previous sequential algorithm. First, the paper identifies the dependencies existing in the process of model generation, which hinders parallelization. Then, the paper proposes a partitioning strategy that is able to turn a sequential generation task into a series of parallelizable subtasks. Experimental results of performance are also presented, which show that the parallel approach proposed can reduce 50% time costs compared to the sequential one in most cases, while the correctness and the randomness of the models generated by this approach are kept.

Unified Modeling Language (UML) activity diagrams are widely used to model concurrent interaction among multiple objects. In this paper, we propose a transformation-based approach to generating scenario-oriented test cases for applications modeled by UML activity diagrams. Using a set of transformation rules, the proposed approach first transforms a UML activity diagram specification into an intermediate representation, from which it then constructs test scenarios with respect to the given concurrency coverage criteria. The approach then finally derives a set of test cases for the constructed test scenarios. The approach resolves the difficulties associated with fork and join concurrency in the UML activity diagram and enables control over the number of the resulting test cases. We further implemented a tool to automate the proposed approach and studied its feasibility and effectiveness using a case study. Experimental results show that the approach can generate test cases on demand to satisfy a given concurrency coverage criterion and can detect up to 76.5% of seeded faults when a weak coverage criterion is used. With the approach, testers can not only schedule the software test process earlier, but can also better allocate the testing resources for testing concurrent applications. Copyright © 2015 John Wiley & Sons, Ltd.

In cloud computing, variability becomes a crucial ability of process-based cloud applications. Existing solutions either focused on modeling variability in the architectural model or tried to support dynamic variability management in implementation. An integrated approach that can inherit the virtues from both categories is expected. The paper aims to fill the gap by proposing a model-driven variability-based service composition approach. We propose VxUML to model the variability in the architecture model. Then, we define a set of model transformation rules to convert VxUML into VxBPEL (an extension to standard BPEL supporting variability at the implementation level). Finally, we implement a prototype tool, and present a case study to demonstrate the feasibility of our approach.

Mode transformation is the key to model-based software engineering. When the model transformation is applied to industrial developments, its scalability becomes an important issue, since the model to be transformed may have a large size. To test the performance of model transformations, this paper proposes a randomized approach to generating large models as test inputs. First, the paper discusses the basic requirements and constraints for performance test input generation of the model transformation. Then, the paper presents our model generation algorithm. It can generate a model having a large size randomly and correctly within a reasonable time, according to the metamodel and user-defined constraints. Finally, an evaluation is also presented. And the result shows that our approach is more suitable for generating performance test inputs compared with existing model generation approaches.

Recently model transformations quickly become large size and complex in structure. It is necessary to apply the modeling technique when developing transformations to manage the complexity. The paper proposes VisTML - a visual modeling language for model transformations. It provides six diagrams, which cover the whole lifecycle of transformation development and enable us to specify a transformation from various views and in different phases, i.e. the goal diagram, the transformation diagram, the rule diagram, the composition diagram, the test diagram, and the deployment diagram. We also provide a tool support and a real case of VisTML to illustrate the feasibility of VisTML. Besides, a comparison of VisTML, UML, and transML is presented at last.

In order to define a graphical modeling language, it is necessary to define the graphical notation of the language in the process of metamodeling. So the defining of the no- tation has become one of the essential functions in meta- modeling tools. This paper proposed the Notation Defini- tion Metamodel (NDM) for metamodeling tools. NDM is used to define the graphical notation. It consists of three parts: basic figures and layouts, location relations and syn- tax bridges. NDM has been implemented in PKU Meta- Model Tool (PkuMMT). The paper made a case study to illustrate the feasibility of NDM. Besides, a comparison between PKU MMT and some metamodeling tools is pre- sented to show the capability and advantages of NDM.