Program Data Structures Research Articles

A Serious game for programming in higher education

Programming is a highly difficult skill which is a constituent of many undergraduate programmes at Higher Education (HE) level. With the advancement of games technology there is an increasing opportunity for educators to provide innovative assessment tools for students on their courses which are highly immersive and graphically indicative of the times. This could potentially be in a supplementary capacity or to a greater extent inextricably linked to the learning outcomes and assessment outcomes. Notably serious games and Games-Based Learning (GBL) have received high levels of attention from educationalists due to being motivational, novel learning approaches. This paper will outline two empirical studies conducted to develop a game to teach programming at HE level. The first study will gauge the acceptability of a computer game for teaching programming and formulating content integration development requirements. The second study will outline the evaluation of the developed game being placed in a module as a formative assessment tool to assist learners to revise for their formal class test. Study one showed that acceptability of the game was high with 61 participants completing an acceptability/content integration questionnaire. The game was designed to consolidate knowledge on rudimentary and advanced programming concepts, data structures and algorithms. 48 participants evaluated the game in study two with the results generally indicating that they enjoyed playing the game as a revision alternative with 14% of participants rating it as very effective and 51% of participants as effective for allowing them to prepare for their class test. The majority of participants also believed that games could be utilised in a formative and summative assessment capacity on courses for independent study.

SciJava Ops: an improved algorithms framework for Fiji and beyond.

Decades of iteration on scientific imaging hardware and software has yielded an explosion in not only the size, complexity, and heterogeneity of image datasets but also in the tooling used to analyze this data. This wealth of image analysis tools, spanning different programming languages, frameworks, and data structures, is itself a problem for data analysts who must adapt to new technologies and integrate established routines to solve increasingly complex problems. While many "bridge" layers exist to unify pairs of popular tools, there exists a need for a general solution to unify new and existing toolkits. The SciJava Ops library presented here addresses this need through two novel principles. Algorithm implementations are declared as plugins called Ops, providing a uniform interface regardless of the toolkit they came from. Users express their needs declaratively to the Op environment, which can then find and adapt available Ops on demand. By using these principles instead of direct function calls, users can write streamlined workflows while avoiding the translation boilerplate of bridge layers. Developers can easily extend SciJava Ops to introduce new libraries and more efficient, specialized algorithm implementations, even immediately benefitting existing workflows. We provide several use cases showing both user and developer benefits, as well as benchmarking data to quantify the negligible impact on overall analysis performance. We have initially deployed SciJava Ops on the Fiji platform, however it would be suitable for integration with additional analysis platforms in the future.

Replicated Versioned Data Structures for Wide-Area Distributed Systems

In this work, we investigate the integration of replicated versioned data structures and append-only distributed storage systems. Doing so facilitates high availability and scalability while providing developer access to different versions of program data structures across program executions. Modern distributed systems such as the Internet of Things (IoT) often employ multi-tiered (cloud/edge/sensors) architectures consisting of a wide array of heterogeneous devices generating data frequently. Hence system availability is imperative to avoid data loss, while scalability is required for the efficient operation of the system not only within the same tier but across different tiers as well. Our proposed approach replicates, persists, and versions <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">program data structures</i> such as binary search trees and linked lists for use in distributed IoT applications. The versioning and persistence of these structures aid failure recovery and facilitate system debugging from its inception instead of making such considerations an afterthought. Moreover, our experiments suggest versioned data structures can perform better in applications performing high volumes of temporal queries versus traditional methods of persisting data (e.g., in a database). We empirically evaluate the overheads associated with versioning and storage persistence of program data structures, present experimental results for multiple end-to-end applications, and demonstrate the scalability of this approach.

An efficient approach to measure the difficulty degree of practical programming exercises based on student performances

This study examines the generality of easy to hard practice questions in programming subjects. One of the most important contributions is to propose four new formulas for determining the difficulty degree of questions. These formulas aim to describe different aspects of difficulty degree from the learner's perspective instead of the instructor's subjective opinions. Then, we used clustering technique to group the questions into three easy, medium and difficult degrees. The results will be the baseline to consider the generality of the exercise sets according to each topic. The proposed solution is then tested on the data set that includes the results of the two subjects: Programming Fundamentals, Data Structures and Algorithms from Ho Chi Minh City University of Technology. The most important result is to suggest the instructors complete various degrees according to each topic for better evaluating student's performance.

Memory Space Recycling

