Detecting JavaScript Transpiler Bugs with Grammar-guided Mutation

Many JavaScript programs are written in an event-driven style. In particular, in server-side Node.js applications, operations involving sockets, streams, and files are typically performed in an asynchronous manner, where the execution of listeners is triggered by events. Several types of programming errors are specific to such event-based programs (e.g., unhandled events, and listeners that are registered too late). We present the event-based call graph, a program representation that can be used to detect bugs related to event handling. We have designed and implemented three analyses for constructing event-based call graphs. Our results show that these analyses are capable of detecting problems reported on StackOverflow. Moreover, we show that the number of false positives reported by the analysis on a suite of small Node.js applications is manageable.

JavaScript (JS) is one of the most popular programming languages for developing client-side applications mainly due to allowing the adoption of different programming styles, not having strict syntax rules, and supporting a plethora of frameworks. The flexibility that the language provides may accelerate the development of application, but also pose threats to the quality of the final software product, e.g., introducing Technical Debt (TD). TD reflects the additional cost of software maintenance activities to implement new features, occurring due to poorly developed solutions. Being able to forecast the levels of TD in the future can be extremely valuable in managing TD, since it can contribute to informed decision making when designating future repayments and refactoring budget among a company's projects. Despite the popularity of JS and the undoubtful benefits of accurate TD forecasting, in the literature, there is available only a limited number of tools and methodologies that are able to: (a) forecast TD during software evolution, (b) provide a ground-truth TD quantifications to train forecasting, since TD tools that are available are based on different rulesets and none is recognized as a state-of-the-art solution, (c) take into consideration the language-specific characteristics of JS. As a main contribution for this study, we propose a methodology (along with a supporting tool) that supports the aforementioned goals based on the Backward Stepwise Regression and Auto-Regressive Integrated Moving Average (ARIMA). We evaluate the proposed approach through a case study on 19,636 releases of 105 open-source applications. The results point out that: (a) the proposed model can lead to an accurate prediction of TD, and (b) the Number of appearances of the “new” and “eval” keyword along with the number of “anonymous” and “arrow” functions are among the features of JavaScript language that are related to high levels of TD.

This study aims to analyse how translation experts from the German department of the European Commission’s Directorate-General for Translation (DGT) identify and correct different error categories in neural machine translated texts (NMT) and their post-edited versions (NMTPE). The term translation expert encompasses translator, post-editor as well as revisor. Even though we focus on neural machine-translated segments, translator and post-editor are used synonymously because of the combined workflow using CAT-Tools as well as machine translation. Only the distinction between post-editor, which refers to a DGT translation expert correcting the neural machine translation output, and revisor, which refers to a DGT translation expert correcting the post-edited version of the neural machine translation output, is important and made clear whenever relevant. Using an automatic error annotation tool and the more fine-grained manual error annotation framework to identify characteristic error categories in the DGT texts, a corpus analysis revealed that quality assurance measures by post-editors and revisors of the DGT are most often necessary for lexical errors. More specifically, the corpus analysis showed that, if post-editors correct mistranslations, terminology or stylistic errors in an NMT sentence, revisors are likely to correct the same error type in the same post-edited sentence, suggesting that the DGT experts were being primed by the NMT output. Subsequently, we designed a controlled eye-tracking and key-logging experiment to compare participants’ eye movements for test sentences containing the three identified error categories (mistranslations, terminology or stylistic errors) and for control sentences without errors. We examined the three error types’ effect on early (first fixation durations, first pass durations) and late eye movement measures (e.g., total reading time and regression path durations). Linear mixed-effects regression models predict what kind of behaviour of the DGT experts is associated with the correction of different error types during the post-editing process.

This study concerns one of the processes involved in written verbal production: text revising. Our aim was to experimentally test the specificity of reading for revision as compared to reading for comprehension, and to determine the cognitive cost of initiating and performing critical-reading processes. A two-session experiment was conducted on students who had to perform a comprehension task and a revising task on a text presented in its basic version, or in a version containing either syntax errors or spelling errors. An analysis of the cognitive effort associated with critical-reading and comprehension-reading processes, and of the participants’ comprehension and revising performance, showed that critical reading was more effortful than comprehension reading. It showed also that critical reading was more effortful for the text version with syntax errors than with spelling mistakes. In addition, the working memory span of the readers/revisers had a different impact on effort and performance, depending on the type of errors in the text (spelling or syntax).

