Browsing by Author "Sandoval Alcocer, Juan Pablo"

Now showing 1 - 12 of 12
  • Thumbnail Image
    Item
    An Empirical Study of Mobile Code Offloading in Unpredictable Environments
    (2023) Sanabria Quispe, Pablo; Neyem, Andres; Sandoval Alcocer, Juan Pablo; Fernandez, Blanco Alison
    Mobile code offloading is a well-known technique for enhancing the capabilities of mobile platforms by transparently leveraging the resources to the cloud. Although this technique has been studied for years, little empirical evidence exists to demonstrate its alleged benefits in terms of performance in real-life situations. All studies conducted on this topic have so far been relegated to controlled environments in laboratory settings. As such, there is no evidence of how and how well this technique performs in real-life scenarios, where network unreliability is the norm. In this work, we present the first empirical study of an Android mobile application integrated with a code offloading framework being tested in the wild. We distributed an application that contains a set of benchmarks in APK format and deployed it on a wide gamut of Android devices to which we had no physical access. We carefully detail the methodology and infrastructure we used to monitor the benchmarks’ performance of 18 devices. Overall, our results show that the accuracy of the decision-making engine is heavily affected by a couple of factors, mainly the network diagnosis and connection type. Therefore, determining whether or not it is more convenient to execute a given task in the cloud is a difficult task. We summarize five lessons we learned by performing our experiment that we believe should be considered for future experiments in this area.
  • Thumbnail Image
    Item
    An Eye-Tracking Study on the Use of Split/Unified Code Change Views for Bug Detection
    (2023) Sandoval Alcocer, Juan Pablo; Cossio-Chavalier, Alejandra; Rojas-Stambuk, Tiara; Merino Del Campo, Leonel Alejandro
    Software developers often use comparison tools to identify bugs in source code by comparing two versions of the code. These tools display the code in either a split view or unified manner, yet there is limited understanding of how developers interact with them when analyzing changes in the source code. Consequently, the advantages and disadvantages of each approach are still unknown. We explored the usefulness, limitations, and potential for improvement of split and unified views of GitHub. To do this, we conducted a user study with 12 participants who were tasked with analyzing source code in two commits to detect bugs. We used a within-subjects approach, and the participants were monitored with an eye-tracking device while using the split and unified views. The results of our study showed that participants experienced less visual strain when using the unified view. This implies that a lower effort can facilitate a more thorough analysis of the code, which can often result in the discovery of more bugs. Additionally, we noticed that participants mainly focused on conditionals, class/instance variables, and code changes. Nevertheless, we did not find any statistically significant differences among the variables examined when using split or unified views. The findings of this study are pertinent to both practitioners and researchers. Practitioners can use the results to make informed decisions when selecting a view, while researchers can use them to identify potential areas for improvement in code comparison tools.
  • No Thumbnail Available
    Item
    DGT-AR: Visualizing Code Dependencies in AR
    (2023) Freire-Pozo, Dussan; Céspedes Arancibia, Kevin; Merino Del Campo, Leonel Alejandro; Fernández, Blanco Alison; Neyem, Hugo Andrés; Sandoval Alcocer, Juan Pablo
    Analyzing source code dependencies between components within a program is an essential activity in software development. While various software visualization tools have been proposed to aid in this activity, most are limited to desktop applications. As a result, the potential impact of augmented reality (AR) on improving dependency analysis remains largely unexplored. In this paper, we present DGT-AR, a node-link visualization tool for code dependencies in immersive augmented reality. DG T-AR extends the physical screen space of IDEs to the infinite virtual space. That is, developers neither have to sacrifice screen space nor leave the IDE and use third-party applications. We present the preliminary results of a pilot user study along with four key lessons learned. Additionally, we have made DGT-AR publicly available.
  • Thumbnail Image
    Item
    Exploring the Impact of Generative AI for StandUp Report Recommendations in Software Capstone Project Development
    (2024) Neyem, Hugo Andrés; Sandoval Alcocer, Juan Pablo; Mendoza Rocha, Marcelo Gabriel; Centellas-Claro, Leonardo; González, Luis A.; Paredes Robles, Carlos Daniel
    StandUp Reports play an important role in capstone software engineering courses, facilitating progress tracking, obstacle identification, and team collaboration. However, despite their significance, students often grapple with the challenge of creating StandUp Reports that are clear, concise, and actionable. This paper investigates the impact of the use of generative AI in producing StandUp report recommendations, aiming to assist students in enhancing the quality and effectiveness of their reports. In a semester-long capstone course, 179 students participated in 16 real-world software development projects. They submitted weekly StandUp Reports with the assistance of an AI-powered Slack, which analyzed their initial reports and provided suggestions for enhancing them using both GPT-3.5 and the early access GPT-4 API. After each submitted report, students voluntarily answered a survey about usability and suggestion preference. Furthermore, we conducted a linguistic analysis of the recommendations made by the algorithms to gauge reading ease and comprehension complexity. Our findings indicate that the AI-based recommendation system helped students improve the overall quality of their StandUp Reports throughout the semester. Students expressed a high level of satisfaction with the tool and exhibited a strong willingness to continue using it in the future. The survey reveals that students perceived a slight improvement when using GPT-4 compared to GPT-3.5. Finally, a computational linguistic analysis performed on the recommendations demonstrates that both algorithms significantly improve the alignment between the generated texts and the students' educational level, thereby improving the quality of the original texts.
  • No Thumbnail Available
    Item
    How Do Developers Use the Java Stream API
    (2021) Nostas, Joshua; Sandoval Alcocer, Juan Pablo; Elias Costa, Diego; Bergel, Alexandre
    Java 8 marked a shift in the Java development landscape by introducing functional-like concepts in its stream library. Java developers can now rely on stream pipelines to simplify data processing, reduce verbosity, easily enable parallel processing and increase the expressiveness of their code. While streams have seemingly positive effects in Java development, little is known to what extent Java developers have incorporated streams into their programs and the degree of adoption by the Java community of individual stream's features. This paper presents a replication study on which we analyze the stream usage of 610 Java projects. Our findings show that the Java streams are used mostly by software libraries rather than regular applications. Developers rarely use parallel processing, and when they do so, they only superficially use parallelism features and most of the parallel streams are used on simple for Each operations. The most common used pipelines involve map, filter and collect operations. We carefully describe a number of stream idioms we identified, and detail how we addressed the challenges we faced to complete our study. Our findings will help developers at (i) making better decisions about which features to consider when improving the API and (ii) supporting stream-related IDEs features, such as refactoring.
  • Thumbnail Image
    Item
    Introduction to Special Issue on Visualization Applied to Software Engineering
    (2023) Leger, Paul; Bergel, Alexandre; Sandoval Alcocer, Juan Pablo; Merino, Leonel
    Software visualization is a broad research area whose general goal is to enhance and promote the theory, realization, and evaluation of approaches to visually encode and analyze software systems, including software development practices, evolution, structure, and software runtime behavior. Software visualization is inherently interdisciplinary, drawing on theories and techniques from information visualization and computer graphics and applying these in the software engineering domain. This special issue on software visualization aims to bring together a community of researchers from software engineering, information visualization, computer graphics, human-computer interaction, and data science to discuss theoretical foundations, algorithms, techniques, tools, and applications related to software visualization. The special issue received 17 submissions of which 6 were accepted for publication (i.e., acceptance rate of 35.3%). Amongst the accepted papers, three correspond to extended versions of papers published in the IEEE Working Conference on Software Visualization (VISSOFT) 2021.
  • Thumbnail Image
    Item
    On the use of statistical machine translation for suggesting variable names for decompiled code: The Pharo case
    (2024) Sandoval Alcocer, Juan Pablo; Camacho-Jaimes, Harold; Galindo-Gutierrez, Geraldine; Neyem, Hugo Andrés; Bergel, Alexandre; Ducassee, Stéphane
    Adequately selecting variable names is a difficult activity for practitioners. In 2018, Jaffe et al. proposed the use of statistical machine translation (SMT) to suggest descriptive variable names for decompiled code. A large corpus of decompiled C code was used to train the SMT model. Our paper presents the results of a partial replication of Jaffe’s experiment. We apply the same technique and methodology to a dataset made of code written in the Pharo programming language. We selected Pharo since its syntax is simple – it fits on half of a postcard – and because the optimizations performed by the compiler are limited to method scope. Our results indicate that SMT may recover between 8.9% and 69.88% of the variable names depending on the training set. Our replication concludes that: (i) the accuracy depends on the code similarity between the training and testing sets; (ii) the simplicity of the Pharo syntax and the satisfactory decompiled code alignment have a positive impact on predicting variable names; and (iii) a relatively small code corpus is sufficient to train the SMT model, which shows the applicability of the approach to less popular programming languages. Additionally, to assess SMT’s potential in improving original variable names, ten Pharo developers reviewed 400 SMT name suggestions, with four reviews per variable. Only 15 suggestions (3.75%) were unanimously viewed as improvements, while 45 (11.25%) were perceived as improvements by at least two reviewers, highlighting SMT’s limitations in providing suitable alternatives.
  • Thumbnail Image
    Item
    Software Visualizations to Analyze Memory Consumption: ALiterature Review
    (2022) Fernández, Blanco Alison; Bergel, Alexandre; Sandoval Alcocer, Juan Pablo
    Understanding and optimizing memory usage of software applications is a difficult task, usually involving the analysis of large amounts of memory-related complex data. Over the years, numerous software visualizations have been proposed to help developers analyze the memory usage information of their programs. This article reports a systematic literature review of published works centered on software visualizations for analyzing the memory consumption of programs. We have systematically selected 46 articles and categorized them based on the tasks supported, data collected, visualization techniques, evaluations conducted, and prototype availability. As a result, we introduce a taxonomy based on these five dimensions to identify the main challenges of visualizing memory consumption and opportunities for improvement. Despite the effort to evaluate visualizations, we also find that most articles lack evidence regarding how these visualizations perform in practice. We also highlight that few articles are available for developers willing to adopt a visualization for memory consumption analysis. Additionally, we describe a number of research areas that are worth exploring.
  • No Thumbnail Available
    Item
    Spike – A code editor plugin highlighting fine-grained changes
    (2022) Escobar, Ronald; Sandoval Alcocer, Juan Pablo; Tarner, Hagen; Beck, Fabián; Bergel, Alexandre
    Information about source code changes is important for many software development activities. As such, modern IDEs, including, IntelliJ IDEA and Visual Studio Code, show visual clues within the code editor that highlight lines that have been changed since the last synchronization with the code repository. However, the granularity of the change information is limited to a line level, showing mainly a small colored icon on the left side of the lines that have been added, deleted, or modified. This paper introduces Spike, a source code highlighting plugin that uses the font color to visually encode fine-grained version difference information within the code editor. In contrast to previously mentioned tools, Spike can highlight insertions, deletions, updates, and refactorings all in a same line. Our plugin also enriches the source code with small icons that allow retrieving detailed information about a given code change. We perform an exploratory user study with five professional software engineers. Our results show that our approach is able to assist practitioners with complex comprehension tasks about software history within the code editor.
  • Thumbnail Image
    Item
    TestEvoViz: visualizing genetically-based test coverage evolution
    (2022) Cota Vidaurre, Andreina; Cusi Lopez, Evelyn; Sandoval Alcocer, Juan Pablo; Bergel, Alexandre
    Genetic algorithms are commonly employed to generate unit tests. Automatically generated unit tests are known to be an important asset to identify software defects and define oracles. However, configuring the test generation is a tedious activity for a practitioner due to the inherent difficulty to adequately tuning the generation process. Furthermore, evolution processes are most of the time compared solely using the final results, while discarding all the details of the iterations that are themselves important for an adequate tuning. This paper presents TestEvoViz, a visual technique to introspect genetic algorithm-based test generation processes. TestEvoViz offers the practitioners a visual support to expose the process and decisions made by the generation algorithm. We first present a number of case studies to illustrate the expressiveness of TestEvoViz. We then conducted a user study involving 22 participants including researchers, students and professional software engineers. Participants use our visual approach to analyze, compare and tune test generation algorithm executions. All participants were able to complete the tasks. Our findings show that participants focus more on the visual components that depict information about the test similarity, individuals coverage increments, and the final generation code coverage.
  • Thumbnail Image
    Item
    Towards an AI Knowledge Assistant for Context-aware Learning Experiences in Software Capstone Project Development
    (2024) Neyem, Hugo Andres; González, Luis A.; Mendoza Rocha, Marcelo Gabriel; Sandoval Alcocer, Juan Pablo; Centellas, Leonardo; Paredes, Carlos
    Software assistants have significantly impacted software development for both practitioners and students, particularly in capstone projects. The effectiveness of these tools varies based on their knowledge sources; assistants with localized, domain-specific knowledge may have limitations, while tools like ChatGPT, using broad datasets, might offer recommendations that do not always match the specific objectives of a capstone course. Addressing a gap in current educational technology, this paper introduces an AI Knowledge Assistant specifically designed to overcome the limitations of existing tools by enhancing the quality and relevance of Large Language Models (LLMs). It achieves this through the innovative integration of contextual knowledge from a local “lessons learned” database tailored to the capstone course. We conducted a study with 150 students using the assistant during their capstone course. Integrated into the Kanban project tracking system, the assistant offered recommendations using different strategies: direct searches in the lessons learned database, direct queries to a GPT model, query enrichment with lessons learned before submission to GPT and LLaMa models, and query enhancement with Stack Overflow data before GPT processing. Survey results underscored a strong preference among students for direct LLM queries and those enriched with local repository insights, highlighting the assistant's practical value. Further, our linguistic analysis conclusively demonstrated that texts generated by the LLM closely mirrored the linguistic standards and topical relevance of university course requirements. This alignment not only fosters a deeper understanding of course content but also significantly enhances the material's applicability to real-world scenarios.
  • No Thumbnail Available
    Item
    Visualizing Memory Consumption with Vismep
    (2022) Fernández, Blanco Alison; Bergel, Alexandre; Sandoval Alcocer, Juan Pablo; Queirolo Córdova, Araceli
    Detecting and repairing memory issues is still a challenging task. One reason is that understanding a program's memory usage involves a diverse and related set of dynamic and static aspects. Over the years, multiple tools have been proposed to assist practitioners in these activities. However, detailed information about how a tool helps users when analyzing memory usage is missing. This article introduces Vismep, an interactive visualization prototype to help programmers analyze Python applications' memory usage, and presents an exploratory study to understand the behavior and perception of users when using Vismep. As a result, we reported five information needs when participants analyze memory consumption and how they use Vismep to satisfy these needs. Besides, participants positively perceived Vismep due to their valuable views and high overall usability.