Many program codes from different application domains process very large amounts of data, making their cache memory behavior critical for high performance. Most of the existing work targeting cache memory hierarchies focus on improving data access patterns, e.g., maximizing sequential accesses to program data structures via code and/or data layout restructuring strategies. Prior work has addressed this data locality optimization problem in the context of both single-core and multi-core systems. Another dimension of optimization, which can be as equally important/beneficial as improving data access pattern is to reduce the data volume (total number of addresses) accessed by the program code. Compared to data access pattern restructuring, this volume minimization problem has relatively taken much less attention. In this work, we focus on this volume minimization problem and address it in both single-core and multi-core execution scenarios. Specifically, we explore the idea of rewriting an application program code to reduce its "memory space footprint". The main idea behind this approach is to reuse/recycle, for a given data element, a memory location that has originally been assigned to another data element, provided that the lifetimes of these two data elements do not overlap with each other. A unique aspect is that it is "distance aware", i.e., in identifying the memory/cache locations to recycle it takes into account the physical distance between the location of the core and the memory/cache location to be recycled. We present a detailed experimental evaluation of our proposed memory space recycling strategy, using five different metrics: memory space consumption, network footprint, data access distance, cache miss rate, and execution time. The experimental results show that our proposed approach brings, respectively, 33.2%, 48.6%, 46.5%, 31.8%, and 27.9% average improvements in these metrics, in the case of single-threaded applications. With the multi-threaded versions of the same applications, the achieved improvements are 39.5%, 55.5%, 53.4%, 26.2%, and 22.2%, in the same order.

Online Judge Systems and Case Teaching Used in Programming Courses

The key to programming courses, including programming languages, data structure, algorithm design and analysis, and so on, is to polish students’ programming skills solving problems. The current programming courses in universities are mainly classroom-teaching models, and students’ skills solving problems by programming can hardly be polished. Polishing students’ programming skills solving problems is implemented by teaching material construction and curriculum construction. In teaching material construction, the book series “Collegiate Programming Contests and Education” focus on polishing students’ programming skills solving problems in a systematic way, based on programming contests’ problems. Experiments, consisting of programming contest problems and their analysis and solutions, are basic units for the book series. The curriculum construction's guiding ideology is programming is a technology. In curriculum construction, first, the case teaching is widely used based on experiments. Students are put into a case of a problem description, apply knowledge that they have learned, think how to solve the problem, and propose the algorithm. And after students design the algorithm solving the problem, they need program and debug to pass all test cases within the time and memory limit. Second, informatization technologies, such as online judge systems, and virtual online contests based on online judge systems, are integrated into courses. Online judge systems are online systems to test programs whether is correct or not in programming practice. These systems can compile and execute programs, and test programs with the input for test data. Online judge systems are the platform on which students polish their programming skills. It has been proved by practice that these works can polish students’ programming skills solving problems efficiently.

Exploiting Arduino Features to Develop Programming Competencies

Developing programming competencies is essential for systems, information science, computer science, and electrical engineering students. Engineering students usually face the complexity of working with programming languages that demand compliance with syntactic and semantic rules, which typically represent a daunting task for novice students. Watching textual messages on the screen only, like the classic &#x201C;hello world,&#x201D; is no longer attractive in the current information society, a missing motivation and possible obstacle to developing programming competencies. Students would like to interact with hardware and appreciate environmental reactions. Arduino board permits developing solutions like that. This article presents the academic experience of first-year students of Ingenier&#x00ED;a de Sistemas e Inform&#x00E1;tica at the Universidad Continental (ISI-UC) of Huancayo, Per&#x00FA;, using the Arduino microcontroller board for the teaching-learning process to develop programming competencies. The results obtained show a positive impact regarding the experience of previous using traditional text-based programming languages. Using Arduino, students create digital circuits and computational electronics competencies, another significant benefit. This experience used an online simulator, and the results obtained permit us to plan future online education strategies for this major. The next step will be the application of Arduino and the online simulator to deepen programming skills, including recursivity, real-time constraints, multitasking features, data structure, data-oriented programming, and object-oriented programming. The primary limitations encountered in this experiment were the students&#x2019; lack of experience with electronics concepts to build circuits and, in some cases, the low internet speeds to assist in the programming process of online education. Realizing simulated experiences in classroom experiences was not a significant challenge for teachers and most students. However, problems could arise when students perform practical experiences using real Arduino boards in traditional classes for the availability requirement of Arduino and other electronic components.

Design and development of CEWES software for complex environment wind engineering simulation

