Researchers have stressed the importance of argumentation among small groups of students in STEM courses to help them develop deep understanding. But it is not widely used in college courses due to such challenges as finding time in already packed courses, effective organization of argumentation in large classrooms, etc. This paper presents a novel online approach to enable argumentation to be adopted widely.One interesting question we investigated in a junior-level computing course concerned the structure of such arguments. Common experience with online forums in courses suggests that a handful of students dominate them while others hardly participate. So we expected that round-based discussions where each student in the group made one submission in each round, the submission not being available to the others until the start of the next round, would be more effective than forum-based discussions where students made as many submissions as they wished and whenever they wished to, and saw each submission as soon as it was made. But to our surprise, the results showed that both were equally effective! We present the details of our approach, the unexpected results from our course, some hypotheses that may explain the results, and future plans to investigate this further.

Piaget's classic work on cognitive development showed that engaging learners in critical discussions with peers about ideas that are different than theirs leads to deep conceptual understanding. Implementing such an approach in computer science and, more generally, STEM, courses has some specific challenges. Based on Piaget's theory, we have developed a highly innovative collaborative learning approach that exploits specific affordances of web technologies to address these challenges. It allows small groups of students with different ideas about the topic in question, to engage in a highly-structured discussion that enables each student in the group to develop deep understanding. While a number of researchers have explored approaches to collaborative learning, a key difference with our work is that our focus is helping individual students develop deep understanding, whereas the focus of much of this other work is on developing students' team skills, effective communication abilities, and the like. We have tested our approach in an undergraduate CS course and the effect on student performance was encouraging; moreover, about two-thirds of the students in the course, based on a post-activity survey, felt that the approach was effective in helping them develop conceptual understanding.

Collaborative learning is a key component of software engineering (SE) courses in most undergraduate computing curricula. Thus these courses include fairly intensive team projects, the intent being to ensure that not only do students develop an understanding of key software engineering concepts and practices, but also develop the skills needed to work effectively in large design and development teams. But there is a definite risk in collaborative learning in that there is a potential that individual learning gets lost in the focus on the team's success in completing the project (s). While the team's success is indeed the primary goal of an industrial SE team, ensuring individual learning is obviously an essential goal of SE courses. We have developed a novel approach that exploits the affordances of mobile and web technologies to help ensure that individual students in teams in SE courses develop a thorough understanding of the relevant concepts and practices while working on team projects, indeed, that the team contributes in an essential manner to the learning of each member of the team. We describe the learning theory underlying our approach, provide some details concerning the prototype implementation of a tool based on the approach, and describe how we are using it in an SE course in our program.

Conflict and cooperation would seem to be ideas that are diametrically opposed to each other. But, in fact, classic work by Piaget on how children and adults learn shows that when learners engage with peers in critical discussion of ideas concerning which they have different understandings, that contributes very effectively to learners developing deep understanding of the concepts involved. At the same time, getting students in undergraduate computing (or other technical/engineering) courses to engage with other students in thoughtful discussion of important concepts is very challenging. It can be especially difficult to get women students and students from other underrepresented groups to participate effectively in such discussions. In our work, we exploit the affordances of mobile and web technologies to address these challenges. Our approach not only helps address these challenges, it has a number of other important advantages over face-to-face discussions. We present the theoretical underpinnings of the approach, some details of our prototype implementation, preliminary results from the use of the prototype in a junior/senior level class on Software Engineering, and the design for the next version of our tool. We also discuss the possibilities and usefulness of applying this approach in a range of computing courses from traditional classrooms to MOOCs.

Learning objects (LOs) were proposed as a way to build reusable chunks of educational content. But in spite of considerable effort by various groups, the approach has had relatively little impact on education. We argue that this is because of a fundamental weakness in the way LOs have been conceived of. We show how the problem can be addressed by borrowing key ideas from object-oriented (OO) programming. We show that the resulting approach will not only help students in learning particular concepts but also help develop their reflective and team-working skills. The approach is also consistent with the ideas of the how people learn (HPL) framework.

In the domain of desktop software, design patterns have had a profound impact; they are applied ubiquitously across a broad range of applications. Patterns serve both to promulgate expert knowledge and as a vocabulary for documenting software design. The result is higher-quality software, reduced development effort, and improved documentation.