In learning and teaching activities, textbook is one of the important elements that play a role in improving the quality of learning in the classroom. Therefore, textbook content analysis also needs to be carried out to avoid errors in the transfer of knowledge to students. This research aims to determine the types of language errors in Arabic textbook for Middle School Grade 2 at Thamavitya Mulniti School of Thailand. This type of research is library research using descriptive methods and a qualitative approach. The results of the analysis of this textbook were that three types of language errors were found, namely 70% of syntax errors, 10% of writing errors and 20% of morphological errors. Based on the results of the analysis, it can be seen that the most common language errors found in this textbook are syntax errors and then morphology errors. Meanwhile, the fewest language errors is writing errors. This research is only limited to analyzing language errors in the aspects of syntax, morphology and writing. It is hoped that further research can explore other linguistic aspects in this textbook. The implication of this research is as information for teachers who want to use this textbook as teaching material for learning Arabic in the classroom. The researcher hopes that this research can become a reference for future researchers who want to raise themes relevant to this research.

Block programming has been suggested as a way of engaging young learners with the foundations of programming and computational thinking in a syntax-free manner. Indeed, syntax errors—which form one of two broad categories of errors in programming, the other one being logic errors—are omitted while block programming. However, this does not mean that errors are omitted at large in such environments. In this exploratory case study of a learning environment for early programming (Kodetu), we explored errors in block programming of middle school students ( N = 123), using log files drawn from a block-based online. Analyzing 1033 failed executions, we found that errors may be driven by either learners’ knowledge and behavior, or by the learning environment design. The rate of error types was not associated with the learners’ and contextual variables examined, with the exception of task complexity (as defined by SOLO taxonomy). Our findings highlight the importance of learning from errors and of learning environment design.

Discourse markers are words and expressions (such as: firstly, then, for example, because, as a result, likewise, in comparison, in contrast) that explicitly state the relational structure of the information in the text, i.e. signalling a sequential relationship between the current message and the previous discourse. Using these markers improves the cohesion and coherence of texts, facilitating reading comprehension. Although often included in tools that support the rhetoric structuring of texts, discourse markers have hardly been explored in writing support tools for learners of a second language. However, learners of a second language, including those at advanced levels, have trouble producing these lexical items, frequently replacing them with items from their native language or with literal translations of items in their own language, which often do not result in proper lexical items in the second language. In addition, students learn a single marker per function and use it repeatedly, producing monotonous texts. With the aim of contributing to reducing these difficulties, this paper presents a lexicon that will be used to support the task of automatically detecting and correcting discourse marker errors. Several heuristics have been evaluated to generate different types of errors. Automatic translation methods were used to semi-automatically compile the lexicon used in these heuristics. Similarity measures were also combined with these heuristics to correct discourse marker errors. The evaluated methods proved to be suitable for the task of identifying some types of discourse marker errors and can potentially identify many others, as long as new lexical inputs are incorporated into them.

Background: In the case of public health emergency scenarios, mortality surveillance done by analyzing medical certificates of cause of death (MCCDs) provides accurate morbidity and mortality data. Precise death certification in the novel coronavirus disease 2019 deaths is critical to understanding the magnitude and advancement of the pandemic. Inaccurate death certificates may cause underreporting or overwhelming reporting of COVID-19 deaths.Methods: The aim of the study was to analyse the MCCDs issued by the institute where the cause of death was attributed to or associated with the COVID-19 infection for certification errors. 729 MCCDs issued in COVID-19 deaths were audited primarily for their formal correctness and completeness and errors, using categories previously reported with some minor modifications. The study did not include analyzing the medical and hospital records of the deceased for the factual correctness of these MCCDs.Results: All types of major and minor certification errors were observed. Incomplete MCCDs were observed in 697 (95.61%) cases. 691 MCCDs (94.8%) were having either major or minor or both types of errors. Abbreviations were used in the MCCDs in 65.29% of cases while improper sequencing of the causes of death was observed in 52.92% of cases. Wrong terminologies like “COVID”, “COVID pneumonia”, “COVID +ve”, and “coronavirus” were used instead of the standard terminology.Conclusions: The lack of completeness and accuracy in writing the causes of death related to COVID-19 indicates a problem faced by the certifying doctors in analyzing them, especially in the early days of the pandemic.

Software Testing is one of the most significant phases within the software development life cycle since software bugs can be costly and traumatic. However, the traditional software testing process is not enough on its own as some undiscovered faults might still exist due to the test cases’ inability to detect all underlying faults. Amidst the various proposed techniques of test suites’ efficiency detection comes mutation testing, one of the most effective approaches as declared by many researchers. Nevertheless, there is not enough research on how well the mutation testing tools adhere to the theory of mutation or how well their mutation operators are performing the tasks they were developed for. This research paper presents an investigative study on two different mutation testing tools for Java programming language, namely PIT and µJava. The study aims to point out the weaknesses and strengths of each tool involved through performing mutation testing on four different open-source Java programs to identify the best mutation tool among them. The study aims to further identify and compare the mutation operators of each tool by calculating the mutation score. That is, the operators’ performance is evaluated with the mutation score, with the presumption that the more prominent the number of killed mutants is, the higher the mutation score, thus the more effective the mutation operator and the affiliated tool.Â

