OCCTIVE is a library of short, animated videos introducing foundational computing concepts. The primary goal is to support faculty outside of Computer Science who are teaching computing in their courses but often lack the class time or background to cover foundational computing concepts that underlie their course materials.

Computing and computing concepts are interconnected with virtually every aspect of daily life and every field of study. However, when teaching new computing concepts to novice programmers, the number of example domain applications that can be presented is extremely limited. In addition, programming assignments where students apply these concepts are typically closed-ended, fully defining the problem to be solved. As a result, there are few opportunities for students to take an active role in creating connections between computing concepts and situations where they can be applied. See Logic in Life exercises are short, non-programming exercises comprised of a logical and a visual component. The exercise format provides opportunities for students to explore and create their own connections between computing concepts and application domains. Further, by sharing these connections with fellow classmates, students are exposed to a breadth of applications for a given concept via a peer learning experience. Student feedback on the impacts of both creating and sharing computing connections via See Logic in Life exercises is presented. Sample See Logic in Life exercises, suitable for use in CS0 or CS1 as in-class, out-of-class, or active learning exercises, are freely available at youtube.com/virt-university.

Whether it is following an influencer on social media, face-timing with friends and family, or participating in online classes, students are accustomed to forming personal connections through their devices via "talking head" images in which a speaker directly addresses their audience. This poster explores leveraging this phenomenon to connect a human context with CS1 assignments by augmenting their descriptions with videos featuring a cameo appearance by the (fictitious) individual who needs the program. The featured speaker can describe the motivation for the assignment, put requirements into context, or provide a rationale for improvements or updates. These talking-head-style videos, which can be easily created using platforms such as Zoom and YouTube, reinforce the notion that programming is creating a product for clients and users. Further, by featuring individuals of diverse ages, genders, races, and ethnicities, cameo videos provide a valuable opportunity to present problem-solving in an inclusive way. This poster provides example cameo videos paired with assignments, tips on how to easily create them, and student feedback as to their effectiveness in providing a human-centered, diverse, and motivational context for programming assignments. Sample cameo videos and corresponding programming assignments, as well as a how-to video for easily creating a cameo video, are available at youtube.com/virt-university.

No abstract available.

Programming assignments are typically clearly and unambiguously defined problem statements that place the focus on developing a program that produces correct answers and those correct answers can be unambiguously ascertained based on the problem description. However, this approach excludes the human influence that can introduce a lack of clarity at each step of the problem-solving process. This poster presents a non-coding exercise structure that highlights the impact of human communication and judgment on that process. The approach emphasizes this human aspect by using a short, purpose-built video depicting an individual explaining their interpretation of a problem they are experiencing. The approach consists of three components: (1) requirements gathering based on the vague, incomplete and ambiguous problem scenario featured in the video (2) black-box test development, and (3) evaluation of a program's solution based on both objective and subjective criteria. The approach is de-coupled from coding, allowing it to be used at any level of the curriculum. A ready-to-use video (The Happy Day Daycare, available at youtube.com/virt-university) and supporting materials are provided and also used as a basis for discussing how interested instructors can use the approach to create their own videos and exercises. Student feedback from using the exercise structure in a CS1 class is also presented.

Students entering the corporate sphere, particularly in client-facing positions, find themselves in a world of ambiguity that needs to be analyzed, clarified, and effectively described and communicated in order to transform real-world problems into real-world computing solutions. Navigating this world involves skills ranging from requirements gathering and creative thinking through high-level design and communication. Academic programming experience is frequently based on assignments that are pre-defined in specific, unambiguous language. This approach leaves a skills gap in translating amorphous, ambiguous problem scenarios into specifications. Video scenarios are a flexible, ready-to-use tool to aid in developing the skills needed to fill this gap. The short videos show individuals discussing or experiencing situations for which they need computing assistance. However, the situations are presented in ways that are ambiguous, open-ended, and sometimes contradictory. Students must utilize critical listening, observation, and thinking skills to define the problem the characters are experiencing and design potential solutions. Video scenarios can be easily used to develop requirements gathering, design specification, and communication skills in classes ranging from general education through capstone seminars. They are particularly well suited for software engineering and design courses, including those in certificate programs. By putting a face on a problem, video scenarios highlight the role of the user and provide a setting for developing user stories, use cases, and interaction skills integral to agile development. Student feedback from using video scenarios in a software engineering course is also presented. Videos and materials are available at http://youtube.com/virt-university.

