Prior research has explored the impact of various demographic and psychological factors in introductory computer science courses (CS1), but there remains a gap in understanding how course engagement patterns relate to students' performance and how these behaviors are influenced by demographic characteristics. This study investigates the relationships between student characteristics, course behaviors, and performance in a CS1 course taught using a flipped classroom model. We analyzed data from 410 engineering students, examining factors including gender, prior programming experience (PPE), grade point average (GPA), and learning self-efficacy (LSE). The study focused on four key course behaviors and attitudes: engagement with pre-class recorded lectures, self-reported class attendance, perceived availability of support, and perceived quality of in-class activities, exploring how these related to exam performance and student characteristics. Analysis indicated significant positive correlations between exam performance and three factors: students' engagement with pre-class recorded lectures, perceived availability of support, and perceived quality of in-class activities. Self-reported class attendance did not relate to exam scores. Female students reported significantly higher engagement with pre-class recorded lectures compared to male students, but lower perceptions of available support. Students with higher GPAs reported lower engagement with pre-class lectures, yet indicated higher perceptions of available support and found in-class activities more helpful. These findings highlight important behavioral and perceptual differences in how students engage with CS1 flipped classrooms. Understanding these patterns could enhance learning environments that better support all students, particularly those who may feel less included in computing education.

With the increasing interest and enrollment in programming courses, educators must discover innovative and inclusive teaching methods to effectively cater to diverse learner needs and varying levels of prior knowledge. Introductory programming courses (CS1) can prove arduous for novices and insufficiently stimulating for those with experience, creating an educational dilemma. Striking a balance between students' expectations and engagement becomes challenging for educators, especially given the expanding pre-higher education CS exposure.

As developments in the field of artificial intelligence (AI) continue to rapidly advance its possible applications, it becomes increasingly crucial for those developing AI systems to understand how receptive the general public will be to their work. The overarching goal of this research is to understand human decision-making (HDM) and human perspectives on algorithmic decision-making based on varied payoffs and outcomes. We conducted a pair of surveys, where the participants were asked about their understanding of AI, as well as their thoughts about the application of AI in the context of an autonomous vehicle placed in an ethically challenging situation. Our analysis focuses on participants' responses to two questions characterized by experimental variations, with additional variation in the consequences presented in those same questions between the two surveys. In total, we collected 284 responses from these surveys administered to engineering students of an introductory programming course for two consecutive semesters in 2022. We qualitatively analyzed the data for individual questions using an inductive approach and identified major themes related to the question asked. From this analysis, found that engineering students' perspectives on an ethically complex scenario were greatly impacted by the controlled variance in consequences, and have developed a framework for tracing their decision-making to their decisions and reasoning. Offering valuable insight about how students reason when it comes to ethics to educators in charge of working on developing engineering ethics curricula.

Within the context of computing education, we refer to outcome expectancy as students' self-estimated performance in a learning environment. We believe this construct has the potential to serve as a proxy for a broad range of motivational constructs capable of influencing students' engagement and persistence in a course. While substantial prior research has delved into other motivational factors like students' self-efficacy, there remains a need for further exploration into the nuances of students' intrinsic belief constructs in relation to their learning behavior, engagement, and performance. This paper studies the impact of factors like GPA, self-efficacy, and other identified constructs on students' outcome expectancy. We also study the group-based differences in students' performance based on outcome expectancy. For this purpose, we analyzed the data of four hundred and ten engineering students enrolled in an introductory programming course (CS1). An exploratory factor analysis of surveyed questions was performed, identifying factors linked to students' self-efficacy, attitude toward learning, and perceptions about programming. We found that students' outcome expectancy significantly differed based on each of these identified factors and GPA. Furthermore, we also found that students' performance in the course significantly differed based on their outcome expectancy. We believe that such an analysis will provide CS educators with a better grounding to understand the underlying belief constructs that influence students' participation, persistence, and performance.

Designing interactive virtual learning environments with effective and engaging design elements is crucial in enhancing learners' motivation, engagement, and learning outcomes. By prioritizing a positive user experience that curates cognitive load, interactions within virtual learning environments may effectively promote voluntary and formative engagement. This analysis focuses on investigating the affordances of having an opportunity to immediately reattempt an incorrectly answered question and additionally have access to video solutions on students' voluntary engagement with mastery learning activities. These mastery learning activities were provided in the form of quizzes through a virtual learning environment, YANTRA EDU. This application was developed to facilitate mastery learning, where learners have the opportunity to engage with the sequential practice of various concepts in an introductory programming (CS1) course.

