Previous research has found that programming assignments can produce strong emotional reactions in introductory programming students. These emotional reactions often have to do with the frustration of dealing with difficulties and how hard it can be to overcome problems. Not only are these emotional reactions powerful in and of themselves, they have also been shown to induce students to make self-efficacy judgments, which can in turn cause adaptive or maladaptive behaviors, depending on the valence of the judgment. These results have been found in previous qualitative research in programming, however, to date no one has done a larger scale quantitative examination of emotional reactions in introductory programming students. Furthermore, no one has tried to connect these emotional reactions systematically to student learning outcomes. Therefore, this study reports on the pilot use of a basic emotional reactions survey with a large class of undergraduate introductory programming students. Preliminary results are presented on how these emotional reactions affect students' course outcomes over the short and longer term.

We investigate if a mobile application running on a touch-enabled device can continuously and unobtrusively authenticate and identify its users based only on their interactions with the user interface of the application. A unique advantage that this modality provides over other implicit modalities on mobile devices is that every user who uses the mobile application is automatically enrolled into the classification system via the touch-based interface, thereby guaranteeing that an attacker cannot avoid the classification system. Using different types of input controls available on the Android platform, we collected interactions from 42 users in five sessions. We created base classifiers from each type of input control and combined them into an ensemble classifier to authenticate and identify users. We found that a Support Vector Machine-based ensemble classifier achieves a mean equal error rate of 7% for user authentication and a median accuracy of 93% for user identification. We found that Support Vector Machine-based ensemble classifiers outperform other techniques in both cases. While the ensemble classifier performance for authentication and identification is not found to be sufficient for it to replace current primary authentication mechanisms used in mobile applications, its truly continuous nature provides motivation for it to be used in conjunction with primary authentication mechanisms. UI interaction-based authentication and identification is independent of swipe gesture-based and keystroke-based authentication, allowing it to be combined with those modalities, while remaining resilient to attacks against those modalities.

Previous research in computer science education has demonstrated the importance of motivation for success in introductory programming. Theoretical constructs from self-regulated learning theory (SRL), which integrates several different types of metacognitive processes, as well as motivational constructs, have proved to be important predictors of success in most academic disciplines. These individual components of self-regulated learning (e.g., self-efficacy, metacognitive strategies) interact in complex ways to influence students' affective states and behaviors, which in turn influence learning outcomes. These elements have been previously examined individually in novice programmers, but we do not have a comprehensive understanding of how SRL constructs interact to influence learning to program. This paper reports on a study that examined the interaction of self-efficacy, intrinsic and extrinsic goal orientations, and metacognitive strategies and their impact on student performance in a CS1 course. We also report on significant gender differences in the relationships between SRL constructs and learning outcomes. We found that student performance had the expected motivational and SRL precursors, but the interactions between these constructs revealed some unexpected relationships. Furthermore, we found that females' self-efficacy had a different connection to programming performance than that of their male peers. Further research on success in introductory programming should take account of the unique and complex relationship between SRL and student success, as well as gender differences in these relationships that are specific to CS.

Previous research has suggested that cognitive tests, including instruments seeking to measure problem solving, are significant predictors of students' programming performance. This paper seeks to expand upon this previous research by using a more theoretically grounded approach to measuring problem solving as a means of predicting performance in an introductory undergraduate programming course. Programming course performance has typically been measured by overall course grades; however, in this paper we used a more fine-grained approach to measuring student programming performance. Specifically, we utilized different types of course assignments (projects and tests) to measure programming outcomes. Results from this study indicate that problem solving ability significantly correlates with performance on programming assignments, but does not correlate with performance on multiple-choice exams.

Cyber criminals are covertly attacking critical infrastructures, and botnets are a common component of those attacks. In recent years, botnets have been shifting their focus from broad-based attacks to more targeted ones such as attacking financial institutions, especially banks. The primary reason for this shift towards financial institutions is that, where the money is. We present an empirical study of the components, features and operations of some of the most widely deployed HTTP-based financial botnets (such as Zeus, SpyEye, ICE 1X, Citadel, Carberp, Tinba, Bugat and Shylock). Our study provides critical insights into the design of these botnets and should help the security community to generate intelligence and develop more robust security solutions to defend against cyber attacks by these botnets. In addition, our comparative analysis of insidious techniques pertaining to Command and Control (C&C) communication, system exploitation and data exfiltration also provides an effective and a holistic view of the capabilities of HTTP-based financial botnets. This study also highlights the evolution of various HTTP-based financial botnets over a period of time. Finally, we discuss security solutions that can help mitigate some of the techniques used by HTTP-based financial botnets.

