Teaching programming-intensive courses in a virtual space brings new opportunities for active learning and student engagement. This poster presents our experience in designing an online active learning environment in two programming-intensive courses delivered in a hybrid modality with all students alternating between online synchronous and face-to-face class meetings. We present the course strategies that support online active learning and a comparison of students' engagement between online and Face-to-Face (F2F) group activities. We highlight our active learning strategies including dynamic breakout room configuration and online group programming collaboration. A survey study is used to investigate how students' engagement in group activities varies between the two settings. Preliminary results show that the students' responses are highly positive over two engagement factors, the values of activities and their personal effort, with no statistically significant difference found between the two modalities.

The COVID-19 pandemic created a host of issues for institutions of higher education over the past year, including the issue of how to effectively assess student learning when courses are taught remotely. In this work-in-progress paper we present our experience using remote oral assessments in five introductory courses in two subject areas: computing and mathematics. We discuss our motivation for adopting this new assessment format and how to successfully implement remote oral assessments to replace traditional written final exams. We conducted a post-assessment student survey to understand how students responded to the oral exam format. The purpose of the survey was to gather feedback on students' emotions during and after the assessment. Our preliminary quantitative results show that overall students experienced more positive than negative emotions in all courses, though students responded differently in computing and mathematics courses. Students generally favored the oral format, and those who did not have previous experience with this type of assessment had a similar positive response to students who were more familiar with the format. We expect to shed more light on students' experience with the oral assessment as we will continue our research and conduct a qualitative study of the open-ended responses in the survey.

In this experience report paper we present our experience with the development of oral assessments as final examinations in three introductory computing courses. The choice of this type of summative assessment was prompted by the emergency remote instruction instituted in the middle of the Spring 2020 semester, across colleges and universities in the U.S., due to the coronavirus pandemic. The principles that guided our oral assessment design were: to develop a more comprehensive measure of student competence and mitigate exam cheating; to facilitate communication and workplace skills through student-teacher interaction; and to alleviate negative emotions associated with traditional summative assessments.

Students often struggle with advanced computing courses, and comparatively few studies have looked into the reasons for this. It seems that learners do not master the most basic concepts, or forget them between courses. If so, remedial practice could improve learning, but instructors rightly will not use scarce time for this without strong evidence. Based on personal observation, program tracing seems to be an important pre-requisite skill, but there is yet little research that provides evidence for this observation. To investigate this, our group will create theory-based assessments on how tracing knowledge affects learning of advanced topics, such as data structures, algorithms, and concurrency. This working group will identify relevant concepts in advanced courses, then conceptually analyze their pre-requisites and where an imagined student with some tracing difficulties would encounter barriers. The group will use this theory to create instructor-usable assessments for advanced topics that also identify issues caused by poor pre-requisite knowledge. These assessments may then be used at the start and end of advanced courses to evaluate to what extent students' difficulties with the advanced course originate from poor pre-requisite knowledge.

Automatic programming assignment assessment is often premised on black-box testing. Grading of student submissions typically relies on functional specifications expressed in terms of expected outputs for given test inputs. Many upper-level courses, however, are centered on concepts that relate to how programs are implemented. In a course that teaches functional programming, for instance, the assignments should require that students use functional programming techniques, even if imperative solutions are supported by the language. When students are required to use certain programming language constructs, algorithms or design strategies as they implement their programs, a different approach to automated assessment is needed. Our strategy is centered on programming assignments designed in such a way that the internals of the assignment implementation can be evaluated through automated testing. A challenge of designing such auto-graded assignments is that both the specifications and the grading tests have a much higher level of complexity compared to plain functional specifications and black-box tests. The specification of a homework assignment must have precise requirements, but not prescribe a certain solution or impair student creativity. Furthermore, test cases should not inadvertently rely on implementation details that were not specified, but must be able to detect forbidden algorithms or language features. The benefits and difficulties of our approach are discussed in this work.

Loops are a fundamental concept in computing and well known to be difficult for novices. Recent research shows that the open-ended learning approach often used in teaching block-based programming can be insufficient to help young students gain a solid understanding of computing concepts. Misconceptions about loop are very common despite the user-friendly block-based programming syntax. This study aims to contribute to the current understanding of how elementary-aged students can learn the concept of loops through a more structured instructional design. We engage students in structured learning activities consisting of "tangible" programming concept demo and progressive problem solving exercises. These activities were used to teach a group of 3-5th graders two types of loops: counting loops that repeat a set number of times without logic conditions, and conditional loops where the loop iteration is controlled by a Boolean condition. The evaluation results indicate that most students are able to understand and use counting loops correctly in their programs after the weeklong class. The understanding of conditional loops, however, remains difficult for elementary-aged students. Our study suggests that computing concepts may be learned more effectively with a structured instruction setting. Nonetheless, teaching young students conditional loops, especially how to apply them in computational problem solving is a very challenging task even in block-based environments.

Supervising students in project-based courses is challenging, particularly when the projects are "open-ended," such as real-world projects or projects whose ideas are generated by the students. These projects often have undefined scope and use technologies and tools where we lack expertise. In this session, we plan to discuss the challenges faced by teachers in supervising open-ended projects in project-based learning environments. Some of the questions we address in this session: How do we support students with a project in a domain we know nothing about? How do we help students find meaningful and relevant projects with appropriate scope? How do we assist students in selecting appropriate technologies and tools? How do we guide students in planning their iterations to deliver business value and core functionality? This BoF is for instructors who teach or are interested in teaching courses with open-ended projects.