The design and development of the complex environment wind engineering simulation software CEWES was carried out, relying on the National Numerical Wind Tunnel Project (NNW). First, based on the characteristics of the physical problem that the software aims to solve, the requirements for the development of complex environment wind engineering simulation software are proposed, and three main modules of the software will be developed: structured grid flow field solver, unstructured grid flow field solvers modeling module of complex terrain and surface. Subsequently, the appropriate mathematical and physical model and numerical solution algorithm are selected for the flow field solver. The CEWES software uses the finite volume method for discretization with second-order accuracy, solves the RANS equations based on the SIMPLE algorithm, uses the k-ε turbulence model to solve the turbulence, and supports large-scale parallelism calculation. Third, the software design was carried out in accordance with the requirements of the CFD solution process and the modular program, focusing on the program architecture, data structure and subroutine interface design, and coding implementation based on the detailed design. Finally, the CEWES software was tested with typical examples. The test results of the calculation examples show that the software calculation results have good accuracy and large-scale parallel computing capabilities, and are suitable for wind engineering simulations in complex terrain environments.

Expanding the Scope of Statistical Computing: Training Statisticians to Be Software Engineers

Traditionally, statistical computing courses have taught the syntax of a particular programming language or specific statistical computation methods. Since Nolan and Temple Lang’s seminal paper, we have seen a greater emphasis on data wrangling, reproducible research, and visualization. This shift better prepares students for careers working with complex datasets and producing analyses for multiple audiences. But, we argue, statisticians are now often called upon to develop statistical software, not just analyses, such as R packages implementing new analysis methods or machine learning systems integrated into commercial products. This demands different skills. We describe a graduate course that we developed to meet this need by focusing on four themes: programming practices, software design, important algorithms and data structures, and essential tools and methods. Through code review and revision, and a semester-long software project, students practice all the skills of software engineering. The course allows students to expand their understanding of computing as applied to statistical problems while building expertise in the kind of software development that is increasingly the province of the working statistician. We see this as a model for the future evolution of the computing curriculum in statistics and data science.

An interdisciplinary approach to learning programming through the creation of electronic music in the sonic pi audio programming environment

With the development of computer technologies, there is a rapid development of applied music based on computer technology: music for computer games, for advertising, for voicing household and other equipment, music in movies and animations, TV music, and academic music. This indicates the relevance of such an area of use of information technologies as program (algorithmic) sound synthesis, and the need for schoolchildren to familiarize themselves with this promising IT area. The fact that music and mathematics are interconnected has been known since ancient times. Now we can observe the close connection of music and informatics. And not just the processing of music in synthesis programs, but the programmatic creation of music using code. The article shows the relationship of musical art with the art of programming, considers the concept of the Sonic Pi audio programming environment, demonstrates the main features of this environment, language tools for programming algorithms, data structures and musical compositions in Ruby.

Recoverable mutual exclusion

Mutex locks have traditionally been the most common mechanism for protecting shared data structures in concurrent programs. However, the robustness of such locks against process failures has not been studied thoroughly. The vast majority of mutex algorithms are designed around the assumption that processes are reliable, meaning that a process may not fail while executing the lock acquisition and release code, or while inside the critical section. If such a failure does occur, then the liveness properties of a conventional mutex lock may cease to hold until the application or operating system intervenes by cleaning up the internal structure of the lock. For example, a process that is attempting to acquire an otherwise starvation-free mutex may be blocked forever waiting for a failed process to release the critical section. Adding to the difficulty, if the failed process recovers and attempts to acquire the same mutex again without appropriate cleanup, then the mutex may become corrupted to the point where it loses safety, notably the mutual exclusion property. We address this challenge by formalizing the problem of recoverable mutual exclusion, and proposing several solutions that vary both in their assumptions regarding hardware support for synchronization, and in their efficiency. Compared to known solutions, our algorithms are more robust as they do not restrict where or when a process may crash, and provide stricter guarantees in terms of efficiency, which we define in terms of remote memory references.

Half a Century of Software Engineering Education: The CMU Exemplar

From the aspirational title of the 1968 NATO conference, software engineering has evolved to a well-defined engineering discipline with strong educational underpinnings. The supporting educational foundation has grown from a few courses in programming languages and data structures, evolving through structured programming, correctness formalisms, and state machine abstractions to full curricula and degree programs. With this context in mind, the authors discuss the evolution of software engineering education and pedagogy, software engineering principles, and future needs, drawing specifically on their experience at Carnegie Mellon University. Reflecting on the software development profession today, they believe that formal software engineering education is needed at least as much as it was in earlier decades. However, it must address the increasing diversity of the developer community, and it must be an education based on the enduring principles that will last a lifetime. This article is part of a theme issue on software engineering’s 50th anniversary.