If you change the CS1 language to Python, what is the impact on the rest of the curriculum? In earlier work we examined the impact of changing CS1 from C++ to Python while leaving CS2 in C++. We found that Python-prepared CS1 students fared no differently in CS2 than students whose CS1 course was in C++, even though CS2 was taught in C++ and covered the same topics as in previous years. Was that an anomaly? What happens in the next tier of courses? When our CS1 was first changed to Python there were many students who had taken CS1 in C++ still in the system. The result is that there is a cadre of students with either CS1 in Python or CS1 in C++ moving together through our curriculum. This one-time occurrence is an opportunity to study the students with many variables fixed. Our next tier of courses is a C-based computer organization course, a C++ based object-oriented software design course, and a data structures course. We found that the students who started with Python fared as well as the CS1 C++ students. As before, the best predictor of performance was their college GPA. Python versus C++ CS1 preparation was not a predictor of performance in any course. We conclude again that in our C++ based curriculum changing CS1 to Python had no negative impact on student performance and did not require any significant change in those subsequent courses.

How suitable is a Python-based CS1 course as preparation for a C++-based CS2 course? After fifteen years of using C++ for both CS1 and CS2, the Computer Science Department at Michigan State University changed the CS1 course to Python. This paper examines the impact of that change on the second course in the sequence, CS2, which kept C++ as its primary language. We report results on a CS2 class which had a mixture of students who had used either C++ or Python from our CS1 course. The CS2 class covered the same topics as previously, though with some changes, and even gave the same final exam as a previous offering. Independent samples t-tests were used to compare students from the Python group with students from the non-Python group on three outcomes: final exam grade, programming projects scores, and final grade for the course. The main result was that there were no significant differences between the groups for all three outcomes. In addition, multiple regression analysis showed that students' past performance (overall GPA) in the University predicted final grades, final exam scores, and programming project scores for the course, but there was no effect of the programming language feature: Python or non-Python. We feel this shows that the Python-based CS1 course prepared students for the C++-based CS2 course as well as the C++-based CS1 course did---while exposing them to a different, powerful and useful language.

We propose a minimalist, architectural approach, Secure Bit (patent pending), to protect against buffer overflow attacks on control data (return-address and function-pointer attacks in particular). Secure Bit provides a hardware bit to protect the integrity of addresses for the purpose of preventing such buffer-overflow attacks. Secure Bit is transparent to user software: it provides backward compatibility with legacy user code. It can detect and prevent all address-corrupting buffer-overflow attacks with little runtime performance penalty. Addresses passed in buffers between processes are marked insecure, and control instructions using those addresses as targets will raise an exception. An important differentiating aspect of our protocol is that, once an address has been marked as insecure, there is no instruction to remark it as secure. Robustness and transparency are demonstrated by emulating the hardware, booting Linux on the emulator, running application software on that Linux, and performing known attacks

When examining a new cache structure or replacement policy, the optimal policy is a useful baseline. We prove that finding the optimal schedule is NP-hard for any but the simplest of caches, and that no polynomial-time approximation scheme exists for this problem unless P=NP.