The need to integrate the development of innovative thinking and creative problem-solving skills into computer science curricula has been increasingly recognized. However, two major hurdles face many computer science educators: (1) What exercises can be used to develop creative and innovative thinking in the context of computing? and (2) How, in crowded curricula, can the time be found to engage students in creative problem-solving exercises? This demonstration presents a solution to both questions using video scenarios. These short films, with associated discussion questions, feature fictitious companies facing problems that computing solutions could alleviate. For example: Can an art gallery please a patron who wants paintings categorized by redness? In what innovative ways can a pet shop create customer communities? The problems the characters are facing are not explicitly stated nor do they have a single solution. Instead, the viewer must discern the problems through critical listening and observation, and then develop creative solutions to solve them. Since the videos decouple problem-solving from implementation, they also provide an equal-footing environment that allows students with varying technical abilities to participate productively in the exercises. Participants will be introduced to how video-based creative problem-solving exercises can be used, even in time-restricted situations. The videos and associated discussion questions are available at http://www.youtube.com/virt-university.

This highly participatory Special Session introduces video scenarios as a collaborative approach that enables students to hone innovative thinking skills while experiencing how diverse viewpoints contribute to innovation. The videos present fictitious scenarios involving individuals experiencing a variety of problems for which the audience is challenged to think of creative technology-based solutions. Emphasizing conceptual solutions, decoupled from implementation, allows students with a variety of ability and experience levels to participate equally in the exercises, highlighting the value of all voices in the creative process. It also allows the videos to be used in a wide of range classes from the general education and introductory levels through senior capstones in both computing and engineering. Participants in this special session will experience how video scenarios provide a platform that highlights the influence and value of diversity for creative problem solving while developing and honing innovative thinking skills. By taking part in a variety of activities, the participants will be ready to use video scenarios to easily bring collaborative exercises for innovative thinking into their classes. Videos and discussion prompts are available at www.youtube.com/virt-university in the Creativity College.

When a client, describing a problem that requires a computing solution, mentions their “old” customers, does it refer to the age of the customers or the length of time the customers have been with the business? How big is “big”, how much is “too many” and what exactly should happen to the extra banquet guests that fail to fill an entire table? While typical programming assignment descriptions are fully specified, with all ambiguity removed, real-world problems are frequently ill-defined, filled with ambiguity and open-ended. Successfully translating these problems into computing solutions involves both recognizing the issues that need to be addressed and asking questions to resolve the unknowns. Typical classroom examples and assignments purposely lack ambiguity and so do not provide students with the opportunity to develop the questioning skills that will be required in professional life. Further, for some students, asking questions implies not understanding the material, and thus can be perceived as a negative attribute. This paper presents an approach to encouraging an environment of questioning surrounding problem descriptions and potential solutions. The generality of the approach enables it to be incorporated into classes ranging from CS1 to upper-level courses such as Software Engineering and senior capstones.

Studies indicate that students, particularly females, find computing most engaging when it is presented in relation to real-life problems, rather than when it is presented in ways that emphasize computing for the sake of computing. Video scenarios are a novel tool for encouraging students to explore computing in a problem-centric, rather than a code-centric, manner. Video scenarios are short films (2-5 minutes long) that depict individuals facing problems in life-like settings. The scenarios emphasize the diverse and often ill-defined nature of real world problems, and the potential for creative and entrepreneurial computing they present. The video scenarios and their associated discussion/exercise questions are freely available on the web at www.Virt-U.org.

This poster presents a tool for providing novice students with a context in which to develop the ability to identify problems and patterns for their solutions by using video scenarios. A video scenario is a short film (typically 2-7 minutes) which has an extemporaneous feel. Each video depicts individuals facing a particular problem that can be helped through a computing solution. A selection of video scenarios is presented which is specifically designed to cultivate the problem identification and solution formulation skills of novice programmers by focusing on problems which can be solved using basic computing constructs. The videos can be used in a wide variety of settings and are suitable for use at the middle school, high school and college levels.

The development of a distributed application that exhibits both desired functionality as well as performance is a complex task. Therefore, the construction of monitoring tools to assist in the development of complex distributed applications is of great practical significance. For example, monitoring tools can be used to observe the behavior and fine tune the performance. One of the fundamental problems that must be addressed is to ensure that the monitoring tool is able to report the true behavior of an application, that is, it is able to monitor the application non-intrusively. We identify the intrusive effects of monitoring on communication in an arbitrary point-to-point network and present the enhanced communication protocol for on-line communication intrusion removal. Our experiments demonstrate that the intrinsic overhead of a distributed system integrated with online intrusion removal techniques is 0.43%, 98.3% of intrusion on the accumulated number of events and 97.2% of intrusion on the sequence of event occurrences can be removed successfully.