What Scalable Programs Need from Transactional Memory

Transactional memory (TM) has been the focus of numerous studies, and it is supported in processors such as the IBM Blue Gene/Q and Intel Haswell. Many studies have used the STAMP benchmark suite to evaluate their designs. However, the speedups obtained for the STAMP benchmarks on all TM systems we know of are quite limited; for example, with 64 threads on the IBM Blue Gene/Q, we observe a median speedup of 1.4X using the Blue Gene/Q hardware transactional memory (HTM), and a median speedup of 4.1X using a software transactional memory (STM). What limits the performance of these benchmarks on TMs? In this paper, we argue that the problem lies with the programming model and data structures used to write them. To make this point, we articulate two principles that we believe must be embodied in any scalable program and argue that STAMP programs violate both of them. By modifying the STAMP programs to satisfy both principles, we produce a new set of programs that we call the Stampede suite. Its median speedup on the Blue Gene/Q is 8.0X when using an STM. The two principles also permit us to simplify the TM design. Using this new STM with the Stampede benchmarks, we obtain a median speedup of 17.7X with 64 threads on the Blue Gene/Q and 13.2X with 32 threads on an Intel Westmere system. These results suggest that HTM and STM designs will benefit if more attention is paid to the division of labor between application programs, systems software, and hardware.

What Scalable Programs Need from Transactional Memory

Transactional memory (TM) has been the focus of numerous studies, and it is supported in processors such as the IBM Blue Gene/Q and Intel Haswell. Many studies have used the STAMP benchmark suite to evaluate their designs. However, the speedups obtained for the STAMP benchmarks on all TM systems we know of are quite limited; for example, with 64 threads on the IBM Blue Gene/Q, we observe a median speedup of 1.4X using the Blue Gene/Q hardware transactional memory (HTM), and a median speedup of 4.1X using a software transactional memory (STM). What limits the performance of these benchmarks on TMs? In this paper, we argue that the problem lies with the programming model and data structures used to write them. To make this point, we articulate two principles that we believe must be embodied in any scalable program and argue that STAMP programs violate both of them. By modifying the STAMP programs to satisfy both principles, we produce a new set of programs that we call the Stampede suite. Its median speedup on the Blue Gene/Q is 8.0X when using an STM. The two principles also permit us to simplify the TM design. Using this new STM with the Stampede benchmarks, we obtain a median speedup of 17.7X with 64 threads on the Blue Gene/Q and 13.2X with 32 threads on an Intel Westmere system. These results suggest that HTM and STM designs will benefit if more attention is paid to the division of labor between application programs, systems software, and hardware.

Automating Live Update for Generic Server Programs

The pressing demand to deploy software updates without stopping running programs has fostered much research on live update systems in the past decades. Prior solutions, however, either make strong assumptions on the nature of the update or require extensive and error-prone manual effort, factors which discourage the adoption of live update. This paper presents <i>Mutable Checkpoint-Restart</i> ( <i>MCR</i> ), a new live update solution for generic (multiprocess and multithreaded) server programs written in C. Compared to prior solutions, MCR can support arbitrary software updates and automate most of the common live update operations. The key idea is to allow the running version to safely reach a quiescent state and then allow the new version to restart as similarly to a fresh program initialization as possible, relying on existing code paths to automatically restore the old program threads and reinitialize a relevant portion of the program data structures. To transfer the remaining data structures, MCR relies on a combination of precise and conservative garbage collection techniques to trace all the global pointers and apply the required state transformations on the fly. Experimental results on popular server programs ( <i>Apache httpd</i> , <i>nginx</i> , <i>OpenSSH</i> and <i>vsftpd</i> ) confirm that our techniques can effectively automate problems previously deemed difficult at the cost of negligible performance overhead (2 percent on average) and moderate memory overhead (3.9 <inline-formula><tex-math notation="LaTeX">$\times$ </tex-math></inline-formula> on average, without optimizations).

Generic Soft-Error Detection and Correction for Concurrent Data Structures