Throughout the history of computer science education there has been debate on what should be the appropriate mathematics background for computer science majors. The first computer science instructors were mathematicians and the first curriculums were just modifications of mathematics curriculums. However, as the discipline has grown and matured there has developed several areas of computer science where traditional undergraduate mathematics is not used and traditional mathematics preparation may not be appropriate. Although logic and problem solving skills are valued by the Computer Science community, exactly how many hours of mathematics and what areas of mathematics should be required, needs to be addressed. This panel was convened to discuss this issue from a variety of viewpoints. We hope that discussion will give the listeners new ideas on just what should be the appropriate courses and topics for their institution and program. The panel was chosen to present a wide range of view representing a variety of schools (large and small, public and private, traditional and non-traditional, preparation for the workplace or for disciplines (E-commerce, distributed computing, artificial intelligence, software engineering and graphics) viewpoints (both young and old, industrial and academic).

An analysis of the primary factors influencing the performance of a parallel implementation on a Cray T3E of a Carbon Molecular Dynamics code developed at Department of Physics and Astronomy at Michigan State University is presented. We show that classical load-sharing techniques combined with careful analysis of Amdahl's law can be successfully used to significantly increase the performance of the code. This report describes the quantitative analysis of these factors and the solutions used to diminish or eliminate their effects. By slightly modifying the code we reduced its sequential portion to less than 0.1%. We also demonstrate that the MPI collective communications implementation on the Cray T3E dramatically reduces the communication overhead for our code. In the end, a speedup of 170 was obtained using 256 Cray T3E processing elements. These results create the prospect of simulating the dynamics of 1,000-atom nanotubes in the microsecond regime (/spl ap/1,000,000 time steps).

Monitoring and debugging of parallel programs is complicated by race conditions, which can cause software monitoring to alter program behavior. To avoid these unwanted modifications of program execution, the authors present a flexible scheme for transparently monitoring parallel programs in a shared-memory environment. To achieve transparency, the monitor observes causal relations between events in different threads of execution, and intervenes when an impending event would change the order of occurrence of causally related events, as compared to unmonitored execution of the same program. Constructs used to support this monitoring scheme are developed, including mechanisms to deal with unsynchronized and coarse grained clocks. The monitoring scheme requires the instrumentation of every shared-memory access. To measure the overhead created by this intrusion, a prototype monitor has been implemented. Preliminary performance results produced by the prototype are presented and discussed.>

This paper presents a parallel implementation of a tree search strategy for recognition of 3D objects in range images. A coarse-grained and a medium-grained implementaton of the tree search algorithm is presented and analyzed. The performances of the two implementations are analyzed on a 96-node BBN GP-1000 and on a 48-node BBN TC-2000; and, for comparison, on a Sun SPARCstation 2.>

The authors present a scalable snoopy scheme based on a single-hop-connected multiple-bus topology. To reduce the hardware complexity, each processor will snoop on a dynamically changing subset of the buses. The physically-distributed-logically-shared memory model is chosen to let processors take advantage of local memory accesses for private data. The proposed scheme can enjoy fast memory access and can also take advantage of greater scalability. At the same time, the number of transceivers can grow naturally with the number of processors in the system. Comparing this solution with the directory schemes and the traditional snoopy coherent schemes indicates that the performance of the scheme is promising.>

We are quickly approaching the projected physical limits of present, field-effect transistors.

The authors describe a set of experiments conducted on wormhole-routed Symult 2010 systems to measure the performance of their interprocessor communication networks. They then analyze the results to predict the performance of similar systems. They first show that long path lengths in this mesh have a negligible effect on communication time. Next, they show that the contention for network channels can scale up with the system size, and that the effect is observable in current machines. It is also shown that resources within a node itself can become a bottleneck. Given current architectural trends, it is concluded that contention for network resources, and not path length, will become the primary concern in ensuring fast communication in future multicomputers.>

Numerous solutions to the problem of detailed routing of wires on a chip have been proposed for two routing layers but few are general enough to also handle switchboxes, more than two layers, variable channel widths, or multiple-layer problems with stacked terminals (3-D routing) without extensive modifications. We propose a different routing approach that not only can solve the two layer problem but the other problems as well. The inherent parallelism of the approach lead to a coarse-grained parallel algorithm.

In this paper we present two n-layer channel routing algorithms that guarantee successful routing of the channel for n greater than three. The first is linear and optimal given a VHV …HV assignment of layers. The second, using an HVH…VH layer assignment, is quasilinear and performs optimally on examples from the literature. Except in pathological cases, we expect the latter router to perform within one row of optimal. For comparison with published examples we implemented the second router in five and three layers. The five-layer implementation routed all examples optimally while the three-layer implementation routed the examples with the same or fewer rows than the published examples. With its n-layer capability this channel router will allow channel routing to be used when more than three layers are available. This router can also be used to evaluate the utility of additional layers.