We present preliminary experiences in designing a Computer Science Principles undergraduate course for all majors that is based on physical computing with the Arduino microprocessor platform. The course goal is to introduce students to fundamental computing concepts in the context of developing concrete products. This physical computing approach is different from other existing CS Principles courses. Students use the Arduino platform to design tangible interactive systems that are personally and socially relevant to them, while learning computing concepts and reflecting on their experiences. In a previous publication [1], we reported on assessment results of using the Arduino platform in an Introduction to Digital Design course. We have introduced this platform in an introductory computing course at the University of Hartford in the past year as well as in a Systems Fundamentals Discovery Course at the University of New Hampshire to satisfy the general education requirements in the Environment, Technology, and Society category. Our goal is to align the current curriculum with the CS Principles framework to design a course that engages a broader audience through a creative making and contextualized learning experience.

Many, if not most, computer science majors plan on careers in some aspect of software development in industry. Software development in industry is characterized by extensive use of tools and specialized software to support large scale projects, such as Git, Maven, Gradle, Jenkins, Hibernate, and Spring. We want our students to have exposure to industry strength tools and systems, but want to avoid having our courses overwhelmed by tools with steep learning curves. In this session, we plan to discuss questions and issues that are raised when choosing, installing, teaching, and using industrial strength tools and frameworks in software project courses. Bring your suggestions for favorite tools and frameworks, ideas on learning activities, and support materials. Some of the questions we might tackle: How do we identify tools that support our course learning objectives? How do we find the time and resources to learn the tools? How do we work with our IT staff in installing and configuring the tools? How many tools and systems should we use in a project course, and when do we merely start overwhelming the students' And finally, what works?

Programmable robots have become a very popular tool to introduce children to technology. However most curricula that emphasize on actual programming typically target kids 10 years and older. This summer, the University of New Hampshire organized an Elementary Program Introducing Computing (EPIC) camp. Children 7-9 years old, with no prior programming experience, were introduced to problem solving and creative program design using Lego EV3 Mindstorms robotics. The program followed a just enough principle, such that just barely enough contents were presented to the children in spite of a wider ranger of available materials. For example, a simple robot model was prebuilt to help children focus on programming rather than construction; program control flow and sensor data processing were introduced early on, but only using a very limited set of visual programming blocks and sensors. These basic structure blocks provide enough functionality to construct a moderately complex program, and help students stay focused on problem solving in a non-overwhelming setting. In order to gauge the learning outcome, a test was given before and after the camp. The comparison of the results showed that our method helped the children retain the programming skills and knowledge of general concepts of computing.

Cooperative agents often need to reason about the states of a large and complex uncertain domain that evolves over time. Since exact calculation is usually impractical, we aim at providing a modeling tool that supports approximate online monitoring in such settings. Our proposed framework, the multi-agent dynamic Bayesian networks (MA-DBNs), models the dynamics of a group of cooperative agents approximately by utilizing weak interaction among them. Each dynamic agent maintains an individual chain of evolution, which enables a factorized and more efficient calculation of cooperative online monitoring. Meanwhile, agents are organized by an underlying hypertree structure to facilitate inter-agent communication. The error resulting from our model approximation is expected to be bounded over time, and a re-factorization method is proposed to improve the approximation quality. Moreover, MA-DBNs are flexible in admitting existing BN monitoring techniques for each agent's local evolution. As an example, we present an algorithm of distributed particle filters under our proposed model.

Extensive research has been done for efficient computation of probabilistic queries posed to Bayesian networks (BNs). One popular architecture for exact inference on BNs is the Junction Tree (JT) based architecture. Among all variations developed, HUGIN is the most efficient JT-based architecture. The Global Propagation (GP) method used in the HUGIN architecture is arguably one of the best methods for probabilistic inference in BNs. Before the propagation, initialization is done to obtain the potential for each cluster in the JT. Then with the GP method, each cluster potential is transformed into cluster marginal through passing messages with its neighboring clusters. Improvements have been proposed to make the message propagation more efficient. Still, the GP method can be very slow for dense networks. As BNs are applied to larger, more complex and realistic applications, the design of more efficient inference algorithm has become increasingly important. Towards this goal, in this paper, we present a heuristic for initialization that avoids unnecessary message passing among clusters of a JT, therefore improving the performance of the architecture by passing fewer messages.

The multiply sectioned Bayesian network (MSBN) model successfully extends the traditional Bayesian network (BN) model for the support of probabilistic inference in distributed multi-agent systems. However, existing MSBN inference methods do not allow agents to reason about their own problem sub-domains right after the initialization process. Extensive amount of inter-agent message passings are needed to calibrate each agent's local subnet into a correct prior marginal distribution. In this paper, we introduce the concept of prior marginal factors to facilitate this process. Based on the analysis of the prior marginal factors, minimum message passing is required during calibration. Furthermore, we have removed the requirement of maintaining a consistent junction tree (JT) during message calculation. Therefore, our marginal calibration algorithm guarantees that a prior marginal in each MSBN subnet is formed with greatly reduced communication and computational cost. Our preliminary experiments have confirmed the improved time efficiency of the proposed algorithm.