Journal of Computer Languages最新文献

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.

Constructing languages and tools for modeling is an intellectual effort that addresses challenges related to linguistic theory. It requires a high level of creativity and understanding between software engineers and language and domain experts. It is important to consider the context of language application, or the main goal of the work, at the beginning of the language construction process. A new language is not created instantaneously, but rather through a process of iteratively refining the definition of its elements in interaction with the real-world context in which it will be applied. From a pragmatic standpoint, the best way to ensure the correctness of a language’s semantics is to verify it using a reference implementation, although different approaches may be used to describe the semantics of the language. In this paper, we share our experience in developing new and extending the existing functionalities of tools for visual domain-specific modeling to simplify reference implementation. We demonstrate how the code generator language, with minor extensions, can be used for it. Visual modeling tools in MDSD and DSM pay more attention to the graphical representation of objects, and less to relations, roles, and properties. In our platform, objects, roles, and relations are all derived from the same base class, which allows us to distinguish between fifteen different model representation types, ranging from view on the model topology to complex 3D views.

Partial redundancy elimination is a well-known optimization in compilers that eliminates the recomputation of equivalent expressions appearing on a path in a program. Morel and Renvoise, in their seminal paper, showed that it is a powerful optimization that subsumes two traditional optimizations, i.e., Common Subexpression Elimination and Loop Invariant Code Motion. Morel and Renvoise’s algorithm is not computationally optimal because partially redundant computations may remain even after the optimization. Later, Knoop et al. came up with an algorithm that is computationally and lifetime optimal. The algorithm by Knoop et al. takes four unidirectional data flow analyses to perform the transformation. Here, we propose a new algorithm for partial redundancy elimination, both computationally and lifetime optimal. The proposed algorithm is more efficient than other best-known algorithms since it takes only three unidirectional data flow analyses. We demonstrate the efficiency of the proposed algorithm by implementing it using the LLVM Compiler Infrastructure and comparing the time taken by the algorithm with other selected best-known algorithms. The proposed algorithm reported here is based on lexically equivalent expressions. However, we believe that the ideas in the proposed algorithm can find their use in the value-based approach.

Studies and evaluations of 3D graph aesthetics beyond the desktop currently remain sparse, despite recent advancements and applications with the emergence of Immersive Analytics. This paper explores curvature aesthetics for the edges within a 3D graph visualisation and presents preliminary implementations to a Lombardi-inspired rendering for an edge. Additionally, we evaluate three approaches to curvature through two studies to compare against straight-lines as a baseline. The two studies focused on observing user preference and performance when navigating a curved graph without and with topological-based tasks in Virtual Reality (VR). We found that curved edges without specified orientations tended to perform worse in performance and preference compared to Lombardi-inspired implementations of edges. Pupillary response and the participant’s approaches to navigation were also observed to be indicative of the edge’s respective performance for topological-based tasks.

Because of their level of abstraction, Domain-Specific Languages (DSLs) enable building applications that ease software implementation. In the context of web applications, we can find a lot of technologies and programming languages for server-side applications that provide fast, robust, and flexible solutions, whereas those for client-side applications are limited, and mostly restricted to directly use JavaScript, HTML5, CSS3, JSON and XML. This article presents a novel approach to creating DSL-based web applications using JSON grammar (JSON-DSL) for both, the server and client side. The approach includes an evaluation engine, a programming model and an integrated web development environment that support it. The evaluation engine allows the execution of the elements created with the programming model. For its part, the programming model allows the definition and specification of JSON-DSLs, the implementation of JavaScript components, the use of JavaScript templates provided by the engine, the use of link connectors to heterogeneous information sources, and the integration with other widgets, web components and JavaScript frameworks. To validate the strength and capacity of our approach, we have developed four case studies that use the integrated web development environment to apply the programming model and check the results within the evaluation engine.

We present a novel approach for resolving numerical program sketches under Boolean and quantitative objectives. The input is a program sketch, which represents a partial program with missing numerical parameters (holes). The aim is to automatically synthesize values for the parameters, such that the resulting complete program satisfies: a Boolean (qualitative) specification given in the form of assertions; and a quantitative specification that estimates the number of execution steps to termination and which the synthesizer is expected to optimize.

To address the above quantitative sketching problem, we encode a program sketch as a program family (a.k.a. Software Product Line) and use the specifically designed lifted analysis algorithms based on abstract interpretation for efficiently analyzing program families with numerical features. The elements of the lifted analysis domain are decision trees, in which decision nodes are labeled with linear constraints defined over numerical features and leaf nodes belong to an existing single-program analysis domain. First, we transform a program sketch into a program family, such that numerical holes correspond to numerical features and all possible sketch realizations correspond to variants in the program family. Then, we use a combination of forward (numerical) and backward (quantitative termination) lifted analysis of program families to find the variants (family members) that satisfy all assertions, and moreover are optimal with respect to the given quantitative objective. Such obtained variants represent the “correct & optimal” realizations of the given program sketch.

We present a prototype implementation of our approach within the FamilySketcher tool for resolving C sketches with numerical data types. We have evaluated our approach on a set of numerical benchmarks, and experimental results confirm the effectiveness of our approach. In some cases, our approach provides speedups against the well-known sketching tool Sketch and resolves some numerical benchmarks that Sketch cannot handle.