Characterizing and taming non-deterministic bugs in Javascript applications

Software evolution analysis can shed light on various aspects of software development and maintenance. Up to date, there is little empirical evidence on the evolution of JavaScript (JS) applications in terms of maintainability and changeability, even though JavaScript is among the most popular scripting languages for front-end web applications, including IoT applications. In this study, we investigate JS applications’ quality and changeability trends over time by examining the relevant Laws of Lehman. We analyzed over 7,500 releases of JS applications and reached some interesting conclusions. The results show that JS applications continuously change and grow, there are no clear signs of quality degradation while the complexity remains the same over time, despite the fact that the understandability of the code deteriorates.

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.

JavaScript is the de facto programming language for the Web. It is used to implement mail clients, office applications, or IDEs, that can weight hundreds of thousands of lines of code. The language itself is prototype based, but to master the complexity of their application, practitioners commonly rely on informal class abstractions. This practice has never been the target of empirical research in JavaScript. Yet, understanding it is key to adequately tuning programming environments and structure libraries such that they are accessible to programmers. In this paper we report on a large and in-depth study to understand how class emulation is employed in JavaScript applications. We propose a strategy to statically detect class-based abstractions in the source code of JavaScript systems. We used this strategy in a dataset of 50 popular JavaScript applications available from GitHub. We found four types of JavaScript software: class-free (systems that do not make any usage of classes), class-aware (systems that use classes, but marginally), class-friendly (systems that make a relevant usage of classes), and class-oriented (systems that have most of their data structures implemented as classes). The systems in these categories represent, respectively, 26%, 36%, 30%, and 8% of the systems we studied.

During last years, the number and cleverness of attacks against Web related applications are steadily growing as Web services become more popular. In this paper, we propose relevant classification features for detecting Web attacks targeting either server-side or client-side applications. Four kinds of features are provided: Request general features, Request content features, Response features and Request history features. Experimental studies carried on real1 and simulated htt p traffic including normal data and several attacks show the efficiency of our feature set in detecting Web related attacks.

Python has emerged as one of the most popular programming languages, extensively utilized in domains such as machine learning, data analysis, and web applications. Python’s dynamic nature and extensive usage make it an attractive candidate for dynamic program analysis. However, unlike for other popular languages, there currently is no comprehensive benchmark suite of executable Python projects, which hinders the development of dynamic analyses. This work addresses this gap by presenting DyPyBench, the first benchmark of Python projects that is large-scale, diverse, ready-to-run (i.e., with fully configured and prepared test suites), and ready-to-analyze (by integrating with the DynaPyt dynamic analysis framework). The benchmark encompasses 50 popular open-source projects from various application domains, with a total of 681k lines of Python code, and 30k test cases. DyPyBench enables various applications in testing and dynamic analysis, of which we explore three in this work: (i) Gathering dynamic call graphs and empirically comparing them to statically computed call graphs, which exposes and quantifies limitations of existing call graph construction techniques for Python. (ii) Using DyPyBench to build a training data set for LExecutor, a neural model that learns to predict values that otherwise would be missing at runtime. (iii) Using dynamically gathered execution traces to mine API usage specifications, which establishes a baseline for future work on specification mining for Python. We envision DyPyBench to provide a basis for other dynamic analyses and for studying the runtime behavior of Python code.

JavaScript is one of the most popular programming languages. However, its dynamic nature poses several challenges to automated testing techniques. In this paper, we propose an approach and open-source tool support to enable white-box testing of JavaScript applications using Search-Based Software Testing (SBST) techniques. We provide an automated approach to collect search-based heuristics like the common Branch Distance and to enable Testability Transformations . To empirically evaluate our results, we integrated our technique into the EvoMaster test generation tool, and carried out analyses on the automated system testing of RESTful and GraphQL APIs. Experiments on eight Web APIs running on NodeJS show that our technique leads to significantly better results than existing black-box and grey-box testing tools, in terms of code coverage and fault detection.