After over a decade of use, design patterns continue to find new areas of application. In previous work, we presented a contract formalism for specifying patterns precisely, and showed how the use of the formalism can amplify the benefits of patterns. In this paper, our goal is to enable practitioners to test whether their systems, as implemented, meet the requirements, as specified in the pattern contracts, corresponding to the correct usage of the patterns underlying the systems' designs. In our testing approach, corresponding to each design pattern, there is a set of what we call pattern test case templates (PTCTs). A PTCT codifies a reusable test case structure designed to identify defects associated with applications of the particular pattern. The test assertions in the PTCT are based on the requirements specified in the appropriate pattern contract. Next we present a process using which, given any system designed using the pattern, the system tester can generate a test suite from the PTCTs for that pattern that can be used to test the system for bugs in the implementation of the particular pattern. The process allows the system tester to tailor the test suite the needs of the individual system by specifying a set of specialization rules that are designed to reflect the structure and the scenarios in which the defects codified in the PTCTs are likely to manifest themselves in the particular system.

The benefits of design patterns in the design phase are well-established. We claim that patterns can - and should - play equally important roles in later stages of the lifecycle. But to make this feasible, we need to develop suitable ways to precisely specify the requirements associated with the use of specific patterns, and runtime monitoring tools to identify any violations of these requirements. We summarize a specification and monitoring approach focused on pattern-centric behavior that we developed previously, evaluate alternative ways to monitor systems based on the formalism, and discuss the overall utility of the specification and monitoring approach in the context of a case study

Design patterns provide guidance to system designers on how to structure individual classes or groups of classes, as well as constraints on the interactions among these classes, to enable them to implement flexible and reliable systems. Patterns are usually described informally. While such informal descriptions are useful and even essential, if we want to be sure that designers precisely and unambiguously understand the requirements that must be met when applying a given pattern, and be able to reliably predict the behaviors the resulting system exhibits, we also need formal characterizations of the patterns. In this paper, we develop an approach to formalizing design patterns. The requirements that a designer must meet with respect to the structures of the classes, as well as with respect to the behaviors exhibited by the relevant methods, are captured in the responsibilities component of the pattern's specification; the benefits that results by applying the pattern, in terms of specific behaviors that the resulting system is guaranteed to exhibit, are captured in the rewards component. One important aspect of many design patterns is their flexibility; our approach is designed to ensure that this flexibility is retained in the formalization of the pattern. We illustrate the approach by applying it to a standard design pattern.

Distributed dynamic channel allocation (DDCA) is a fundamental resource management problem in mobile cellular networks. It has a flavor of distributed mutual exclusion but is not exactly a mutual exclusion problem. We establish the exact relationship between the two problems. Specifically, we introduce the problem of relaxed mutual exclusion to model one important aspect of the DDCA problem. We develop a general algorithm that guarantees relaxed mutual exclusion for a single resource and prove necessary and sufficient conditions for the information structure. Considering distributed dynamic channel allocation as a special case of relaxed mutual exclusion, we apply and extend the algorithm to further address the issues that arise in distributed channel allocation such as deadlock resolution, dealing with multiple channels, design of efficient information structures, and channel selection strategies. Based on these results, we propose an example distributed channel allocation scheme using one of the information structures proposed. Analysis and simulation results are provided and show that the results of this research can be used to design more efficient distributed channel allocation algorithms.

In the object-oriented approach, a designer can, given an existing base class, use inheritance to build a derived class that extends, or that slightly differs from the base class, but in order to exploit the full potential of inheritance to build systems incrementally, the designer must also be able to reason about the derived class incrementally. This paper presents a specification notation and verification procedure that allows such incremental reasoning out; the approach makes important use of the concrete specification of a class, in addition to the usual abstract specification. The reasoning reuse that the approach enables is illustrated by applying it to a simple example.

Probes and tokens are used in many deadlock detection and resolution algorithms. A deadlock is detected by propagating probes along dependency edges. When the initiator p/sub i/ of a probe receives its probe back, it knows of the existence of a deadlock. p/sub i/ then sends out a token to clean up those probes in the deadlock; cycle which, if not removed, may later lead to phantom deadlock detections. Only after the token returns to p/sub i/ is the deadlock resolved by aborting a 'victim' (usually p/sub i/). As a result, all involved transactions remain waiting and all involved resources locked until the token returns to p/sub i/, although the deadlock was already detected when the probe returned to p/sub i/. This paper proposes the idea of barriers to allow the deadlock to be resolved without waiting for the token to return to p/sub i/, thereby reducing the average deadlock persistence time considerably.