As enrollments in CS1 courses continue to rise, it has become essential for CS educators to support students with varying learning needs and prior programming experiences. Many experts have pointed to the use of mastery-based learning (MBL), which allows students to develop proficiency by engaging in formative practice problems at their own pace. However, less is known about the characteristics of students who use and benefit from such an approach. CS educators need strong evidence for whether formative practice helps to increase aggregate learning outcomes, especially among students who could gain the most from MBL. In this paper, we are interested in exploring the characteristics of students who engage with formative learning opportunities. We analyze data from 118 students enrolled in a CS1 course who were provided with weekly optional practice quizzes that contained multiple-choice and free-response questions. We used logistic regression to analyze who actually attempted these optional quizzes and found that while gender was not significant, students who do not have prior programming experience (PPE) were more likely to use optional practice than those with PPE. We also conducted a nonparametric two-sample analysis and found that students without PPE engage with optional practice questions to a higher level than students with PPE. Our findings explore the factors that may underpin students' agency and their academic behavior and performance. These results can inform educators on how to scaffold students' learning trajectories by accounting for expected group-based behavioral patterns while utilizing MBL in large CS1 courses.

As the effectiveness of algorithms to make decisions improves and as the use of algorithms in domains, which can have a significant impact in determining one's life prospects increases, it is important to understand undergraduate students' perceptions of algorithmic decision making and reasoning behind that perception. We conducted a study to understand engineering students' perception about algorithmic decision making in two different scenarios using a trolley problem at the end of an introductory programming course. The motivation to conduct this study was to gain insights on how they reason about the ethical use of algorithms. Data of eighty-two undergraduate engineering students was analyzed to not only understand their decisions in two different contexts but also their qualitative reasoning behind their decisions. This paper presents a thematic analysis of these decisions and how they differed in the two contexts. Further, classification of their reasoning into different known philosophical frameworks is discussed, which helps in understanding the major underpinnings of these decisions. We believe that the results of this study can help educators understand how students reason about algorithms which may influence how 'ethics' as a topic is integrated in computer science courses, especially in introductory programming courses.

A vital part of any good strategy for most imperfect-information games is making predictions about the information that is unavailable. For example, in card games like Poker and Gin Rummy, predicting the kinds of cards the opponent is holding is necessary for playing well. Specifically, it is useful for agents to be able to map the partial game states that are made available to them to the probabilities of each of the possible complete game states, given that they are playing against other rational player(s). Finding this relationship, however, is difficult, as it requires knowledge of how a rational player would play, which is the problem this relationship is being used to solve. In this paper, we attempt to find this relationship in the context of the card game Gin Rummy, though instead of predicting the complete game state, we focus on what is most useful to a player: the opponent's hand. We do this by using heuristic utility functions to create an agent that approximates how a rational player would play, and then using the resulting game data to train a Deep Neural Network mapping known information to predictions about the opponent's hand. This model is used to improve the existing agent and, in turn, to produce more data to create better models.

This poster presents an analysis of students' quiz and homework submission times in a flipped introductory programming course (CS1) using MATLAB. A total of 145 engineering students were divided into three sections where every week they were expected to watch the prerecorded content videos and complete a quiz before the class on Monday. During the class, students practiced short programming problems while after the class students were expected to submit a homework assignment by the end of the week. We studied their quiz and homework submission times to gauge and categorize their behavior. Four major categories of submission time clusters were analyzed based on when the weekly quizzes and homeworks were due. We found that students who submitted the quizzes and homeworks 24 hours prior to the submission deadline had significantly higher exam scores as compared to students who submitted during the last 24 hours. Additionally, we found that this difference was only significant for students who did not have prior programming experience. This indicates that early submission of assignments can help students who do not have prior programming experience in improving their overall course performance.

