Parse Tree Research Articles

Developing a Graphical Domain-Specific Modeling Language for Efficient Lightweight Block Cipher Schemas Configuration: LWBCLang

The lightweight block cipher is an encryption technique with negligible computational overhead. Despite its advantages, it faces a substantial challenge. Correct handwriting of the script code for the cipher scheme is a challenge for programmers. In this research, we suggest a new graphical domain-specific modeling language to make it easier for both non-technical users and domain specialists to implement lightweight block cipher schemes. The proposed language, called LWBCLang, is a modular and extensible language that offers graphical components for constructing three essential types of inner block cipher structures. Seven different methods of keystream generation and all the tests of the NIST suite with performance analysis are provided. In the context of its meta-model, LWBCLang's abstract and concrete syntaxes are specified. LWBCLang has been implemented as an internal DSML with Python as the host language. The evaluation of LWBCLang is based on qualitative analysis to demonstrate the language's effectiveness and efficiency. Further benefits of this proposed language are evaluated and discussed in depth in this research.

Dual syntax aware graph attention networks with prompt for aspect-based sentiment analysis

Aspect-based sentiment analysis (ABSA) is a challenging task due to the presence of multiple aspect words with different sentiment polarities in a sentence. Recently, pre-trained language models like BERT have been widely used as context encoders in ABSA. Graph neural networks have also been employed to extract syntactic and semantic information from sentence parsing trees, resulting in superior results. However, dependency trees may establish irrelevant dependencies for sentences with irregular syntax and complex structures. Additionally, previous methods have not fully utilized recent developments in pre-trained language models. Therefore, we propose a Dual Syntax aware Graph attention networks with Prompt (DSGP) model to address these issues. Our model utilizes prompt templates to maximize the potential of pre-trained models and masked vector outputs of templates as supplementary aspect feature representations. We also leverage both dependency trees and constituent trees with graph attention networks to extract different types of syntactic information. The dependency tree captures syntactic correlation between words, while the constituent tree provides a high-level formation of the sentence. Finally, the output from the prompt and parsing trees is fused and fed into a standard classifier. Experimental results on four public datasets demonstrate the competitive performance of our model.

Keywords, morpheme parsing and syntactic trees: features for text complexity assessment

Keywords, morpheme parsing and syntactic trees: features for text complexity assessment

A Concrete Syntax Transformation Approach for Software Language Processing

In this paper we present an approach for software language processing tasks such as code generation, reverse-engineering and refactoring, based upon text-to-text (T2T) transformations expressed using the concrete syntax of the source and target software languages. The goal of the approach is to provide simpler and more usable techniques for specifying such tasks, compared to model-to-model (M2M) or model-to-text (M2T) transformation approaches. We evaluate the approach on language processing tasks of domain-specific language (DSL) tool support, software abstraction, model transformation, reverse engineering and program translation, and show that it can be effective for these tasks.

ChatMDG: A discourse parsing graph fusion based approach for multi-party dialogue generation

Comprehending multi-party dialogue generation poses a challenge due to intricate speaker interactions, where multiple participants engage in a dynamic exchange of questions and responses, assuming diverse roles such as speaker, receiver, and observer, with these roles evolving across conversational turns. Most existing research on multi-party dialogue generation only considers semantic information contained in each sentence and does not take into account the dialogue flow information implicit in multi-role interaction, leading to difficulties in accurately understanding the dialogue state in multi-party dialogue. To fill these gaps, we introduce an information fusion based approach for Multi-party Dialogue Generation named ChatMDG, which integrates role interaction into a semantic-enriched graph with context-based embeddings to cooperatively capture both global and local information in multi-party dialogue. Specifically, we proposes a graph-based network to represent the complex role-interaction dialogue structure for discourse parsing and then designs the dialogue flow encoding method to fuse role-interaction information with semantic states effectively. Furthermore, ChatMDG presents interaction strategies to correspondingly generate reactive and proactive utterances based on the fused embeddings, which lead to more dialogue coherence and user engagement. Experimental results show that ChatMDG significantly improves the accuracy of the multi-party response generation task, especially in complex scenarios with multiple interactions.

Establishing interoperability between EMF and MSDKVS: an M3-level-bridge to transform metamodels and models