Static analyzers have become increasingly popular both as developer tools and as subjects of empirical studies. Whereas static analysis tools exist for disparate programming languages, the bulk of the empirical research has focused on the popular Java programming language. In this paper, we investigate to what extent some known results about using static analyzers for Java change when considering C#-another popular object-oriented language. To this end, we combine two replications of previous Java studies. First, we study which static analysis tools are most widely used among C# developers, and which warnings are more commonly reported by these tools on open-source C# projects. Second, we develop and empirically evaluate EagleRepair: a technique to automatically fix code in response to static analysis warnings; this is a replication of our previous work for Java [20]. Our replication indicates, among other things, that 1) static code analysis is fairly popular among C# developers too; 2) Re-Sharper is the most widely used static analyzer for C#; 3) several static analysis rules are commonly violated in both Java and C# projects; 4) automatically generating fixes to static code analysis warnings with good precision is feasible in C#. The EagleRepair tool developed for this research is available as open source.

Background: Drones, also known as Unmanned Aerial Vehicles (UAVs), have been incorporated into current applications, shifting from military to general-purpose usage. The proliferation of hobbyist drones, such as the Parrot AR Drone 2.0, highlights the need for straightforward control systems, particularly considering the enormous number of smartphone users worldwide. Objective: This article aims to illustrate the usage of JavaScript, a high-level programming language, for mobile connectivity to the Parrot AR Drone 2.0, making it more accessible to a broader audience. Methods: Using the AR-drone package on the Node.js platform, a server-side application in Express.js was created. This program converts HTTP GET queries from a mobile app into drone-actionable instructions. This change enables a mobile device to control the drone's operations, such as takeoff, landing, and movement. Results: With this system in place, the drone successfully navigated an indoor obstacle course, demonstrating its suitability for complicated navigational tasks. The method streamlines drone operations, improving the user experience. Conclusion: JavaScript can act as a bridge between drone technology and smartphone interfaces. This integration democratizes drone control and heralds breakthroughs in the confluence of IoT and drone technology. It underscores the need to address real-time processing and security issues in future research.

The emergence of Unified Modeling Language (UML) as a standard for modeling systems has encouraged the use of automated software tools that facilitate the development process from analysis through coding. The UML state machine diagram is used for modeling the dynamic aspects of systems and includes many concepts that are not present in most popular programming languages, like Java or C++. There exists a gap between high level modeling language and a programming language. This paper proposes an approach to narrow the gap between multiple UML models and an implemented system. The narrowing of gap is achieved by generating compact and efficient Java code directly from UML state machine having sequential and concurrent substates. The code generation is achieved by creating a mapping between UML behavior and the Java programming language. Our model can work as a basis for automatic code generation for object-oriented systems.

The object of research in the article are the tools and capabilities of the C# programming language for the implementation of cybersecurity analysis software in local computer networks and computer-integrated systems. The relevance of the study is due to the importance of information security of computer and computer-integrated systems in government, military-industrial complex, private business etc., and due to the importance of training cybersecurity professionals in higher education to consider teaching examples in popular programming languages. The goal of the work is to research the possibilities of the C# programming language for the development of software that analyzes cybersecurity in local computer networks and computer-integrated systems. The tasks to be solved are: to develop software for scanning network device ports in computer networks and computer-integrated systems for information security audit, using tools and libraries of the C# programming language, to research the benefits and possibilities of using this programming language for this task. Research methods: theory of computer networks, object-oriented programming, theory of algorithms and data structures, theory of software testing. Conclusions. In this paper the possibilities and advantages of the C# programming language for developing cybersecurity analysis software for computer and computer-integrated systems were explored. In the course of work software that analyzes information security in local computer networks and computer-integrated systems was developed. This software can be used for educational purposes in learning the C# programming language and cybersecurity of computer systems. The developed software has the potential to be further improved and applied in various fields to test the cybersecurity of local computer networks and computer-integrated technologies.