CHAPTER 9 - Errors and Pitfalls

Software refactoring is to improve readability, maintainability and expansibility of software by adjusting its internal structure, whereas the external behaviors of software are not changed. Although software refactoring should not change the external behaviors of software systems, they might make a regression test case obsolete (with syntax and runtime errors) or fail. People have investigated which refactorings had an influence on regression test case. However, how test cases are influenced by refactorings and what kind of errors might be introduced remain unknown. To this end, in this paper, we proposed an approach to analyze refactorings' impact on regression test cases. On one hand, we analyzed why regression test cases failed. On the other hand, we analyzed the influence of refactorings on software interfaces. Based on the analysis, we built up a mapping between refactorings and test case failure. Such a mapping can be used to guide test case repair automation where test cases are made obsolete by refactorings. The approach was evaluated on five open-source applications. Evaluation results suggest that the precision of the approach is greater than 80%.

Traditionally, mutation testing is used as test set generation and/or test evaluation criteria once it is considered a good fault model. This paper uses mutation testing for evaluating an automated static analyzer. Since static analyzers, in general, report a substantial number of false positive warnings, the intention of this study is to define a prioritization approach of static warnings based on their correspondence with mutations. On the other hand, knowing that Mutation Test has a high application cost, another possibility is to try to identify mutations of some specific mutation operators, which an automatic static analyzer is not adequate to detect. Therefore, this information can be used to prioritize the order of incrementally applying mutation operators considering, firstly, those with no correspondence with static warnings. In both cases, contributing to the establishment of incremental strategies on using automatic static analysis or mutation testing or even a combination of them. We used mutation operators as a fault model to evaluate the direct correspondence between mutations and static warnings. The main advantage of using mutation operators is that they generate a large number of programs containing faults of different types, which can be used to decide the ones most probable to be detected by static analyzers. We provide evidences on the correspondence between mutations and some types of static warnings. The results obtained for a set of 19 open-source programs indicate that: 1) static warnings may be prioritized based on their correspondence level with mutations; 2) specific set of mutation operators and their mutations may be prioritized based on their correspondence level with warnings. It is possible to provide an incremental testing strategy aiming at reducing the cost of both static analysis and mutation testing using the correspondence information between these activities/artifacts.

Computational thinking in early childhood education: The impact of programming a tangible robot on developing debugging knowledge

Due to the pandemic or any other tough situations, attending the student laboratory session physically is difficult or even impossible. To overcome this problem, a virtual laboratory can be introduced. In many universities, virtual teaching methodology is not implemented widely. While there are several existing visual programming languages developed for various applications, an open-source visual programming language named Node-RED, which is particularly used for Internet of Things (IoT)-based applications, is taken into consideration in the book chapter. A complete outlook of Node-RED, which can be applied for an IoT-based virtual laboratory, is described. Its simplicity providing many built-in entities makes it possible to evolve innovative platforms with less coding complexity. The configuration, the flow development, the requirements, and the usage of the Node-RED are explained with respect to handling all the various types of errors. A few experimental cloud-based services are implemented on an IoT platform using serial port and message queuing telemetry transport (MQTT) broker service as well as providing live camera capturing feature with artificial-intelligence-based object detection. The results show that real-time IoT sensor data can be efficiently measured and visualized in dashboard and live object detection can be done with good accuracy.

Chinese Spelling Check (CSC) aims to detect and correct spelling errors in Chinese. Most CSC models rely on human-defined confusion sets to narrow the search space, failing to resolve errors outside the confusion set. However, most spelling errors in current benchmark datasets are character pairs in similar pronunciations. Errors in similar shapes and errors which are visually and phonologically irrelevant are not considered. Furthermore, widely-used automatically generated training data in CSC tasks leads to label leakage and unfair comparison between different methods. In this work, we propose a feature (visual and phonological) enhanced siamese BERT to (1) correct spelling errors without using confusion sets; (2) integrate phonological and visual features for CSC by a glyph graph; (3) improve performance for unseen spelling errors. To evaluate CSC methods fairly and comprehensively, we build a large-scale CSC dataset in which the number of samples in different error types is the same. The experimental results show that the proposed approach achieves better performance compared with previous state-of-the-art methods on three benchmark datasets and the new error-type balanced dataset.