Universal Java code execution tracer

Background and Context Data structures and algorithms (DSA) play a central role in programming. However, misconceptions related to DSA, i.e. students’ mental models which differ from the expert thinking, have been studied to a moderate extent. Concept inventories (CI) are validated tests which measure students’ knowledge utilizing misconceptions. CIs enable teachers to tailor their teaching methods and identify areas where students struggle. Objective This systematic literature review investigates what CIs exist on DSA topics and what misconceptions these CIs contain. Method We performed backward and forward snowballing to collect 52 papers discussing DSA & recursion CIs. The scope was finally reduced to nine reports which (i) describe DSA misconceptions and (ii) have conducted at least one pilot test in the CI development process. Misconceptions were extracted from these reports using their explicit definitions or by interpreting CI questions. Findings We identified seven DSA CIs in the final set of nine reports. We have extracted 92 misconceptions or students’ difficulties from these reports and mapped them onto ACM/IEEE-CS/AAAI Computer Science Curricula 2023. Implications Our catalog of 92 DSA misconceptions and difficulties helps instructors gain pedagogical content knowledge and improve learning materials. Future research should investigate misconceptions on DSA subtopics not covered here but present in the curricula recommendation. Reviews and CI development could be extended to the 22 reports of misconceptions finally excluded from this study.

Data Structures and Algorithms (DSA) are one of the main pillars of software development; however, abstractions around them are hard to teach and to be understood by students. The most common approaches adopted by instructors to demonstrate the behavior of DSAs are the use of resources like slides and whiteboard sketches to create program illustrations. This task may be slow and tedious because these illustrations need to be continuously updated to represent new algorithm inputs and modifications. In this paper, we propose Willow, a tool for Program Visualization Simulation (PVS), which supports user interactions to manipulate the generated visualizations. With these manipulations in the visualization, we expect the user to be able to create better examples, resembling Algorithm Visualization Simulation tools (AVS), which are specialized in providing visualizations for specific DSAs. We evaluated our tool through a preliminary qualitative study with teaching assistants from an introductory Computer Science course who all give review lessons to the students. Our preliminary results show that the tool was well accepted by the participants, but we still need more studies to validate the use of the tool in classrooms. With the use of our tool features in the teaching-learning process, we expect that instructors may be able to interactively and more clearly explain DSAs to their students, without the hassle of hours creating slides or drawing by hand messy examples of algorithms.

Data structures and algorithms (DSA) are fundamental concepts introduced in the early stages of any undergraduate computing degree. Many students find DSA concepts challenging to learn, partly due to their abstract nature but also due to issues of low motivation. We examine these and other common difficulties faced by educators teaching DSA, and present a novel solution which combines a game-based learning approach with the use of engaging visualizations of algorithms in 2.5D. Game-based learning and algorithm visualizations are often employed in existing educational tools, but are rarely combined. Our game, DeCode, presents DSA concepts as in-game objects and animations within a 2.5D game-based world alongside traditional game-like mechanics such as progression. Feedback from an initial pilot study (n=51) suggests that students regard DeCode as an enjoyable and effective tool for learning DSA concepts. We also find evidence that DeCode's visualizations help students find efficient solutions to problems that have received prior attention in the literature, such as shifting all of the elements in an array.

Data Structures and Algorithms (DSAAs) are always important for Computer Science (CS) undergraduate students to learn. However, they are becoming more and more difficult to teach, especially when f...

Understanding and debugging of data structures and algorithms (DSA) is one of the most common tasks in computer science. DSA tests have also become a standard threshold that software developers have to cross to "get the job". One major challenge in comprehending and debugging DSA implementations lies in establishing and maintaining mental models of the quintessentially complex and twisted networks of events that make up their dynamic runtime behavior. Despite the high level of difficulty of this crucial task, general purpose tools to help users understand or reason about DSA implementations still have very limited capabilities. In this work we present Dbux-PDG, a dynamic Program Dependency Graph extension for the Dbux omniscient debugger. It captures data and control flow, as well as data dependencies of a program's execution for visualization and user interaction. To deal with the immense complexity of non-trivial programs, it offers multiple layers of summarization, that allow the user to explore either the graph as a whole or in parts, one step at a time, as they see fit. We present our findings from applying Dbux-PDG to 94 diverse algorithms and explore its utility in several case studies. All visual results are made available in an online gallery. Dbux-PDG is open source and one-click installable, making it a powerful, easy-to-use tool prototype for DSA comprehension.Video URL: https://youtu.be/dgXj3VoQJZQ

Learning Data Structures and Algorithms (DSA) can often be noted to be an important challenge, primarily due to the abstract nature of program execution. To address this pedagogical challenge, the current paper presents RunSketch, an interactive educational application that will help with visualizing code in real-time, highlighting syntax, tracking variables, and providing AI-based narration. RunSketch uses code execution to provide feedback on the code to users, and provides explanatory information in the form of written text and spoken output using Google Text to Speech API. Its front-end architecture is based on React.js, D3.js and Monaco Editor, the back-end is written in Python using Flask and uses the sys.settrace() method to trace execution. RunSketch significantly enhances understanding and interaction of learners, due to the combination of visual and audio feedback systems, thus, becoming an important innovation in the sphere of teaching programming.