Many powerful metamodeling platforms enabling model-driven software engineering (MDSE) exist, each with its strengths, weaknesses, functionalities, programming language(s), and developer community. Platform interoperability would enable users to exploit their mutual benefits. Such interoperability would allow the transformation of metamodels and models created in one platform into equivalent metamodels and models in other platforms. Language engineers could then freely choose the metamodeling platform without risking a lock-in effect. Two well-documented and publicly available metamodeling platforms are the eclipse modeling framework (EMF) and the modeling SDK for visual studio (MSDKVS). In this paper, we propose an M3-level-bridge (M3B) that establishes interoperability between EMF and MSDKVS on the abstract syntax level and on the graphical concrete syntax level. To establish such interoperability we (i) compare the two platforms, (ii) present a conceptual mapping between them, and (iii) implement a bidirectional transformation bridge including both the metamodel and model layer. We evaluate our approach by transforming a collection of publicly available metamodels and automatically generated or manually created models thereof. The transformation outcomes are then used to quantitatively and qualitatively evaluate the transformation’s validity, executability, and expressiveness.

Supporting meta-model-based language evolution and rapid prototyping with automated grammar transformation

In model-driven engineering, developing a textual domain-specific language (DSL) involves constructing a meta-model, which defines an underlying abstract syntax, and a grammar, which defines the concrete syntax for the DSL. We consider a scenario in which the meta-model is manually maintained, which is common in various contexts, such as blended modeling, in which several concrete syntaxes co-exist in parallel. Language workbenches such as Xtext support such a scenario, but require the grammar to be manually co-evolved, which is laborious and error-prone. In this paper, we present GrammarTransformer, an approach for transforming generated grammars in the context of meta-model-based language evolution. To reduce the effort for language engineers during rapid prototyping and language evolution, it offers a catalog of configurable grammar transformation rules. Once configured, these rules can be automatically applied and re-applied after future evolution steps, greatly reducing redundant manual effort. In addition, some of the supported transformations can globally change the style of concrete syntax elements, further significantly reducing the effort for manual transformations. The grammar transformation rules were extracted from a comparison of generated and existing, expert-created grammars, based on seven available DSLs. An evaluation based on the seven languages shows GrammarTransformer’s ability to modify Xtext-generated grammars in a way that agrees with manual changes performed by an expert and to support language evolution in an efficient way, with only a minimal need to change existing configurations over time.

Multi-Table Programmable Parser with online flow-level update consistency for satellite networks

Programmable packet parsers in the space data plane, responsible for identifying protocols and extracting keywords on demand, are significant to realize protocol upgrading for satellite networks. Because flow-level update consistency is significant, onboard resources are limited, and space radiation may cause errors in packet parsers, programmable packet parsers with online flow-level update consistency, low complexity, and high reliability are urgently needed. In our previous work, a Multi-Table Programmable Parser (MTPP) [1] is designed for fast configuration and low storage cost by networking configuration and multiple tables. In this paper, we propose a Multi-Table Programmable Parser with Online Flow-Level Update Consistency (MTPP-OFLUC), consisting of five tables and eight models. To guarantee the flow-level update consistency, each table consists of a main table and a backup table. Moreover, to improve the reliability of MTPP-OFLUC, a fault tolerance mechanism is designed. Furthermore, an Online Configuration based on Super Parse Graph Segmentation (OC-SPGS) is proposed to achieve fast configuration with flow-level update consistency. The numerical analysis under typical parse graphs demonstrates that MTPP-OFLUC uses less storage than that of PISA-based parser. Due to backup tables adapted to guarantee the flow-level update consistency, the storage cost of MTPP-OFLUC is only 11.53% more than that of MTPP. Through OC-SPGS, the parsing success ratio of MTPP-OFLUC is up to 66.7% larger than that of MTPP. Finally, a prototype of MTPP-OFLUC is implemented on Xilinx Virtex-7 FPGA. The response time of MTPP-OFLUC and the network is 1.460 us and 4.196 ms, respectively. The size of configuration information is less than that of PISA-based parser. In summary, rapid response and flow-level update consistency are realized by MTPP-OFLUC. Moreover, security risks, user-friendly interfaces, potential capacity of upgrades, and supports for higher data rates still need to be considered in the future works.

Out of step: Code clone detection for mobile apps across different language codebases

