Analyzing the Evolution of Javascript Applications

JavaScript has become one of the most popular programming languages for both client-side and server-side applications. In JavaScript applications, events may be generated, triggered and consumed non-deterministically. Thus, JavaScript applications may suffer from non-deterministic bugs, when events are triggered and consumed in an unexpected order. In this proposal, we aim to characterize and combat non-deterministic bugs in JavaScript applications. Specifically, we first perform a comprehensive study about real-world non-deterministic bugs in server-side JavaScript applications. In order to facilitate bug diagnosis, we further propose approaches to isolate the necessary events that are responsible for the occurrence of a failure. We also plan to design new techniques in detecting non-deterministic bugs in JavaScript applications.

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 has been recognized as one of the most widely used script languages. Optimizations of JavaScript engines on mainstream web browsers enable efficient execution of JavaScript programs on CPUs. However, running JavaScript applications on emerging heterogeneous architectures that feature massively parallel hardware such as GPUs has not been well studied.This paper proposes a framework for flexible mapping of JavaScript onto heterogeneous systems that have both CPUs and GPUs. The framework includes a frontend compiler, a construct library and a runtime system. JavaScript programs written with high-level constructs are compiled to GPU binary code and scheduled to GPUs by the runtime. Experiments show that the proposed framework achieves up to 26.8x speedup executing JavaScript applications on parallel GPUs over a mainstream web browser that runs on CPUs.

JavaScript is single-threaded. As a result, long-lasting computations (not necessarily due to poorly written code) will block the UI thread and make it impossible to add text to text boxes, click buttons, use CSS effects, and, in most browsers, open new tabs until control has returned. As an answer to that problem, HTML5 Web Workers provide background-processing capabilities to web applications and typically run on separate threads so that JavaScript applications using Web Workers can take advantage of multicore CPUs. Separating long-running tasks into Web Workers also avoids the dreaded slow-script warnings, shown in Figure 10-1, that display when JavaScript loops continue for several seconds.KeywordsIncoming MessageMain PageStop WorkerEvent ListenerWindow ObjectThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Aspect-oriented software development (AOSD) is gaining wide attention both in research environments and in industry. Aspect-oriented systems encompass new software engineering abstractions and different complexity dimensions. As a consequence, AOSD poses new problems to empirical software engineering. It requires new assessment frameworks specifically tailored to measure the reusability and maintainability degrees of aspect-oriented systems. This paper presents an assessment framework for AOSD, which is composed of two components: a suite of metrics and a quality model. These components are based on well-known principles and existing metrics in order to avoid the reinvention of well-tested solutions. The proposed framework has been evaluated in the context of two different empirical studies with different characteristics, diverse domains, varying control levels and different complexity degrees. Based on empirical and quantitative analysis, the advantages and drawbacks of the framework components are discussed.

Code clone detection is an active field of study in computer science. Despite its rich history, it lacks focus on web scripting languages. Due to the expansion of web applications and web development amongst developers of varying education and experience levels, they inevitably resort to cloning through out the web. The spread of code clones is further increased by websites like StackOverflow and GitHub. In this paper, we will be focusing on clone detection research done to target clones in JavaScript code and discuss its areas of concern. Also, we will summarize language independent research done and possibility of its application on JavaScript and web applications.

Nowadays, the idea of artificial intelligence for software engineering is an emerging research domain and it has been receiving more and more attention recently. Software Engineering (SE) is a well-established technological paradigm, providing clear guidance and direction on every aspect of software development and maintenance. Artificial Intelligence (AI), contrary to the conventional approach, is an emerging and futuristic concept that reshapes a new era, designing intelligent machines that can accomplish tasks that humans do towards a technological wonderland. In parallel with technological advancements, SE is yet to be considered in adopting the state-of-the-art principle for AI-based methodologies. We realize the importance of facilitating the SE towards AI-based intelligent machines, devising novel techniques and approaches for AI-Oriented Software Engineering (AIOSE). In this study, we thoroughly explore the principle of SE within the AI boundary for ensuring effective development activities throughout the AIOSE development process. We believe that such a compendium study will help with linking AI and SE towards overcoming existing limitations for the betterment of both SE and AI communities.KeywordsSoftware engineeringArtificial IntelligenceAIAIOSEAI-oriented applicationIntelligent system