Distributed programs are often instrumented for collecting information to assist in analyzing the behavior of an application. However, the act of monitoring a process introduces intrusive overhead that delays the times at which actions occur in a monitored execution in comparison to the times at which they occur in an unmonitored execution. These delays can alter the actions of individual processes and the behavior of the system as a whole. The overall behavior of process scheduling is determined by the choices a scheduler makes in terms of when particular processes will be given access to the processor. Monitoring introduced delays can result in different scheduling choices being made which can in turn lead 20 changes in the behavior of processes throughout the distributed system. This paper presents intrusion removal techniques which are designed to accommodate monitoring delays in an attempt to minimize the intrusion on the scheduling and execution behavior of the monitored computation.

The development of a distributed application that exhibits both desired functionality as well as performance is a complex task. Therefore the construction of monitoring tools to assist in the development of complex distributed applications is of great practical significance. Monitoring tools can be used to observe the behavior and fine tune the performance of an application. One of the fundamental problems that must be addressed in order to construct an effective monitoring tool is to ensure that the tool is able to report the true behavior of an application, that is, it is able to monitor the application non intrusively. In order to do so we must avoid the affects of monitoring on the outcomes of non deterministic aspects of a computation, including non determinism introduced explicitly by the application programmer and non determinism in the scheduling of application processes. We present protocols that enable the presentation of the overall program behavior.

This paper describes the design, protocol, and implementation of VidNet (Video Network), an environment for distributing the generation of photo-realistic images across the workstations of a local area network. Photo-realistic images are produced by tracing the interacting light rays within a three-dimensional computer model. The number of calculations required to ray-trace a single image severely limits the number of images that can be generated by a single-processor system. VidNet uses distributed processing techniques to reduce the time required to produce computer generated animation, which may consist of several thousand ray-traced images. In designing VidNet, however, consideration was given to a number of requirements which would define its impact on the overall computing environment. First, VidNet was designed to minimize its visibility to the users of the workstations. The two scheduling strategies, the assigned and the automatic strategies, used by VidNet to determine the assignment of frame processing to workstations were directly influenced by this restriction. Secondly, VidNet was implemented using only existing technologies. No additional hardware or software was required. The existing software package for ray-tracing was used to render individual images. Also, VidNet provides a degree of fault tolerance and error recovery for some basic types of failures.

Programs written in distributed programming languages are often non-deterministic in nature and hence the execution of such programs is not only dependent upon the program input, but also on the timing of the execution. Thus, an attempt to monitor the run-time behavior of a non-deterministic program through code instrumentation, such as during debugging, can potentially alter the program's behavior. In this paper we present techniques for dynamically minimizing the intrusive effects of monitoring by attempting to ensure that the likelihoods of various outcomes of the non-deterministic events are the same for uninstrumented and instrumented programs. This goal is achieved by minimizing the intrusive effects of monitoring on message passing between processes located at different sites of a distributed system. Monitoring actions alter the message pool at the time of non-deterministic message selection and the order in which the messages arrive at a processor. The dynamic techniques presented in this paper minimize intrusion by restoring the message pool and message ordering.

Due to their fundamental nature, analyzing the behavior of distributed computations is a complex task. One approach is to monitor the system activity for occurrences of user defined events. As the computation executes, the monitoring system automatically collects and evaluates information pertaining to the defined events, and recognizes event occurrences. The need exists to study various approaches to event recognition in a context in which the strategies can be created and analyzed. This paper presents an EVEnt REcognition teSTbed (EVEREST) specifically designed to address these needs. Commands are provided by which the user can define the behavior to be recognized the configuration of the monitoring system and the strategies to be used in recognizing the event occurrences. Utilizing these directives, EVEREST recognizes occurrences of the defined events during the distributed program's execution. By providing flexible structuring and dynamic configuration of the monitoring system, multiple time view protocols and the separation of event and monitoring specification, EVEREST provides the capability of developing, testing and comparing various approaches to distributed event recognition.

A statement is considered to be monotonic with respect to a loop if its execution, during the successive iterations of a given execution of the loop, assigns a monotonically increasing or decreasing sequence of values to a variable. We present static analysis techniques to identify loop monotonic statements. The knowledge of loop monotonicity characteristics of statements which compute array subscript expressions is of significant value in a number of applications. We illustrate the use of this information in improving the efficiency of run-time array bound checking, run-time dependence testing, and on-the-fly detection of access anomalies. Given that a significant percentage of subscript expressions are monotonic, substantial savings can be expected by using these techniques.>