Previous research in K-5 CS education has focused on improving students' engagement in programming using visual block-based environments like Scratch. However, little is known about how elementary school students' reason about programs. We define computational reasoning as the ability to read, write, trace and debug programs and predict program behavior. Recently, computing education researchers have become interested in exploring how elementary school students build their computational reasoning abilities. This poster presents results from a study which analyzed the role of explicit instruction in the form of 'laws of computation' in cultivating elementary school (4th and 5th graders) students' ability to reason about programs using Microsoft Kodu Game Lab. We used pretests to record students' default models of reasoning about programs and then used posttests to measure the effectiveness of intervention by noting students' reasoning responses on a similar program. Our findings indicate that by default students reason sequentially about program execution which can be incorrect in situations like parallel rule execution. We also found that the use of explicit instruction in the form of 'laws' is helpful for students to refine their understanding of program execution and to improve their reasoning ability.

This working group asserts that Program Comprehension (PC) plays a critical part in the writing process. For example, this abstract is written from a basic draft that we have edited and revised until it clearly presents our idea. Similarly, a program is written in an incremental manner, with each step being tested, debugged and extended until the program achieves its goal. Novice programmers should develop their program comprehension as they learn to code, so that they are able to read and reason about code while they are writing it. To foster such competencies our group has identified two main goals: (1) to collect and define learning activities that explicitly cover key components of program comprehension and (2) to define possible learning trajectories that will guide teachers using those learning activities in their CS0/CS1 or K-12 courses.

Over the last decade, CS Education researchers have developed different curricula, resources, and strategies to foster computer science learning in K-12 education. However, there is a lack of research about how elementary school students develop the ability to reason about programs. Reasoning about programs consists of a student's ability to read, write, debug, trace, and predict program behavior. This paper presents results from a think-aloud study of fourth and fifth grade students learning to program in Kodu. The goal of this study was to track students' understanding of how Kodu interprets and executes rules of a program. To understand students' reasoning of program execution, we explicitly taught them the Laws of Kodu computation which govern the decision making and execution process of Kodu rules. We collected students' responses on pre- and post-assessments, and we conducted think-aloud interviews with students where students explained their answers to assessment questions. We found that explicitly teaching students how Kodu rules are interpreted significantly improved their ability to understand the execution of programs and to explain program behavior. The results of this study provide insight into how elementary school students reason about simple programs, and how this ability can be scaffolded.

Over the past five years, there has been a major push to develop the computational thinking skills of K-12 students. Tools such as Scratch, Alice, and Kodu have been developed to engage students in learning to program through the creation of computational artifacts (e.g., games, animations, and stories). However, less is known about how elementary and middle school children reason about program behavior. Such skills are useful for reading and adapting others programs, locating possible sources of bugs, and predicting program behavior given code snippets (i.e., mental simulation). The goal of this poster is to measure and track the development of students' ability to reason about programs using Teague & Lister's Neo-Piagetian classification of novice programmers: Sensorimotor, Preoperational Thinkers, and Concrete Operational Thinkers. We operationalize Teague and Lister's category descriptions by creating a criterion for each category. This classification has helped us characterize students' mastery of strategies for reasoning about the lawful behavior of programs using a Kodu curriculum. In particular, this categorization was used to differentiate students' reasoning styles using data from two studies having 20 and 19 students each. We found strong consistency in the results across both studies. Through analysis and categorization of student responses, most students fall into the preoperational thinker category. Within this category, we found a diversity of mastery patterns that help us understand where students face challenges in reasoning about programs.

Researchers and educators have designed curricula and resources for introductory programming environments such as Scratch, App Inventor, and Kodu to foster computational thinking in K-12. This paper is an empirical study of the effectiveness and usefulness of tiles and flashcards developed for Microsoft Kodu Game Lab to support students in learning how to program and develop games. In particular, we investigated the impact of physical manipulatives on 3rd -- 5th grade students' ability to understand, recognize, construct, and use game programming design patterns. We found that the students who used physical manipulatives performed well in rule construction, whereas the students who engaged more with the rule editor of the programming environment had better mental simulation of the rules and understanding of the concepts.

Reading, tracing, and explaining the behavior of code are strongly correlated with the ability to write code effectively. To investigate program understanding in young children, we introduced two groups of third graders to Microsoft's Kodu Game Lab; the second group was also given four semantic "Laws of Kodu" to better scaffold their reasoning and discourage some common misconceptions. Explicitly teaching semantics proved helpful with one type of misconception but not with others. During each session, students were asked to predict the behavior of short Kodu programs. We found different styles of student reasoning (analytical and analogical) that may correspond to distinct neo-Piagetian stages of development as described by Teague and Lister (2014). Kodu reasoning problems appear to be a promising tool for assessing computational thinking in young programmers.