It is crucial to review and update course materials regularly in higher education. However, in the course evaluation process, it is debatable what a difficult learning topic is. This paper proposes a data mining approach to detect learning topics requiring attention in the improvement process of teaching materials by analyzing the discrepancy between formative and summative assessments. In addition, we propose specific methods involving clustering and noise reduction using the OPTICS algorithm and discrepancy calculation steps. Intensive experiments have been conducted on a dataset collected from accurate assessment results of the data structures and algorithms (DSA) course for IT major students at our university. The experimental results have shown that noise reduction can assist in identifying underperforming and overperforming students. In addition, our proposed method can detect learning topics with a high discrepancy for continuously improving teaching materials, which is essential for question recommendation in adaptive learning systems.

Large language models (LLMs) have shown strong potential across a variety of tasks, but their application in the telecom field remains challenging due to domain complexity, evolving standards, and specialized terminology. Therefore, general-domain LLMs may struggle to provide accurate and reliable outputs in this context, leading to increased hallucinations and reduced utility in telecom operations. To address these limitations, this work introduces KG-RAG—a novel framework that integrates knowledge graphs (KGs) with retrieval-augmented generation (RAG) to enhance LLMs for telecom-specific tasks. In particular, the KG provides a structured representation of domain knowledge derived from telecom standards and technical documents, while RAG enables dynamic retrieval of relevant facts to ground the model’s outputs. Such a combination improves factual accuracy, reduces hallucination, and ensures compliance with telecom specifications. Experimental results across benchmark datasets demonstrate that KG-RAG outperforms both LLM-only and standard RAG baselines, e.g., KG-RAG achieves an average accuracy improvement of 14.3% over RAG and 21.6% over LLM-only models. These results highlight KG-RAG’s effectiveness in producing accurate, reliable, and explainable outputs in complex telecom scenarios.

To leverage modern hardware platforms to their fullest, more and more database systems embrace compilation of query plans to native code. In the research community, there is an ongoing debate about the best way to architect such query compilers. This is perceived to be a difficult task, requiring techniques fundamentally different from traditional interpreted query execution. In this dissertation, we contribute to this discussion by drawing attention to an old but underappreciated idea known as Futamura projections, which fundamentally link interpreters and compilers. Guided by this idea, we demonstrate that efficient query compilation can actually be very simple, using techniques that are no more difficult than writing a query interpreter in a high-level language. We first develop LB2: a high-level query compiler implemented in this style that is competitive with the best compiled query engines both in sequential and parallel execution on the standard TPC-H benchmark. Query engines process a variety of data types and structures including text, spatial, graphs, etc. Several spatial and graph engines are implemented as extensions to relational query engines to leverage optimized memory, storage, and evaluation. Still, the performance of these extensions is often stymied by the interpretive nature of the underlying data management, generic data structures, and the need to execute domain-specific external libraries. On that basis, compiling spatial and graph queries to native code is a desirable avenue to mitigate existing limitations and improve performance. To support compiling spatial queries, we extend the LB2 main-memory query compiler with spatial predicates, indexing structures, and spatial operators. To support compiling graph queries, we extend LB2 with graph data structures and operators. The spatial extension matches the performance of hand-written code and outperforms relational query engines and map-reduce extensions. Similarly, the graph extension matches, and sometimes outperforms, low-level graph engines.

Recently, a high dimensional classification framework has been proposed to introduce spatial and anatomical priors in support vector machine (SVM) optimization scheme for brain image analysis. However, classical SVM has to convert 3D discrete brain images naturally represented by higher-order tensors to one-dimensional vectors in order to meet the input requirements. This traditional method destroys the natural structure and correlation in the original data, and generates high dimensional vectors. In this manuscript, the method is improved by a modified support tensor machine (STM) algorithm to make full use of spatial prior and the inherent information of tensor. The new approach reduces memory requirements and computational complexity significantly, and it is comparably demonstrated by experimental results on classification of Alzheimer patients and elderly controls. Introduction Alzheimer disease (AD) is the most prevalent neurodegenerative dementia in worldwide, and thus prevention and early accurate diagnosis of AD is increasingly crucial. In the last few years, support vector machine (SVM) methods for AD subject classification have become an incredibly active research topic. In the related work, SVM approach, as same as feature selection and extraction, has been taking the specificity of neuroimaging data into account. As an example, a frame work is proposed in [1] to include spatial and anatomical priors into SVM by using regularization operators, and it indicates a flexible way to model various types of proximity. However, for the purpose of satisfying the input requirements of classical SVM, 3D discrete brain images naturally represented by higher-order tensors have to convert to vectors in advance. This conversion breaks the inherent structure and correlation in the original data, and easily produces high dimensional vectors and leads to a poor performance in time complexity and space complexity. In order to improve above method including spatial prior of 3D discrete brain images in SVM, a new method is proposed in this manuscript to maintain the natural structure in the original tensor data and include spatial prior of all frontal slices of the tensors in STM [2]. To illustrate the improvement, we apply the proposed method to classification of 299 subjects, 137 AD patients and 162 cognitively normal (CN) controls, as the same study population in [3]. It can be observed that the proposed method reduces size of memory requested and the time complexity significantly and produces better classification performances. Spatial prior in SVM SVM is a supervised learning algorithm introduced by Vapnik and performs classification by mapping the data into higher dimensional space [4]. Let (xs, ys), s∈1,...,S be a training set of instance-labeled pairs, xs∈Ω, ys∈{-1,1} and Ω is the input space, then SVM optimization problem can be written as:

Probabilistic modeling of lexicalized grammars is difficult because these grammars exploit complicated data structures, such as typed feature structures. This prevents us from applying common methods of probabilistic modeling in which a complete structure is divided into sub-structures under the assumption of statistical independence among sub-structures. For example, part-of-speech tagging of a sentence is decomposed into tagging of each word, and CFG parsing is split into applications of CFG rules. These methods have relied on the structure of the target problem, namely lattices or trees, and cannot be applied to graph structures including typed feature structures. This article proposes the feature forest model as a solution to the problem of probabilistic modeling of complex data structures including typed feature structures. The feature forest model provides a method for probabilistic modeling without the independence assumption when probabilistic events are represented with feature forests. Feature forests are generic data structures that represent ambiguous trees in a packed forest structure. Feature forest models are maximum entropy models defined over feature forests. A dynamic programming algorithm is proposed for maximum entropy estimation without unpacking feature forests. Thus probabilistic modeling of any data structures is possible when they are represented by feature forests. This article also describes methods for representing HPSG syntactic structures and predicate-argument structures with feature forests. Hence, we describe a complete strategy for developing probabilistic models for HPSG parsing. The effectiveness of the proposed methods is empirically evaluated through parsing experiments on the Penn Treebank, and the promise of applicability to parsing of real-world sentences is discussed.

In this paper, we present a neuro-medical imaging system called the Brain Slicer, which allows neuroscientists to construct a three-dimensional digital brain atlas from an array of high-resolution parallel section images and obtain arbitrary oblique section images from the digital atlas. This application is based on a new data structure, the Scalable Hyper-Space File (SHSF). The SHSF is a generalized data structure that can represent a hyperspace of any dimension. The two-dimensional SHSF is a scalable linear quadtree and the three-dimensional SHSF is a scalable linear octree. Unlike the normal linear quadtree and octree, the data structure uses a scalable linear coding scheme. It recursively uses fixed-length linear code to encode the hyperspace, which is efficient in terms of storage space and accessing speed. The structure lends itself well to pipelined parallel operations in constructing the volumetric data set, so that it enjoys excellent performance even though the huge data set imposes heavy disk I/O requirements. The data structure can provide different levels of detail; therefore it can be used in an environment where the bandwidth and computation power is limited, such as the Internet and slow desktop computers. We envision that this methodology can be used in many areas other than neuro-medical imaging.

The general algorithms which are followed to solve the Longest Common Subsequence (LCS) problems have both time complexity and space complexity of O(m * n). To reduce this complexity, two ways are proposed in this work. One is the use of Divide and Conquer approach, and another one is changing the data structure from two-dimensional array to queue. By using these approaches, an algorithm has been developed and implemented for the long length string in this paper. The time complexity after using these approaches becomes a function of logarithm O(n * log(n)) which has been shown with proper explanation and the space complexity after using queue data structure becomes linear O(n).

Various Data Structures have been introduced till date that aim at either to improve them in terms of time or space complexity or they are particularly designed for some special applications. This work aims at developing a new data structure that takes the idea of plotting each digit to another dimension and thereby reducing the access time for keys stored in it. In order to make it practical to implement, a tree-based approach has been used to store it in the memory. The asymptotic time complexity is O(nu) for extracting the keys in sorted order where u is the size of universe. In practical testing, the procedure took much less time to complete as compared to Merge Sort which is the best Comparison based Sorting Technique in terms of worst-case time complexity. This work discusses the concept, implementation and algorithms associated with the data structure. Then it evaluates it against various test scenarios with other sorting techniques.

Matrisler bilgisayar bilimlerinde sıklıkla kullanılan veri yapılarıdır. Üçgensel matris gibi özel matris türleri için programlama dillerinde hazır yapılar bulunmamaktadır. Bir veri yapısı olarak üçgensel matris kullanmak gerekiyorsa programlama dilinden kaynaklanan bu eksiklik nedeniyle bellek ve zaman karmaşıklığı yönünden etkin olmayan yazılımlar kodlanmaktadır. Bu çalışmada üçgensel matris tipindeki yapıların bir boyutlu dizi olarak temsil edilmesinde kullanılan dönüşüm ve ters dönüşüm formülleri elde edilerek programların yer ve zaman karmaşıklığı açısından etkinliğinin arttırılması amaçlanmaktadır.