Journal of Computer Languages最新文献

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.

Since linked lists serve as a bridge to understanding more advanced data structures, we believe that it is critical to identify students’ misunderstandings early. We found that students had a good conceptual understanding of how to insert and delete nodes in a singly linked list in C. However, many students continued to struggle with C syntax, pointer manipulation, and memory management needed to correctly implement singly linked lists. Students reported that the abstract nature of pointers, relating linked lists to the real world, and prior knowledge about dynamic arrays contributed the most to their difficulties with linked lists in C.

Context:

Low-code development is a concept whose presence has grown both in academia and the software industry and is discussed alongside others, such as model-driven engineering and domain-specific languages. Usability is an important concept in low-code contexts since users of these tools often lack a background in programming. Grey literature articles have also stated that low-code tools have high usability.

Objective:

This paper examines the current literature about low-code and no-code to discover more about them and their relationship with usability, particularly its quality, which factors are the most relevant, and how users view these tools. This focus on usability aims to provide a different point of view from other works on low-code.

Method:

We performed a systematic literature review based on a formal protocol for this study. The search protocol returned a total of 207 peer-review articles across five databases, which was supplemented with a snowballing process. These were filtered using inclusion and exclusion criteria, resulting in 38 relevant articles that were analysed, synthesised and reported.

Conclusion:

Despite growing interest and a strong enterprise presence in academia, we did not find a formal definition of low-code, although common characteristics have been specified. We found that users have a heightened awareness of usability regarding low-code tools, with some authors performing feasibility studies on their implementations or listing factors that influence the user experience in a given tool. Researchers are considering usability factors unconsciously, and the low-code field would grow if research on usability increased. This paper also suggests a definition for low-code development.

Embedded Systems applications have several limitations, one of these limitations is the memory size. Modern compilers provide optimization sequences that reduce the code size, contributing to solve this memory issue. However, the optimization search space is very large, and the same optimization can be applied several times in the same program. Consequently, there is a need to determine the optimization sequence length. Furthermore, sometimes applying optimizations does not result in a significant speedup gain. In this paper, we present an evaluation of optimization sequence lengths, their impact on the code size reduction and speedup increase using a graph-based model to build optimization sequences. The results indicate that is possible to achieve about 15.1% of code size reduction over O0, and also obtain speedups better than O2 optimization level, while Oz achieves 15.5% of code size reduction but cannot reach the speedup of O2 optimization level.

The context-free grammars extended with regular expressions (RE), known as ECF or EBNF grammars, are commonly used as they often allow for terser language definitions. Yet for such grammars the notion of syntax tree, and consequently of ambiguity, lacks an agreed definition. The simplified tree structures returned by the existing parsing algorithms do not faithfully represent all the ways a sentence is derivable by means of the REs present in the grammar rules. We contribute a precise definition of the regular parts in the structures of the EBNF syntax trees, which is aligned with the tree representations that have been adopted by the recent algorithms for RE matching. For an EBNF rule, the finest representation shows all the RE operators as nodes in the sub-tree, while the flat representation simply appends the string generated by the RE to the nonterminal node. A consequent notion of representation-dependent ambiguity follows. The above representations are incorporated into a Tomita-style parsing algorithm, i.e., a $\text{GLR}\left(1\right)$ parser. To construct such a parser, we follow the positional method of the Berry–Sethi parsers for regular languages. Given an EBNF grammar, our parser-generator produces a parser compliant with the choices expressed by the user about the representation of the syntax trees. We also report the parsing performance, over a few representative sets of languages (benchmarks) for programming and data representation, in comparison with existing parsers for EBNF grammars.

Recent advances in Virtual Reality (VR) technology and the increased availability of VR-equipped devices enable a wide range of consumer-oriented applications. For novice developers, however, creating interactive scenes for VR applications is a complex and cumbersome task that requires high technical knowledge which is often missing. This hinders the potential of enabling novices to create, modify, and execute their own interactive VR scenes. Although recent authoring tools for interactive VR scenes are promising, most of them focus on experts as the target group and neglect the novices with low programming knowledge. To lower the entry barrier, we provide an open-source web-based End-User Development (EUD) tool, called VREUD, that supports the rapid construction and execution of interactive VR scenes. To address the aspect of construction, VREUD enables the specification of the VR scene including interactions and tasks. Furthermore, our tool supports the execution and immersive experience of the created interactive VR scenes on VR head-mounted displays. Based on a user study, we have analyzed the effectiveness, efficiency, and user satisfaction of VREUD which shows promising results to empower novices in creating their interactive VR scenes.

Method naming is a critical factor in program comprehension, affecting software quality. State-of-the-art naming techniques use deep learning to compute the methods’ similarity considering their textual contents. They highly depend on identifiers’ names and do not compute semantical interrelations among methods’ instructions. Source code metrics compute such semantical interrelations. This article proposes using source code metrics to measure semantical and structural cross-project similarities. The metrics constitute features of a KNN model, determining the k-most similar methods to a given method. Experiments with 4000000 Java methods on the proposed model demonstrate improvements in precision and recall of state-of-the-arts with 4.25 and 12.08%.

Live coding – the real-time procedural creation of audiovisual works – suggests opportunities to extend hand-drawn animation; however, existing live coding systems are incompatible with manual animation workflows. Manual input is not a primary datatype in existing live coding languages and live coding tools require using symbolic programming environments. We theorize that by applying direct manipulation to the domain of live coding, we can enable animators to create expressive mappings between hand-drawn animations and audio effects in realtime. We present Megafauna, a sketch-based system for audiovisual performance, informed by interviews with professional animators. Megafauna supports the integrated generation and control of hand-drawn animation and audio sequences by enabling animators to directly sketch mapping functions between animation frames and sound generators. We demonstrate the expressive potential of Megafauna by reproducing animated compositions from procedural and manual domains. We evaluate the opportunities of our approach for live production through an expert review of a performance piece created with Megafauna.

A common frustration with programming Graphical User Interfaces (GUIs) is that features for manipulating structures, such as lists and trees, are limited, inconsistent, buggy, or even missing. Implementing complete and convenient sets of operations for inserting, removing, and reordering elements in such structures can be tedious and difficult: a structure that appears as one collection to the user can be implemented as several different data structures and a web of dependencies between them. Structural modifications require changes both to the GUI’s model and view, and possibly extraneous bookkeeping operations, such as adding and removing event handlers.

This paper introduces a DSL that helps programmers to implement a complete set of operations to structures displayed in GUIs. The programmer specifies structures and relations between elements in the structure. Concretely, the latter are definitions of methods for establishing and unestablishing relations. Operations that manipulate structures are specified as rules that control which relations should hold before and after a rule is applied. From these specifications, our tools generate an easy-to-use API for structure manipulation. We target constraint system-based Web GUIs: the DSL generates JavaScript and relies on dataflow constraint systems for expressing dependencies between elements in GUI structures. Our DSL gives tangible representations with well-defined operations for ad-hoc and incidental GUI structures.