Mental simulation is an important skill for program understanding and prediction of program behavior. Assessing students' ability to mentally simulate program execution can be challenging in graphical programming environments and on paper-based assessments. This poster presents the iterative design and refinement process for assessing students' ability to mentally simulate and predict code behavior using a novel introductory computational thinking curriculum for Microsoft's Kodu Game Lab. We present an analysis of question prompts and student responses from data collected from three rising 3rd - 6th graders where the curriculum was implemented. Analysis of student responses suggest that this type of question can be used to identify misconceptions and misinterpretation of instructions. Finally, we present recommendations for question prompt design to foster better student simulation of program execution.

This paper introduces reasoning about lawful behavior as an important computational thinking skill and provides examples from a novel introductory programming curriculum using Microsoft's Kodu Game Lab. We present an analysis of assessment data showing that rising 5th and 6th graders can understand the lawfulness of Kodu programs. We also discuss some misconceptions students may develop about Kodu, their causes, and potential remedies.

A secure software demands effective techniques for vulnerability detection during its development cycle. The practice of detecting security flaws before the deployment phase eliminates the risks that vulnerabilities may impose for the company. Static analysis and dynamic analysis techniques offer two complimentary approaches for checking vulnerabilities. Static analysis involves the scanning of source code or binary eliminating the need of executing it. This approach is fast and has no run time overhead. However, static analysis are quite imprecise and generate huge false positives and false negatives. On the other hand, dynamic analysis involves the running of the software. The problem of false positives and negatives is less in case of dynamic analysis because they analyze by running the test cases. But this approach requires large number of test cases to ensure a certain confidence level in detecting security bugs. This paper describes a methodology which integrates the two approaches in a complimentary manner. It adopts the strengths of the two and eliminates their weaknesses. We are currently dealing with buffer overflow vulnerability with pointer aliasing. However the idea can be extended to other vulnerabilities also for e.g memory related errors, race conditions(time of check to time to use vulnerability), dangling pointer vulnerability, integer errors etc

Detecting security bugs during the development cycle of a software is extremely difficult as effective testing approaches for such bugs do not exist. Applications are often deployed without being tested for security vulnerabilities even though the application domain demands highly secure software. Hence there is a need to develop systems which can monitor such applications for security violations and take immediate actions if any violation occurs. In this paper we describe an approach for monitoring the security health of a software system. Our methodology involves an agent based approach which communicates with the health monitoring system running as an independent process. We make this agent a part of the application (binary) and modify the binary at appropriate locations to transfer the control to the agent attached. The agent sends critical information regarding the execution to the monitoring system. The monitoring system analyzes the data and takes suitable actions. Currently our system monitors the following security bugsuffer overflow, race conditions (time of check to time to use vulnerability), random number vulnerability and can be extended for other vulnerabilities also

This paper considers the problem of selecting a set of parameter values from a given parameter space, in order to perform rate-distortion optimization in the context of audio compression. Due to interdependencies between parameters, separate optimization of parameter values is inherently suboptimal, yet a straightforward brute-force joint search involves prohibitive computational complexity. This work proposes a new method for joint rate-distortion optimization, while accounting for interparameter dependencies. The optimal solution is achieved, at significantly reduced complexity as compared to a brute-force search, by employing a Viterbi search over a trellis. Two objective distortion metrics are specifically considered: the average, and the maximum noise-to-mask ratio. Subjective (AB/MOS) and objective (average/maximum noise-to-mask ratio) tests demonstrate considerable gains at low bit rates of 16 kbps per channel for a 44.1-kHz sampled audio signal using the proposed approach.