Unit testing represents a key activity in software development and maintenance. Test suites with high internal quality facilitate maintenance activities, such as code comprehension and regression testing. Several guidelines have been proposed to help developers write good test suites. Unfortunately, such rules are not always followed resulting in the presence of bad test code smells (or simply test smells). Test smells have been defined as poorly designed tests and their presence may negatively affect the maintainability of test suites and production code. Despite the many studies that address code smells in general, until now there has been no empirical evidence regarding test smells (i) distribution in software systems nor (ii) their impact on the maintainability of software systems. This paper fills this gap by presenting two empirical studies. The first study is an exploratory analysis of 18 software systems (two industrial and 16 open source) aimed at analyzing the distribution of test smells in source code. The second study, a controlled experiment involving twenty master students, is aimed at analyzing whether the presence of test smells affects the comprehension of source code during software maintenance. The results show that (i) test smells are widely spread throughout the software systems studied and (ii) most of the test smells have a strong negative impact on the comprehensibility of test suites and production code.

Developing and maintaining large-scale applications has become a daunting task with the rapid evolution of the Android ecosystem. This research examines the application of SOLID (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion) principles in contemporary Android development. By the case study of Meta and an analysis of the application in top tech companies, the present research shares how SOLID principles can achieve better product quality, maintainability, and a positive outcome between your team. The study is based on a mixed-methodology, including qualitative and quantitative, analyzing the source code of 25 enterprise-grade Android applications, in-depth interviews with 50 senior professionals from top-tier technology companies, and code-metrics data for 24 months. We implemented it in Kotlin, taking advantage of the modern Android Jetpack ecosystem. The results of the study demonstrate dramatic increases in all aspects of software development. These include 45% reduction in technical debt, 89% increase in test coverage and 30% reduction in bug rate. A qualitative analysis indicates that teams report increased ease of code maintenance and ramp up of new team members. The research also highlights some of the barriers to applying SOLID: high learning curve, challenges convincing team members to adopt SOLID mindset. Our research contributes (1) a SOLID implementation framework for Android, empirically validated in four case studies. It also includes (2) metrics and tools for measuring adherence to SOLID principles, and (3) recommendations for resolving issues encountered during the implementation of these principles. These results have significant practical implications for mobile software industry practitioners and researchers

For software products, the specifications, the requirements even the variables, the code or the software modules are subject to be labelled with key-terms, or described using attributes or specific values. The purpose of these notations is linked to the semantic of the object labelled, and is used as an indexing form for that specific category. A separation of concerns meta model is proposed here to provide the support of using a unitary type of notation in labelling various kind of resources used in the process of developing software, from requirements and specifications all the way to variables, code or software modules. The use of a standard, unitary notation can have multiple benefits, covering areas like code reusability, reverse engineering, assigning technologies for development, aspect-oriented software development (AOSD), requirements engineering (engineering web applications, grouping requirements by categories, such as: technology, importance, actor, volatility, functionality).

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.

Are Forward Designed or Reverse-Engineered UML diagrams more helpful for code maintenance?: A family of experiments

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.

Distributed work is ubiquitous in modern organizations, as are situations where managers and workers interact remotely. Past research postulates the existence of costs of manager–worker separation, but empirical evidence is scant and inconclusive. Building on the literature on manager–worker separation and distributed work we claim that the effect of manager–worker separation on worker performance varies depending on three factors: task complexity, collocation of the worker with experienced peers, and manager supervisory experience. We investigate our arguments by developing hypotheses in the context of a multisite IT services organization, where we collected data encompassing 13,435 software maintenance tasks executed within a two years period. We find that the hypothesized interaction effects are significant and can give rise to costs of manager–worker separation. However, our results also pinpoint the existence of situations where benefits of manager–worker separation are present, that is, where remote supervision leads to superior worker performance. In practice, our findings suggest that organizations should consider task, work configuration, and manager characteristics when deciding whether workers and managers should be collocated.

Software is created by people for people working in a range of environments and under various conditions. Any aspiration towards sustainability in software engineering will need to take account of the people in the process, their behaviour and the impact of that behaviour. Understanding the cooperative and human aspects of software development is crucial in order to comprehend how methods and tools are used, and thereby improve the creation and maintenance of software. Both researchers and practitioners have recognized the need to investigate these aspects, but the results of such investigations are dispersed in different conferences and communities.