Clone detection provides insight about replicated fragments in a code base. With the rise of multi-language code bases, new techniques addressing cross-language code clone detection enable the analysis of polyglot systems. Such techniques have not yet been applied to the mobile apps' domain, which are naturally polyglot. Native mobile app developers must synchronize their code base in at least two different programming languages. App synchronization is a difficult and time-consuming maintenance task, as features can rapidly diverge between platforms, and feature identification must be performed manually. The end goal of this work is to provide an analysis framework to reduce the impact of app synchronization. A first step in this direction consists in a structural algorithm for cross-language clone detection, called Out of Step, exploiting the idea behind enriched concrete syntax trees. Such trees are used as a common intermediate representation built from programming languages' grammars, to detect similarities between app code bases. Our technique finds code similarities with over 80% for the evaluation of language features, where Type 1-3 clones are manually injected for the analysis of both single- and cross-language cases for Kotlin and Dart. We validate the feasibility and correctness of our approach through the evaluation of the main language constructs for Kotlin and Dart. To validate the effectiveness we use a first case study detecting clones between 12 sorting algorithms across Kotlin and Dart, identifying clone similarities with a precision between 67% and 95%. Finally, we use a corpus of 144 mobile apps implemented in Kotlin and Dart, correctly identifying code similarities for the full application logic.

Dependency Structure-Enhanced Graph Attention Networks for Event Detection

Existing models on event detection share three-fold limitations, including (1) insufficient consideration of the structures between dependency relations, (2) limited exploration of the directed-edge semantics, and (3) issues in strengthening the event core arguments. To tackle these problems, we propose a dependency structure-enhanced event detection framework. In addition to the traditional token dependency parsing tree, denoted as TDG, our model considers the dependency edges in it as new nodes and constructs a dependency relation graph (DRG). DRG allows the embedding representations of dependency relations to be updated as nodes rather than edges in a graph neural network. Moreover, the levels of core argument nodes in the two graphs are adjusted by dependency relation types in TDG to enhance their status. Subsequently, the two graphs are further encoded and jointly trained in graph attention networks (GAT). Importantly, we design an interaction strategy of node embedding for the two graphs and refine the attention coefficient computational method to encode the semantic meaning of directed edges. Extensive experiments are conducted to validate the effectiveness of our method, and the results confirm its superiority over the state-of-the-art baselines. Our model outperforms the best benchmark with the F1 score increased by 3.5 and 3.4 percentage points on ACE2005 English and Chinese corpus.

Mechanizing Refinement Types

Practical checkers based on refinement types use the combination of implicit semantic subtyping and parametric polymorphism to simplify the specification and automate the verification of sophisticated properties of programs. However, a formal metatheoretic accounting of the soundness of refinement type systems using this combination has proved elusive. We present λ RF , a core refinement calculus that combines semantic subtyping and parametric polymorphism. We develop a metatheory for this calculus and prove soundness of the type system. Finally, we give two mechanizations of our metatheory. First, we introduce data propositions , a novel feature that enables encoding derivation trees for inductively defined judgments as refined data types, and use them to show that LiquidHaskell’s refinement types can be used for mechanization. Second, we mechanize our results in Coq, which comes with stronger soundness guarantees than LiquidHaskell, thereby laying the foundations for mechanizing the metatheory of LiquidHaskell.

Rational Index of Languages Defined by Grammars with Bounded Dimension of Parse Trees

Rational Index of Languages Defined by Grammars with Bounded Dimension of Parse Trees

Dependency-based BERT for Chinese Event Argument Extraction

Existing event extraction methods independently identify and classify each argument role separately, ignoring the interdependence between different parameter roles. Further, these methods rely on simple vectors to represent word embeddings. By embedding explicit syntactic constraints in the attention mechanism, we address these shortcomings by using dependency syntax to guide the text modeling. Specifically, we use dependency syntax to guide the BERT model for Chinese event argument role extraction, which mainly consists of three stages. First, the self-attention method guided by a dependency syntactic parsing tree is embedded in the Transformer computing framework of the BERT model. In addition to obtaining a deep two-way linguistic representation of a word according to its context information, this method also expresses the long-distance syntactic dependency relationships between words based on context information. Secondly, the designed conditional layer normalization method is applied to the event argument extraction model in order to integrate the semantic information of trigger words into the text, thereby improving the accuracy of the argument role extraction. Lastly, conditional random fields (CRFs) are used to determine the optimal sequence of labels at the sentence level based on the dependence relationships between adjacent labels. According to the experimental results, the constructed model outperforms several strong baselines in the Chinese event argument extraction task on the ACE2005 dataset and the iFLYTEKA.I.2020 dataset.

Pengembangan Parsing PCPATR Sebagai Preservasi Bahasa dan Sastra Banjar