Event based debuggers for distributed systems automatically detect occurrences of user specified events. During debugging it is not always possible to break-point a computation in a state that reflects an event occurrence. Thus, to avoid unnecessary break-points we must develop techniques that determine, prior to the initiation of a breakpoint, whether an event occurrence will be captured by the breakpoint. We propose the simultaneity operator for achieving the above goal. This operator asserts that its operand events, which correspond to slates of different processes in the distributed computation, are all true at a point in the program and stable with respect to this point. The stability of events guarantees that the initiation of a break point at this point will leave the system an a state which reflects the event occurrence. We present static analysis techniques that identify points in a program at which user specified simultaneous events should be evaluated to avoid unnecessary breakpointing. The statically computed information also enables minimal instrumentation of the program for the detection of event occurrences.>

Programs written in distributed programming languages are often non-deterministic in nature and hence the execution of such programs is not only dependent upon the program input, but also on the timing of the execution. Thus, an attempt to monitor the run-time behavior of a non-deterministic distributed program through code instrumentation, such as during debugging, can potentially alter the program's behavior. In this paper we introduce notions of non-intrusion that are useful for the monitoring of non-deterministic programs. We develop static perturbation analysis techniques to analyze the affect of run-time monitoring activities on the outcome of a non-deterministic event and identify points in a program at which monitoring activities can be performed non-intrusively.

A new task graph representation, namely the compact task graph (CTG) is developed to aid in the scheduling of a set of communicating periodic real-time tasks. This representation exposes the potential for parallelism across tasks as well as the idle times that may be encountered within a task. Therefore using a CTG a real-time scheduler can generate schedules that are able to meet deadlines by interleaving the execution of tasks on a single processor and/or overlapping the execution of tasks on multiple processors. The construction of a CTG is based upon the busy-idle execution profiles for the tasks generated by the compiler. The profiles are computed assuming that sufficient resources are available for parallel execution of all tasks. Thus, they expose all opportunities for overlapped and interleaved execution. The compiler analyzes the profiles to identify useful opportunities for interleaving and expresses them in the CTG without explicitly partitioning the tasks. The CTG is powerful because it expresses schedules that are not expressed by existing approaches for constructing task graphs. Schedules can be generated efficiently since a CTG's construction does not require the splitting of tasks. We also demonstrate the usefulness of our techniques by developing an approach for non-intrusive monitoring of real-time tasks.>

Event based monitors and debuggers for distributed systems automatically detect occurrences of user specified events that characterize the state of one or more processes in a distributed computation. The system monitors the occurrences of local events. Data pertaining to these occurrences is utilized to detect occurrences of distributed events which check the ordering or concurrency of local events that occur at different processes. The overhead of recognizing distributed events can be high, because of the need to capture, communicate, store and evaluate event information for analysis. This paper presents techniques that exploit program and event semantics to reduce the overhead of monitoring a distributed computation for ordered and concurrent events. Static analysis algorithms are presented that determine the minimal program instrumentation required to insure that adequate state and timing information are available to recognize every event occurrence.>

The authors present a methodology for the characterization of event recognitions based on the relationship between the system state at recognition time and its state when the event actually occurred. The methodology incorporates characteristics of the event and computation with a technique for collecting and organizing state information, thus providing an integrated approach to recognition characterization. Since the processes of a distributed computation are located at different processors in a system, the task of recognizing an event occurrence actually consists of two subtasks. First, the information pertaining to the activity described in an event definition must be collected and organized into a view of the computation's behavior which reflects the temporal relationships between the activity at the various processes. Second, this view must be analyzed in light of the user-provided event definitions to determine whether the behavior specified by the user occurred.>

A technique is presented by which state information can be organized into unified, consistent representations of the system state through the creation of simultaneous regions. This method provides a general, yet efficient means of establishing the simultaneous relationship necessary for the monitoring and recognition of event occurrences. The types of events for which a computation can be monitored are described. The methods of utilizing logical clocks and global snapshots are then presented and the reasons why they are not appropriate for use in event evaluation are discussed. The technique for establishing simultaneous regions is then presented and the behaviour of the monitoring and recognition protocol is examined in the context of specific monitoring examples. The correctness of the protocol is proved.>

A generalized approach to the task of monitoring a distributed computation for event occurrences is presented that involves analyzing the characteristics of both the behavior to be recognized and the environment in which it can occur. The monotonicity of an event, which is a measurement of the stableness of its state, is the primary feature used in characterizing events. A general classification system for monitoring strategies is also presented. The classifications are based on the view of time used by the monitoring system, the delay between the occurrence of an event and its recognition, and the assertions that can be made about the system state at the point of recognition. The properties of an event and a computation can be used to determine the applicability of various types of monitoring strategies.>