Recent studies indicate that transient memory errors ( soft errors ) have become a relevant source of system failures. This paper presents a generic software-based fault-tolerance mechanism that transparently recovers from memory errors in object-oriented program data structures. The main benefits are the flexibility to choose from an extensible toolbox of easily pluggable error detection and correction schemes, such as Hamming and CRC codes. This is achieved by a combination of aspect-oriented and generative programming techniques. Furthermore, we present a wait-free synchronization algorithm for error detection in data structures that are used concurrently by multiple threads of control. We give a formal correctness proof and show the excellent scalability of our approach in a multiprocessor environment. In a case study, we present our experiences with selectively hardening the eCos operating system and its benchmark suite. We explore the trade-off between resiliency and performance by choosing only the most vulnerable data structures for error recovery. Thereby, the total number of system failures, manifesting as silent data corruptions and crashes, is reduced by 69.14 percent at a negligible runtime overhead of 0.36 percent.

Multipurpose Card Using Rfid Technology

Most often in our daily life we have to carry lot of cards such as credit cards, debit cards and some other special cards for toll system ERP, parking and personal identification purpose. Currently smart card implementations can be seen around the world but they are not unified i.e. each developers uses different programming standards and data structures. The smart card will provide service to the user only within a university campus or an organization. In order to make available such multiple application access using a single card to every individual person we have planned to use RFID technology, which is cost effective. As RFID technology is used in the proposed concept, the programming standards and data structures will be unified. Unlike smart card, the RFID card can be used by every individual person to access different applications. Thus, a person needs not to carry number of cards; he can just carry a single card for different purpose. KeywordsSmart card; not unified: Multiple application access; Single card; RFID technology; Cost effective

Применение объектного отображения XML в обработке данных с повышенными требованиями к целостности

The role of XML document Schema and its mapping to program data structures is discussed, in relation to applications with high data reliability requirements. The actuality of work is defined by the wide application of XML as a data representation format in the tasks of electronic document exchange and popularity of XML Schema as a document integrity control tool. Original package for Python programming language is introduced, suitable for defining XML document Schemas as class hierarchies, which will allow to use the package in software development will allow to substantially reduce the code repetition in serialization and deserialization of XML containers. The results of work are applied to development of specialized software for document exchange.

Automatic induction proofs of data-structures in imperative programs

We consider the problem of automated reasoning about dynamically manipulated data structures. Essential properties are encoded as predicates whose definitions are formalized via user-defined recursive rules. Traditionally, proving relationships between such properties is limited to the unfold-and-match (U+M) paradigm which employs systematic transformation steps of folding/unfolding the rules. A proof, using U+M, succeeds when we find a sequence of transformations that produces a final formula which is obviously provable by simply matching terms. Our contribution here is the addition of the fundamental principle of induction to this automated process. We first show that some proof obligations that are dynamically generated in the process can be used as induction hypotheses in the future, and then we show how to use these hypotheses in an induction step which generates a new proof obligation aside from those obtained by using the fold/unfold operations. While the adding of induction is an obvious need in general, no automated method has managed to include this in a systematic and general way. The main reason for this is the problem of avoiding circular reasoning. We overcome this with a novel checking condition. In summary, our contribution is a proof method which – beyond U+M – performs automatic formula re-writing by treating previously encountered obligations in each proof path as possible induction hypotheses. In the practical evaluation part of this paper, we show how the commonly used technique of using unproven lemmas can be avoided, using realistic benchmarks. This not only removes the current burden of coming up with the appropriate lemmas, but also significantly boosts up the verification process, since lemma applications, coupled with unfolding, often induce a large search space. In the end, our method can automatically reason about a new class of formulas arising from practical program verification.

An interactive SQL relational interface for querying main-memory data structures

Query formalisms and facilities have received significant attention in the past decades resulting in the development of query languages with varying characteristics; many of them resemble sql. Query facilities typically ship as part of database management systems or, sometimes, bundled with programming languages. For applications written in imperative programming languages, database management systems impose an expensive model transformation. In-memory data structures can represent sophisticated relationships in a manner that is efficient in terms of storage and processing overhead, but most general purpose programming languages lack an interpreter and/or an expressive query language for manipulating interactive queries. Issuing interactive ad-hoc queries on program data structures is tough. This work presents a method and an implementation for representing an application's arbitrary imperative programming data model as a queryable relational one. The Pico COllections Query Library (pico ql) uses a domain specific language to define a relational representation of application data structures and an sql interface implementation. Queries are issued interactively and are type safe. We demonstrate our relational representation for objects and the library's usefulness on three large c++ projects. pico ql enhances query expressiveness and boosts productivity compared to querying via traditional programming constructs.