The latest rankings of computer language popularity once again list C as the most popular programming language [1]. As a computer scientist that has written a lot of C code over the years, I must admit that makes me smile. While I don't write code much anymore, I like writing code, and I like writing it in C. Apparently so do a lot of other people. However, C was also the most popular programming language 25 years ago which is one indication that, in the field of software development, not much has changed. Are software developers unwilling to accept new paradigms or are the new paradigms proposed to-date simply unacceptable? This talk discusses what has and hasn't changed in the area of software development, how change (or the lack of it) relates to application security, and concludes with some thoughts on possible directions for the future.

The object-oriented theory has been widely used in software design and development and Java programming language is a popular object-oriented programming language for computer science related majors in higher education. With the huge demand for intelligent manufacturing employees in the work market, more and more universities have listed Java programming language in their curriculum for non-CS undergraduates. However, learning object-oriented programming languages, such as Java, is tough even for CS students. This paper presents how to improve non-CS undergraduate students’ learning outcomes of java language by adopting industry standard professional integrated development tool Eclipse and interactive visual educational tool BlueJ. Our Java programming language course is an alternative 8-week course including 16 h lecture and 16 h lab. Forty-seven junior students from mechanical engineering major were divided into two groups, 23 in the control group (CG) and 24 in the experimental group (EG). Students in both groups used Eclipse to write and run programs during the course while BlueJ was adopted to demonstrate the object-oriented concepts during the fifth and sixth weeks only for students in the EG. A pre-test, which was taken by students from both groups, shows no statistical differences in programming knowledge between the two groups. Results from the post-test at the end of the sixth week show students in EG achieved better performance than students in CG. Results of the survey for the EG reveal that students thought BlueJ was helpful for mastering the concepts of object-oriented programming.KeywordsJava programmingLearning outputHigher educationInteractiveVisualBlueJEclipse

In this paper we measure the speed of several popular and recent programming languages performing the most usual operators in the canonical evolutionary algorithm, mutation and crossover, as well as an usual fitness function, OneMax. These three operations are representative of the kind of the ones performed in binary chromosomes. Our main objectives are, first, to create programs in programming languages that use the fastest available implementation. Second, to find out the differences in speeds for the different languages. Third, to find out whether the usual assumptions about the speed of languages really holds. And, finally, to find if the assumed order of speed in languages used in evolutionary algorithms holds true for all kinds of operations. In order to do that, we use available implementations or perform our own, concluding that the evolutionary algorithm scenario is more complex than usually assumed and finding out some surprising winners and losers among the languages tested.

This book provides an introduction to R programming and a summary of financial mathematics. It is not always easy for graduate students to grasp an overview of the theory of finance in an abstract form. For newcomers to the finance industry, it is not always obvious how to apply the abstract theory to the real financial data they encounter. Introducing finance theory alongside numerical applications makes it easier to grasp the subject. Popular programming languages like C++, which are used in many financial applications are meant for general-purpose requirements. They are good for implementing large-scale distributed systems for simultaneously valuing many financial contracts, but they are not as suitable for small-scale ad-hoc analysis or exploration of financial data. The R programming language overcomes this problem. R can be used for numerical applications including statistical analysis, time series analysis, numerical methods for pricing financial contracts, etc. This book provides an overview of financial mathematics with numerous examples numerically illustrated using the R programming language.

With the growing usage and migration of interactive applications and systems into today’s environment, the significance of the graphical user interfaces (GUIs) increases as they act as the gates into using systems efficiently. Therefore, extensive efforts are spent to enhance the usability of the GUIs. However, most of the works focus on testing the functional properties of applications’ GUIs rather than nonfunctional features such as performance. For this reason, it is worthwhile to assess the performance of various GUI components at runtime. In this paper, the most popular programming languages used to create GUI based applications namely, Java and C# were compared experimentally to evaluate their performance in terms of the creation and manipulation of GUI components/controls. The experimental results of this study, which is based on 32 testing scenarios, showed that Java outperformed C# in all test scenarios. This might be because of the “HotSpot” performance engine that Java uses. This study is useful for developers to get insights into the performance of different GUI components provided by different programming languages. Also, it helps them to choose the right programming language for their GUI based applications hence enhance the overall applications’ performance and user satisfaction.