We propose two quantization techniques for improving the bit-rate scalability of compression systems that optimize a weighted squared error (WSE) distortion metric. We show that quantization of the base-layer reconstruction error using entropy-coded scalar quantizers is suboptimal for the WSE metric. By considering the compandor representation of the quantizer, we demonstrate that asymptotic (high resolution) optimal scalability in the operational rate-distortion sense is achievable by quantizing the reconstruction error in the compandor's companded domain. We then fundamentally extend this work to the low-rate case by the use of enhancement-layer quantization which is conditional on the base-layer information. In the practically important case that the source is well modeled as a Laplacian process, we show that such conditional coding is implementable by only two distinct switchable quantizers. Conditional coding leads to substantial improvement over the companded scalable quantization scheme introduced in the first part, which itself significantly outperforms standard techniques. Simulation results are presented for synthetic memoryless Laplacian sources with mu-law companding, and for real-world audio signals in conjunction with MPEG AAC. Using the objective noise-mask ratio (NMR) metric, the proposed approaches were found to result in bit-rate savings of a factor of 2 to 3 when implemented within the scalable MPEG AAC. Moreover, the four-layer scalable coder consisting of 16-kb/s layers achieves performance close to that of the 64-kb/s nonscalable coder on the standard test database of 44.1-kHz audio

The standard scalable coding of stereophonic audio suffers from significant performance loss because of (1) poor prediction gain at the enhancement-layer and (2) direct requantization of the reconstruction error, which is suboptimal for the noise-mask ratio (NMR) criterion. To mitigate such performance loss, this paper proposes an integrated approach which employs two complementary techniques, namely, the estimation theoretic (ET) predictor and the conditional enhancement-layer quantizer (CELQ). The ET predictor has been shown to combine information from various sources for efficient enhancement-layer prediction, while CELQ efficiently handles scalable quantization to minimize NMR. We demonstrate that the proposed combined approach can achieve major performance gains in terms of bit rate reduction and reconstruction quality enhancement. For example, the proposed 2/spl times/16 kbit/s two layer coder achieves considerably improved reconstruction quality compared to that of the conventional 4/spl times/16 kbit/s four layer coder, despite expending only 50% of the standard scalable coder bit rate.

We propose an efficient enhancement-layer quantizer which considerably improves the bit rate scalability of the multi-layer Advanced Audio Coder (AAC). The scheme exploits the statistical dependence of the enhancement-layer signal on the base-layer quantization parameters. It fundamentally extends the prior work on compander domain scalability, which was shown to be asymptotically optimal for entropy coded uniform scalar quantizer, to systems with non-uniform base-layer quantization. We show that an enhancement-layer quantization which is conditional on the base-layer information can be efficiently implemented within the AAC framework to achieve major performance gains. Moreover, in the important case that the source is well modeled as Laplacian, we show that the optimal conditional quantizer is implementable by only two distinct switchable quantizers depending on whether or not the base-layer quantizer employed the “zero dead-zone.” Hence, major savings in bit rate are recouped at virtually no additional computational cost. For example, the proposed four layer scalable coder consisting of 16kbps layers achieves performance close to a 60kbps non-scalable coder on the standard test database of 44.1kHz audio.

We derive an asymptotically optimal multi-layer coding scheme for entropy-coded scalar quantizers (SQ) that minimizes the weighted mean-squared error (WMSE). The optimal entropy-coded SQ is non-uniform in the case of WMSE. The conventional multi-layer coder quantizes the base-layer reconstruction error at the enhancement-layer, and is sub-optimal for the WMSE criterion. We consider the compander representation of the quantizer, and propose to implement scalability in the compressed domain. We show that such a multi-layer coding system achieves the operational rate-distortion bound given by the non-scalable entropy-coded SQ, at the limit of high resolution. Simulation results for a synthetic memoryless Laplace source with /spl mu/-law companding are presented for various values of layer rates. Substantial gains are also achieved on the "real-world" sources of audio signals, when the optimal multi-layer approach is applied to a two-layer scalable MPEG-4 Advanced Audio Coder.

We address the issue of optimizing side information rate for efficient audio coding. In coders such as the MPEG-4 AAC, at rates around 16 kbps to 48 kbps, the side information rate forms a substantial part of the total rate. The parameter search procedure in the verification model optimizes each band separately and results in poor performance at low rates. We propose to jointly optimize the encoding parameter of all the bands. The near-optimal solution using a brute force search has drastic computational complexity. However, the same solution is obtained at a much reduced complexity using a Viterbi search through a trellis. The search procedure is developed and evaluated for two objective measures, the average and the maximum noise-mask ratio. For both the measures, the trellis-based search yields substantially better solutions. In particular, trellis-based optimization of maximum noise-mask ratio greatly improves the performance of AAC at low rates. The resulting bit stream is standard-compatible, and the additional complexity due to the proposed optimization is only incurred at the encoder.