Journal of Computer Languages最新文献

There is an increasing demand nowadays for low-code development platforms (LCDPs). As they rely heavily on graphical languages rather than writing code, these platforms enable citizen developers to participate in software development. However, creating new LCDPs is very costly, since it requires building support for graphical modelling and its integration with services like model validation, recommendation systems, or code generation. While Model-driven Engineering (MDE) has developed technologies to create these components, most of them are not cloud-based, as required by LCDPs. In particular, a cloud-based graphical workbench capable of providing the scalability required by industrial applications and adequately supporting technological heterogeneity is currently missing.

To fill this gap we introduce Dandelion, a cloud-based graphical language workbench for LCDPs built following an MDE approach. The tool handles model heterogeneity by using a harmonising meta-model to uniformly represent models from diverse technologies, and supports a customisable level of conformance between models and meta-models. Scalability is addressed by persisting models in a distributed, highly flexible database whose infrastructure is designed to conform to the harmonising meta-model, thus favouring model retrieval. Additionally, a customisable scalability component is introduced for lazy model loading.

This paper describes the concepts and principles behind the tool design and reports on an evaluation on large synthetic process mining models, and on domain-specific languages and large industrial models used within the UGROUND company, showing promising results.

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.

A Smart Contract (SC) is a piece of code executed on the blockchain to automatically trigger transactions upon the occurrence of predefined events. Due to the intrinsic features regarding traceability and data immutability, many companies started using blockchain Smart Contracts to perform collaborative processes. Despite their promising features, there is a lack of Smart Contacts management platforms that enable blockchain participants to describe and publish their smart contacts or “search and match” already deployed ones. In this paper, a new Distributed Smart Directory (DSD) where providers can publish their SCs description is proposed. The SCs descriptions include metadata covering functional, and non-functional properties of the SC. Hence, users can find SCs according to their non-functional preferences, needs, and constraints. The proposed DSD is an extension of the ebXML directory. It was fully implemented on-chain. The SCs descriptions are generated based on the Uniform Description language for SC (UDL-SC). The proposed solution is implemented on the Ethereum blockchain. It was then tested and evaluated.

Software design Anti-pattern is the common feedback to a recurring problem that is ineffective and has a high risk of failure. Early prediction of these Anti-patterns helps reduce the design process’s efforts, resources, and costs. In earlier research, static code or Web Service Description Language (WSDL) metrics were used to develop anti-pattern prediction models. These source code metrics are calculated at either file-level or system-level. So, the values of these metrics are frequently dependent on assumptions that are not defined or standardized and might vary depending on the tools available. This study aims to develop a machine learning-based Anti-patterns prediction model using natural language processing techniques for representing the WSDL file as an input. In this research, the four-word embedding methods have been used to process the WSDL file. The processed outputs are used as input to the models trained using thirty-three classifier techniques. This study also uses eight feature selection techniques to remove ineffective features and five data sampling techniques to handle the class imbalance nature of the datasets. The results indicate that the developed models using text metrics perform better than the static code or WSDL metrics. Additionally, the results suggest that selecting features using feature selection and balancing data using sampling techniques helps improve the models’ performance.

In the last few years we have been seeing a drastic change in the way software is developed. Large-scale software projects are being assembled by a flexible composition of many (small) components possibly written in different programming languages and deployed anywhere in the cloud — the so-called microservices-based applications.

The dramatic growth in popularity of microservices-based applications has pushed several companies to apply major refactorings to their software systems. However, this is a challenging task that may take several months or even years.

We propose a methodology to automatically evolve monolithic web applications that use object-relational mapping into microservices-based ones. Our methodology receives the source code and a microservices proposal and refactors the original code to create each microservice. Our methodology creates an API for each method call to classes that are in other services. The database entities are also refactored to be included in the corresponding service. The evaluation performed in 120 applications shows that our tool can successfully refactor about 72% of them. The execution of the unit tests in both versions of the applications yield exactly the same results.

Application Programming Interfaces (APIs) are frequent in software engineering domain texts, such as API references and Stack Overflow. These APIs and the comparison knowledge between them are not only important for solving programming issues (e.g., question answering), but they are also organized into structured knowledge to support many software engineering tasks (e.g., API misuse detection). As a result, extracting API comparison knowledge (API entities and semantic relations) from texts is essential. Existing rule-based and sequence labeling-based approaches must manually enumerate all linguistic patterns or label a large amount of data. Therefore, they involve a significant labor overhead and are exacerbated by morphological and common-word ambiguity. In contrast to matching or labeling API entities and relations, we formulates heterogeneous API extraction and API relation extraction tasks as a sequence-to-sequence generation task. It proposes APICKnow, an API entity-relation joint extraction model based on the large language model. To improve our model’s performance and quick learning ability, we adopt the prompt learning method to stimulate APICKnow to recognize API entities and relations. We systematically evaluate APICKnow on a set of sentences from Stack Overflow. The experimental results show that APICKnow can outperform the state-of-the-art baselines, and APICKnow has a quick learning ability and strong generalization ability.

Programmers typically learn APIs on-the-fly through web examples. Incompatibilities and omissions in copied example code can create barriers for these learners. We present an analysis of example usage barriers programmers faced in a previous study of React.js novices. We show that a small set of errors prevented programmers from using most found code examples. In response, we built REVEAL to detect and repair the common errors we identified in copied code. We describe the formative evaluation of REVEAL and show that REVEAL users were more likely to successfully integrate code examples than participants in the previous study.

Since machine learning became a prominent feature in the modern-day computing landscape, the urge to automate processes has increased. One such process of particular interest has been the automatic generation of websites based on user intention. Though the requirement of such automatic generation is a modern-day need, the quality of the automatic generation still provides a unique set of challenges. As such, to analyze these unique challenges and viable opportunities in automatic website generation, this survey systematically reviews research on the topics of automatic website generation. The analysis initially segments state-of-the-art into three categories based on the dominant strategy used for automatic generation. These strategies are examples-based, mock-up-driven, and artificial intelligence-driven automatic website generation. When considering the example-based strategy, the emphasis is on analyzing how manual design aspects of a professionally developed website are incorporated into generation models and the challenges that arise. Similarly, transformation methods from website visual design into functional GUI code are investigated for the mock-up-driven strategy with a particular reference to the six underlying conversion mechanisms. Finally, artificial intelligence website builders are analyzed based on their ability to build customizable websites to user preferences. Based on this systematic review of 47 research works on the three dominant strategies, this survey outlines unique challenges and future research endeavors that researchers would encounter when developing models that generate websites automatically and provides insights to researchers on selecting a website generation strategy based on user intention appropriately.

Program traces are a widely used representation for explaining the dynamic behavior of programs. They help to make sense of computations and also support the location and elimination of bugs. Unfortunately, program traces can grow quite big very quickly, even for small programs, which compromises their usefulness.

In this paper we present a visual notation for program traces that supports their concise representation. We explain the design decisions of the notation and compare it in detail with several alternatives. An important part of the trace representation is its flexibility and adaptability, which allows users to transform traces by applying filters that capture common abstractions for trace representations.

We also present an evaluation of the trace notation and filters on a set of standard examples. The results show that our representation can reduce the overall size of traces by at least 79%, which suggests that our notation is an effective improvement over the use of plain traces in the explanation of dynamic program behavior.