The content in Formal Languages courses is mathematical in nature, and requires students to engage with proofs and algorithms to grasp core concepts. Conventional textbooks on Formal Languages predominantly employ textual explanations, with assignments often entailing manual problem solving. Some educators incorporate tools like JFLAP, which helps students construct models and apply algorithms to enhance interaction with the subject matter. However, students must put considerable effort into reading and solving problems manually to reach comprehension. Drawing inspiration from the Programmed Instruction (PI) teaching methodology, we have developed an innovative eTextbook for Formal Languages that facilitates better understanding of these ideas. The PI approach requires students to read a bit, ideally a sentence or paragraph, and then answer a question or complete an exercise related to that information. Depending on their response, students can progress to subsequent information frames or re-attempt the exercise. Our objective is to present the entirety of a Formal Languages curriculum through the PI approach. To evaluate the pedagogical effectiveness of our new eTextbook, we conducted a survey to ask students for their feedback on their experience with the Programmed Instruction etextbook. We also conducted performance evaluations on two offerings of the Formal Languages course. Students' grades are compared to assess learning gains between visualizations with exercises, and with PI frames. The evaluation shows that the Programmed Instruction ebook improved students' grades in almost all topics covered by the ebook.

Simplifying programming for novices and students is a goal for many computer science instructors over the world and an essential concern for computer science education in general. In this paper we introduce CodeVisions, a static code analyzer and interpreter that provides testing and assessment mechanisms and generates a detailed trace of code execution. It's intended to be used to facilitate creating programming tutoring or coding assessing applications (Such as visualizers and auto-graders) through a variety of supported programming languages and flexibility of restricting code inputs. CodeVisions has a testing mechanism that allows users to write their own tests to validate the dump to their rules instead of manually parse the dump themselves resulting a test report too.

COVID-19 caused universities to switch from traditional face-to-face (F2F) course delivery to completely online in Spring 2020. This transition took place on short notice in the middle of the semester. We present results from surveys of students in two CS courses offered at Virginia Tech. Results indicate differing perceptions in the two courses regarding the usefulness of course components before and after the transition for each course. A logistic regression model indicates that for each course, different course components both before and after the transition significantly affect students' preferences for course modality.

Students often skip through instructional material without paying enough attention to the content, resulting in less understanding. Inspired by the Programmed Instruction (PI) technique, we implemented extensions to an eTextbook system to support instructional slideshows with a large number of interspersed questions. Students must answer a question correctly to pass to the next slide. This completely changes how students interact with the material. Our initial results show a significant increase in students' grades when they used PI for a Formal Languages course.

The material taught in a Formal Languages and Automata (FLA) course is mathematical in nature and requires students to practice proofs and algorithms to understand the content. Traditional FLA textbooks are heavy on prose, and homework typically consists of solving many paper exercises. Instructors often make use of Finite State Machine simulators like the JFLAP package. JFLAP allows students to interactively build models and apply different algorithms to these models, providing both a more interactive and a more visual approach. However, course materials have still traditionally relied largely on prose and hand-graded exercises, limiting both the interaction and the amount of practice. In this paper, we propose an eTextbook with integrated tools (simulators and auto-graded exercises) that allow for greater interactivity and levels of engagement. To evaluate the pedagogical effectiveness of our approach, we conducted performance evaluations across different offerings of an FLA course. Results indicate that students using the integrated eTextbook performed better than did a control group using a traditional textbook approach. Students gave positive feedback regarding the usefulness of the auto-graded exercises for practicing different FLA concepts.

Android app testing is challenging and time-consuming because fully testing all feasible execution paths is difficult. Nowadays apps are usually tested in two ways: human testing or automated testing. Prior work compared different automated tools. However, some fundamental questions are still unexplored, including (1) how automated testing behaves differently from human testing, and (2) whether automated testing can fully or partially substitute human testing.

The material taught in a Formal languages course is mathematical in nature and requires students to practice proofs and algorithms to understand the content. Traditional Formal Languages textbooks are heavy on prose rather than visuals, and homework consists of solving many paper exercises. Some instructors make use of Finite State Machine simulators like JFLAP. JFLAP allows students to build different models and apply algorithms on these models, which improves student interaction with the material. However, students still need to read a significant amount of text without direct and immediate feedback on their understanding. Inspired by the Programmed Instruction (PI) teaching method, we have begun developing a new Formal Languages eText-book capable of conveying these concepts more intuitively (through visualizations) and more interactively (through the use of PI methods). Under PI methods, students read a little, ideally a sentence or a paragraph, and then answer a question related to that information. Based on the question response, students can go further and complete other frames of information or retry to solve the same question. To evaluate the pedagogical effectiveness of our new eTextbook, we will conduct time and performance evaluations across two offerings of a Formal Languages course. We will compare the time spent by students using materials with text and exercises only, with text and visualizations, and with the PI frames to determine levels of students engagement. Students grades will be compared to assess learning gains.

Understanding basic manipulation of object references is a conceptual prerequisite to understanding many data structures, beginning with linked lists and trees. Unfortunately, there is often a gap between introductory programming courses that introduce reference variables and creation of objects, and second-semester programming courses that immediately skip to introducing linked lists. As a consequence, students begin using references extensively during Data Structures and Algorithms courses without enough knowledge about how references work. To fill this gap, we created a tutorial about basic use of references and the manipulation of objects using references. The tutorial, implemented as part of the OpenDSA eTextbook system, focuses on learning through visualizations and interactive exercises. Students work a series of small code-writing exercises, inspired by the JhavePOP system. These exercises use simple program visualization to let students see the result of running their program. Manipulative exercises test student proficiency at reading and understanding small sections of code that use references to link objects. All exercises are automatically assessed, providing immediate feedback. Our evaluation of the tutorial's effectiveness will focus on identifying and correcting student misconceptions. Optional sections of the tutorial introduce the program stack and the dynamic memory heap.