Banjar Mantra is part of the Banjar language and literature in the form of words recited orally by certain people. Mantras are considered to have magical powers for supernatural powers and curses. This study aims to develop a sentence parsing device as a Language and Literature Preservation of Banjar using a sentence parsing application (parse PC-PATR). Parse PC-PATR is a sentence parsing application that will produce a pattern tree to represent the syntactic structure of sentences based on the Banjar language grammars. The problem in this research is that the mantra corpus uses the old genre of Banjarese language and literature. Words in the old genre are currently not widely used in communication by the Banjar people. On the other hand, the absorption of Arabic also presents its own problems. Finally, it is difficult to find the availability of experts who still preserve the Banjar mantra. This research used the ADDIE method with 20 Banjar mantras as test sentences and involved 3 committees of linguists as examiners. The research results showed that the naturalness of the test sentences was as low as 6%. The average parsing tree suitability percentage is 98%. This shows that the sentence parser is acceptable even though the naturalness of the test sentences is only 18% on average.

AGL: Incorporating behavioral aspects into domain-driven design

Domain-driven design (DDD) aims to iteratively develop software around a realistic domain model. Recent research in DDD has been focusing on using annotation-based domain-specific languages (aDSLs) to build the domain model. However, within current approaches behavioral aspects, that are often represented using UML Activity and State machine diagrams, are not explicitly captured in the domain model. The focus of this paper is to introduce a new approach for incorporating behavioral aspects into domain models within the Domain-Driven Design (DDD) approach. The proposed approach involves using a new activity graph language (AGL) as an aDSL for representing behavioral aspects within a unified domain model. This integration of AGL and the previously developed aDSL (DCSLto represent domain models) aims to achieve three important features of DDD: feasibility, productivity, and understandability. Our approach involves building a unified class model in DCSLwithin a domain-driven architecture, which uses the annotation attachment feature of the host programming language (such as Java) to attach AGL activity graphs directly to the activity class of the unified class model, resulting in a unified domain model. In this work, we define the abstract and concrete syntax of AGL. To demonstrate our method, we use a Java framework called jDomainApp and evaluate AGL through a case study to show that it is expressive and practical for real-world software. This paper presents two contributions. Firstly, it proposes a mechanism to include behavioral aspects in a unified domain model by introducing a new aDSL called AGL to represent domain behaviors. Secondly, it presents a unified modeling method for domain-driven software development. Our method significantly extends the state-of-the-art in DDD in two important fronts: constructing a unified domain model for both structural and behavioral aspects of domain models and bridging the gaps between model and code.

A Mongolian-Chinese Neural Machine Translation Model Based on Soft Target Templates and Contextual Knowledge

In recent years, Mongolian-Chinese neural machine translation (MCNMT) technology has made substantial progress. However, the establishment of the Mongolian dataset requires a significant amount of financial and material investment, which has become a major obstacle to the performance of MCNMT. Pre-training and fine-tuning technology have also achieved great success in the field of natural language processing, but how to fully exploit the potential of pre-training language models (PLMs) in MCNMT has become an urgent problem to be solved. Therefore, this paper proposes a novel MCNMT model based on the soft target template and contextual knowledge. Firstly, to learn the grammatical structure of target sentences, a selection-based parsing tree is adopted to generate candidate templates that are used as soft target templates. The template information is merged with the encoder-decoder framework, fully utilizing the templates and source text information to guide the translation process. Secondly, the translation model learns the contextual knowledge of sentences from the BERT pre-training model through the dynamic fusion mechanism and knowledge extraction paradigm, so as to improve the model’s utilization rate of language knowledge. Finally, the translation performance of the proposed model is further improved by integrating contextual knowledge and soft target templates by using a scaling factor. The effectiveness of the modified model is verified by a large number of data experiments, and the calculated BLEU (BiLingual Evaluation Understudy) value is increased by 4.032 points compared with the baseline MCNMT model of Transformers.

Task parse tree: Learning task policy from videos with task-irrelevant components

A good task policy should explicitly interpret the preconditions of actions and the composition structure of task. We aim to automatically learn such a task policy from videos which remains challenging at present. This issue can be further aggravated when task-irrelevant components are involved in videos, such as unoperated objects and small actions. Task-irrelevant objects may introduce disruptive visual relations, and task-irrelevant actions would lead to misleading and even failed task planning. Solving both issues simultaneously is beyond the scope of existing methods. To this end, we propose Task Parse Tree (TPT) as a novel task policy representation, distinguishing task-relevant actions with definite preconditions and clear execution order. The automatic generation of TPT relies on two core designs, where spatio-temporal graph (STG) seizes the vital changes in visual relations of objects and their attributes both spatially and temporally, and conjugate action graph (CAG) models the execution logic of actions in a graph. We collect a dataset of a real-world task, Make Tea, and experiment results on the dataset show that TPT realizes both accurate and interpretable task planning in two different scenarios.

A new versioning approach for collaboration in blended modeling

The complexity of modern software-intensive systems and the need for flexibility in their development process forces developers to collaborate using the most appropriate language(s) for each given task, view and component. Blended modeling is the ability to edit a model through multiple concrete syntaxes simultaneously. To support collaborative blended modeling, we present a variation of operation-based versioning that allows bi-directional propagation of changes between concrete and abstract syntaxes. This allows us to support layout continuity between different versions, and to handle information that is not (yet) available (e.g., layout information) when rendering changes from abstract to concrete syntax. Finally, our approach does not enforce immediate conflict resolution. Rather, different merge options and their consequences can be presented to the users, who may choose to only perform partial conflict resolution, deferring final resolution till later. In this article, we present the general approach and describe salient parts of an implementation.

Extraction of Phrase-based Concepts in Vulnerability Descriptions through Unsupervised Labeling

Software vulnerabilities, once disclosed, can be documented in vulnerability databases, which have great potential to advance vulnerability analysis and security research. People describe the key characteristics of software vulnerabilities in natural language mixed with domain-specific names and concepts. This textual nature poses a significant challenge for the automatic analysis of vulnerability knowledge embedded in text. Automatic extraction of key vulnerability aspects is highly desirable but demands significant effort to manually label data for model training. In this article, we propose unsupervised methods to label and extract important vulnerability concepts in textual vulnerability descriptions (TVDs). We focus on six types of phrase-based vulnerability concepts (vulnerability type, vulnerable component, root cause, attacker type, impact, and attack vector) as they are much more difficult to label and extract than name- or number-based entities (i.e., vendor, product, and version). Our approach is based on a key observation that the same-type of phrases, no matter how they differ in sentence structures and phrase expressions, usually share syntactically similar paths in the sentence parsing trees. Specifically, we present a source-target neural architecture that learns the Part-of-Speech (POS) tagging to identify a token’s functional role within TVDs, where the source neural model is trained to capture common features found in the TVD corpus, and the target model is trained to identify linguistically malformed words specific to the security domain. Our evaluation confirms that the proposed tagger outperforms (4.45%–5.98%) the taggers designed on natural language notions and identifies a broad set of TVDs and natural language contents. Then, based on the key observations, we propose two path representations (absolute paths and relative paths) and use an auto-encoder to encode such syntactic similarities. To address the discrete nature of our paths, we enhance the traditional Variational Auto-encoder (VAE) with Gumble-Max trick for categorical data distribution and thus create a Categorical VAE (CaVAE). In the latent space of absolute and relative paths, we further apply unsupervised clustering techniques to generate clusters of the same-type of concepts. Our evaluation confirms the effectiveness of our CaVAE, which achieves a small (85.85) log-likelihood for encoding path representations and the accuracy (83%–89%) of vulnerability concepts in the resulting clusters. The resulting clusters accurately label six types of vulnerability concepts from a TVD corpus in an unsupervised way. Furthermore, these labeled vulnerability concepts can be mapped back to the corresponding phrases in the original TVDs, which produce labels of six types of vulnerability concepts. The resulting labeled TVDs can be used to train concept extraction models for other TVD corpora. In this work, we present two concept extraction methods (concept classification and sequence labeling model) to demonstrate the utility of the unsupervisedly labeled concepts. Our study shows that models trained with our unsupervisedly labeled vulnerability concepts outperform (3.9%–5.14%) those trained with the two manually labeled TVD datasets from previous work due to the consistent boundary and typing by our unsupervised labeling method.

Parasitic gap patterns and hierarchy preservation in German

AbstractThis paper discusses how German parasitic gap data from various earlier publications illustrate two patterns of systematic grammatical variation in the language, which have not been previously identified as such in the literature. I show how Heck and Himmelreich’s (Heck, Fabian & Anke Himmelreich. 2017. Opaque intervention.Linguistic Inquiry48. 47–97) analysis for one pattern, although not able to currently capture both patterns, can be extended by allowing for variation in the positions targeted by scrambling along with the phrase markers that constitute domains for linearization. The resulting unifying analysis highlights how different grammatical mechanisms can in various ways (both local and global) have the effect of preserving the hierarchical relations involved in multiple movement dependencies.