There is an urgent need for ''T-shaped'' software developers with breadth in Quantum Computing (QC) and depth in Computer Science and Software Engineering, who can build and work with the quantum-powered applications of the near future. This paper reports on our experiences implementing the Quantum-Aware (Q-Aware) track, an adaptable and lightweight curricular framework that can be integrated into existing curricula for the preparation of quantum-aware graduates. Our focus here is a study conducted on the integration of Q-Aware into Data Structures and Discrete Structures courses during Fall 2025. One goal of this study was to investigate the effectiveness of Q-Aware in helping students achieve the level of knowledge and skills for quantum awareness. In addition to a high level of enthusiasm of students for participation in Q-Aware, we observed a substantial increase in confidence of students when it comes to understanding concepts such as qubit, quantum state, superposition and quantum measurement. A second goal was to assess the effectiveness of QC training for the instructors teaching these courses. Student feedback was positive overall about the effectiveness of lectures, motivating students, effective use of time, and handling students' questions.

Computing educators strive to align curricula with workforce needs yet rarely articulate how professional competencies, behaviors, and responsibilities develop across different educational pathways. As the community moves beyond the 2027 curriculum revision cycle, bridge pathways spanning vocational, undergraduate, graduate, and non-computing entry routes are rapidly expanding. At the same time, widespread AI use requires curricula to more explicitly address professional judgment, accountability, and ethical reasoning, in addition to technical skills. This working group brings participants together to map, compare, and synthesize real curriculum and pathway artifacts using shared academic and workforce frameworks. Participants will build a competency-oriented pathway framework, identify recurring bridge pathway designs and gaps, and produce practical, post-2027 guidance that supports coherent, scalable, and internationally transferable computing curricula.

Ethical inquiry in computing has an evolving nature, where repeated critical questioning may lead to a series of reframings of the problem. Since many computing students have experience with agile project-based courses, an iterative approach can provide a familiar entry into ethics. Agile development, however, is typically oriented around satisfaction of customer goals, while ethical inquiry requires constant questioning that may cast those goals into doubt. Does the similarity between critical ethical inquiry and iterative development provide a helpful model or breed a false familiarity?

This work proposes a novel cognitive model, called Aggregate-Superpose-Project (ASP), to facilitate problem solving and the analysis of algorithms in Quantum Computing (QC). Our model contains three simple abstractions that help students use classic computing concepts towards specifying quantum states and transformations. Simplicity is a major advantage of ASP along with reinforcing the use of classical concepts in learning QC abstractions. Preliminary evaluations indicate that ASP can provide students with the means to describe quantum algorithms at appropriate levels of abstraction.

The complexity of statutory legislation can generate confusion and disagreement in interpretation even among experts and can leave ordinary citizens disempowered. Technological “solutions”, even with stakeholders’ best interests in mind, can exacerbate this sense of estrangement from the law. We are exploring an alternative application of technology in this area: a digital “sandbox” environment for legislators, lawyers, judges, and citizens to define and explore the consequences of legislation. Our approach employs a “lightweight” method to computational modeling, using automated analysis to uncover hidden assumptions and unintended consequences. As a case study, we are focusing on a number of U.S. statutes that define conditions under which prior convictions can be expunged from an individual’s public record. We use the Alloy modeling language and analyzer to explore consequences of expungement statutes. Starting with the State of Michigan’s Clean Slate Law and then extending to similar statutes in Utah and Arizona, we can model varying interpretations of the law in terms of modular changes to a base model, and then use the Alloy analyzer to explore the consequences of these interpretations. We have developed a user interface for the model that is tuned to the needs of individuals seeking expungement and their legal assistants, determining which convictions within the individual’s record can be expunged under varying interpretations, and explaining why some convictions may not be expunged. This application not only serves as a proof of concept for our larger sandbox vision but also has promise as a useful tool for individuals navigating the complexities of expungement.

The importance of dialogue in questioning assumptions and bringing new options and perspectives to light is well established in various areas of decision-making; what potential does it hold to enrich students' critical thinking competencies in the context of ethics education? We examine student work in an ethics course for senior computer science and software engineering students. The course includes a series of exercises in critical ethical inquiry, implementing the iterative Ethical Cycle approach of van de Poel and Royakkers with reflection sessions where students exchange peer critiques. Through a qualitative analysis of two years of student work, we explore two questions: what kinds of critical issues do students acknowledge in peer dialogue, and how do students incorporate, or fail to incorporate, critical challenges into their work? We identify and categorize critical challenges that appear in student reflection statements, and we identify a number of patterns of critical engagement: ways in which student map the identifications of critical challenges to subsequent changes in later iterations. Our results indicate that dialogue with others is generally an enriching component of students' ethical inquiry, though not all students take advantage of it even when built into class exercises, and other students may adopt new ideas in a superficial way, failing to truly incorporate them into prior discussion. The results also suggest certain design changes of the ethical analysis exercises that can help students take greater advantage of insights from their peers: fostering greater interplay between peers through a single clearly identified topic; more defined scaffolding of peer discussions, prompting students to identify critical challenges from others; further scaffolding to remind students of the peer challenges raised earlier and ask them how (and whether) they wish to incorporate these new perspectives into their own work; and more discussion and modeling of how to truly incorporate new ideas in a robust way.

In the spring of 2022, a formerly vibrant summer reading program had become moribund due to retirements and staff changes; roughly 1600 first year students were about to miss out on a longstanding and successful tradition. In response, a small group of faculty sought a way to link first-year courses between disciplines in order to boost student engagement. This group latched upon a fortuitous circumstance: the 101st anniversary of Karel Capek's play R. U.R., which gave the world the term “robot.” Thus was born Robot 101, an integrative experience connecting instructional content between courses and with a wide range of academic and artistic events outside the classroom, all centered around the multifaceted theme of “robot.” This paper details how a common theme can inform and enliven first-semester courses in engineering, composition, and computer science, as well as engage the greater university community. Our primary objective in establishing these overt connections between courses and other activities was to give students the opportunity to form their own covert connections, thereby deepening their appreciation of the interdisciplinary nature of big ideas in engineering, technology, and society. The program also provided opportunities for more advanced students to participate and make their own interdisciplinary connections. This work provides initial data and reflections on the effect of this program on student engagement and connectedness in first semester courses. We include recommendations for a scalable and sustainable program that continues thematic integration on an ongoing basis.

Comics as a pedagogical tool have shown promise in conveying ideas and increasing retention in STEM disciplines. Within the context of introductory programming courses, the visual, real-world analogies to programming problems that comics offer may allow engineering students to better grasp abstract algorithmic concepts that can be obscured by low-level programming language details. Creating comics also provides an opportunity for students to exercise metacognition, as they are asked to reflect on what they know and how to express it in a new way. Further work is needed, however, to develop comic assignments with rigorous rubric-based assessment. Our work in progress focuses on an intervention where students develop their own algorithmic comics and share them with peers. The design of the assignment and assessment rubric leverages prior work on using context-bounded analogy to teach programming concepts. Students will create a comic illustrating an algorithmic concept and then use it as a medium for further communication, responding to peer feedback in order to further refine their understanding. These communications, we hypothesize, will increase correctness of representations and scenarios in the comics through refinement and likewise, in their understanding of programming concepts. The rubric associated with the assignment will serve as a model for assessment of relevant criteria within comic-based student activities.

In this work in progress/innovative practice paper, we describe our efforts to integrate introductory computer science pedagogical methods into an engineering fundamentals context. Our multidisciplinary team is addressing the problem of perceived value and applicability of programming for first-year engineering students. These students tend to be unaware of the importance of programming skills for practicing engineers within industry, and consequently display low interest in programming. We are working to address this perception problem through interventions in the engineering fundamentals classroom.Our interventions have three objectives: establish awareness of how programming skills can be generalized beyond the introductory classroom, incorporate targeted activities for algorithmic thinking, and demonstrate the practical applications of programming skills. Similar interventions are part of the introductory experience for our computer science students; our goal here is to tailor the interventions to an introductory engineering context. Our goal is for students to recognize computing as part of the career and identity of an engineer.

Climate change is the defining environmental challenge now facing our planet. Babies born today will be 22 when global warming reaches 1.5 C, according to the latest IPCC report and forecasts. What will life be like in 2040? How do we as educators respond today, to the challenges that lie ahead for the next generation?

This poster presents MATLAB Critiquer, a system that examines code submissions and provides feedback to first year engineering students who are learning to program in MATLAB. Code Critiquers act as substitute mentors, when instructors are not available, and give students experience with interactive, test-driven development. Students using our critiquer are engaged in communication by proxy with the instructor. This communication does not replace instructor feedback; rather, it codifies common feedback scenarios to assist the instructor in reaching students just when the student is engaged in problem solving and learning. Our critiquer uses the MATLAB Java API; connecting to the MATLAB Engine that parses and executes student code submissions. We process error messages that are returned using regular expressions, then use these results to craft feedback for the students. Static code analysis is used to provide feedback on style. The critique covers code structure, shakedown test results, and programming style in a manner appropriate for novice coders.

The introductory programming lab, with small cycles of teaching, coding, testing, and critique from instructors, is an extraordinarily productive learning experience for novice programmers. We wish to extend the availability of such critique through automation, capturing the essence of interaction between student and instructor as closely as possible. Integrated Development Environments and Automated Grading Systems provide constant feedback through static analysis and unit testing. But we also wish to tailor automated feedback to acknowledge commonly recurring issues with novice programmers, in keeping with the practice of a human instructor. We argue that the kinds of mistakes that novice programmers make, and the way they are reported to the novices, deserve special care. In this paper we provide examples of early programming antipatterns that have arisen from our teaching experience, and describe different ways of identifying and dealing with them automatically through our tool WebTA. Novice students may produce code that is close to a correct solution but contains syntactic errors; WebTA attempts to salvage the promising portions of the student's submission and suggest repairs that are more meaningful than typical compiler error messages. Alternatively, a student misunderstanding may result in well-formed code that passes unit tests yet contains clear design flaws; through additional analysis, WebTA can identify and flag them. Finally, certain types of antipattern can be anticipated and flagged by the instructor, based on the context of the course and the programming exercise; WebTA allows for customizable critique triggers and messages.

Students in computing disciplines need a strong basis in the fundamentals of discrete mathematics, but traditional offline approaches to teaching this material provide limited opportunities for the kind of interactive learning that computing students experience in their programming assignments. We have been using the Alloy language and analyzer to teach concepts in discrete structures (relational algebra, logic, and graphs) in an exploratory, programming-oriented way. Alloy, however, constitutes a new programming paradigm for introductory students, and careful mediation is needed to keep students on track. We use the familiar programming lab format, where students work on small-scope problems co-located with instructors, to provide guidance as students wrestle with the languages of relational algebra and predicate logic through Alloy. We describe selected lab exercises, and report on initial findings based on our experiences with students.

This working group contributes to formulating a framework for modeling competencies in the current and future disciplines that comprise computing education. We draw upon the innovative approach taken in the curricular document for information technology (IT2017), curricular competency frameworks, other related documents such as the software engineering competency model (SWECOM), the Skills Framework for the Information Age (SFIA), current research in competency models, and elicitation workshop results from other computing conferences. The outcomes contribute to the Computing Curricula 2020 (CC2020) project, and include the formulation and review of sets of disciplinary-relevant competencies for use in computing education. This work directly informs the CC2020 project sponsored by the Association for Computing Machinery (ACM) and the IEEE Computer Society.

The need for K-12 students to engage in Computer Science has been acknowledged in the White House call for "Computer Science for All" and supported through a variety of institutions. Implicit in many initiatives, and explicit in Google's CS4HS initiative, is the notion of a "Community of Practice" involving K-12 teachers. Communities of Practice are mutually supportive groups to assist newcomers as they find their way in a new endeavor. Teachers can support one another at multiple levels: technical, pedagogical, political, and emotional. Maintaining a Community of Practice for CS teachers, however, can be challenging. Demands on teacher time, lack of institutional buy-in, physical isolation, and lack of appropriate peer institutions are some confounding factors. A true community of practice requires maintenance: ways to identify newcomers or other participants in need, and ways to identify and share the resources that can help others. In this BoF, educators who are working to expand CS within K-12 education will discuss the challenges in the Community of Practice approach and share proven ways of addressing them.

We present a demonstration of our WebTA tool, which facilitates the teaching of programming by providing automatic critique and grading of student source code. Programming is in fact a complex set of interconnected activities. Learning to design, analyze, implement, test, and revise software is crucial for student success, not just for computer science students but for a broad and growing body of students in other disciplines as well. Our approach is to teach students agile development methods through small cycles of teaching, coding integrated with testing, and immediate feedback. WebTA facilitates our teaching approach by providing automatic critique of student source code. WebTA provides immediate feedback to students and gives them experience with interactive, test-driven development. Students using WebTA are engaged in communication-by-proxy with the instructor. This communication does not replace instructor feedback; rather, it codifies common feedback scenarios, triggered by errors, warnings, or textual code analysis, to assist the instructor in reaching students just when the student is engaged in problem solving and learning. This prompts the student to reflect and refactor in an iterative design process. WebTA compiles student code and executes it over a series of shakedown tests. It also analyzes student performance and generates preliminary grading reports. Students are coached through code critiques and suggestions that prompt them to reflect and refactor. The demonstration consists of a walkthrough of two use-case scenarios: Student use of WebTA as a code snippet critiquer and its use by faculty as an automated grading system.

This workshop presents a novel approach to teaching the mathematical foundations of computing commonly known as Discrete Structures. Following the common model of the programming lab, we provide interactive learning experiences in relational algebra, predicate logic, and graph theory that are both human- and computer-mediated. Students use the Alloy language and analyzer to express constraints in formal mathematical notation and search for models that satisfy the constraints. Alloy is an industrial-strength tool, but with careful scaffolding even students in introductory discrete structures can benefit from highly interactive and visual guided explorations mediated through Alloy code. We design exercises carefully to take students from observers of Alloy program behavior to tweakers of established code and later to builders of their own code. We find that the feedback provided by the Alloy Analyzer eliminates common misconceptions among students. Compared to a traditional approach where students simply submit written answers to homework problems, students working on Alloy problems get immediate critique of the well-formedness and satisfiability of their responses. The interactive nature of Alloy allows them to explore, discover new concepts, and challenge their assumptions with unexpected corner cases. After an introduction to Alloy, teams of workshop participants will engage in learning activities in discrete structures, using the Alloy tool for exploration and application of concepts. Teams will reflect on their experiences and comment on the applicability of this socio-technical learning approach in their own teaching contexts. A laptop is recommended for participation in the workshop.

Our experience with digital literacy tutoring for older adults confirms other research that identifies technology-related anxiety as a significant barrier for this constituency. Based on established theories of instructional design, we hypothesize that anxiety impairs the development of digital literacy skills by consuming critical cognitive resources. Our research with experienced tutors reveals numerous strategies for mitigating anxiety and motivates the development of anxiety-aware instructional and design frameworks, and new anxiety scales that better reflect current devices, services, and threats.

In entering the digital realm, older adults face obstacles beyond the more clearly understood physical and cognitive barriers traditionally associated with accessibility. This experience report is a collection of narratives from learners and student tutors who participate in our digital literacy sessions for seniors. We point out ways in which attitudes and motivations, framed by social and cultural factors, can either hinder or assist with adoption of commodity digital technology among older newcomers. We also show how a social-cognitive approach can help learners overcome barriers to digital literacy.

Students in computing disciplines need a strong basis in the fundamentals of discrete mathematics. Traditional “offline” approaches to teaching this material provide limited opportunities for the kind of interactive learning that students experience in their programming assignments. We have been using the Alloy language and analysis tool to teach concepts in discrete structures and logic in an exploratory, programming-intensive way. We report on our efforts to build scaffolded Alloy exercises for newcomers to discrete mathematics, and we report on some initial findings based on our experiences with students.

We introduce an interactive tool called WebTA that facilitates learning through automatic critique of student source code. Our tool provides immediate feedback to students and gives them experience with test-driven development. Students receive the benefits of cognitive apprenticeship through the feedback they receive in the tool. This facilitates tight, productive cycles of inquiry, critique and learning. WebTA compiles each student submission and executes it over a series of shakedown tests. Immediate feedback is given concerning errors and warnings, coupled with suggestions for debugging. The tool performs a textual analysis of the students source code and critiques programming style based on standard programming guidelines. To encourage inquiry through test-driven development, edge-case coverage, and API compliance, students develop and submit their own tests to be evaluated by the software. We report on use of WebTA in one first-year programming course and one second-year data structures course. Lab and assignment scores have improved with WebTA, and student comments attest to the effectiveness of the tool. Preliminary results indicate students receive higher grades with WebTA. One area with mixed results is WebTAs analysis of student developed JUnit tests; this feature improved API compliance but reduced edge-case testing. With these successful initial results, we offer suggestions for future development.

Software professionals routinely use sophisticated problem solving and design skills in their communication with one another and other stakeholders in the software process. We wish to introduce our computer science and software engineering students to the communication challenges of real software development and help them to develop skills to meet these challenges. We describe our guided inquiry approach to addressing communication in a team software project course. This course constitutes a crucial juncture in the academic journey of our students, where they learn and practice the full responsibilities of a software engineer, including "soft skills" like communication. Early in the course, we expose the students to real communication challenges that others have faced. Later, during their project development, we ask them to reflect on the communication challenges they are facing. We describe the guided inquiry techniques that scaffold the students' understanding of communication issues, and we outline our pattern approach to communication design. We provide some initial results from the classroom, following teams as they explore the communication practices of others and reflect on their own.

This HCI course incorporated unit testing as a quality improvement initiative with an Experiential Learning Model. The focus of the research was on observation and conceptualization---students should be able to associate the benefits of usability and unit testing and apply them to more general situations. Based on our survey results and student interviews, the most difficult challenge incorporating unit testing in an experiential course was ensuring students overcome their negative bias to discover the benefits of functional testing. We recommend emphasizing the concrete benefits of unit tests and ensuring that all students fully participate in the testing experience.

With the continued and alarming lack of involvement in computing among college students, attention has recently focused on engaging students at the middle and high school levels. Our "Copper Country Programmers" club began as a community outreach program to fill a gap left by the elimination of the computing curriculum in the local school district. In our club, university faculty and students provide curriculum, tools, and classroom tutoring for young novice programmers across the school district. Our curriculum teaches programming through a series of exercises involving HTML, BASIC, LOGO, and Processing (a graphics-oriented Java variant.) Contrary to some other approaches, we present students initially with a low level, bare bones programming model and development environment, then gradually increase the functionality and complexity. We find that students readily grasp the simple, transparent initial model, then experience first-hand the motivations for adding functionality (and complexity). Our cross-curricular programming topics include graphic design, interactive fiction, computer generated poetry, mathematical simulation, computational geometry, game physics, computer art, artificial intelligence, video game development, and critical thinking. We provide examples of our curriculum, student work, problems encountered, and how they were resolved.

Exploratory testing is a well-established, industry-adopted process of investigation and discovery, which employs human creativity to gain deep insights into a software product. It is authentic, rigorous, and enjoyable, making it an excellent topic for an undergraduate software engineering course. However, it is difficult to explain to the beginner how to generate a successful exploratory strategy. “Case studies” and “lessons learned” from practitioners illustrate the value of exploratory testing but do not necessarily reveal the motivation for a particular exploratory tour. Here we discuss the use of problem frames as a means of guiding students toward promising testing strategies. Problem frames were originally proposed as a requirements analysis approach, carefully locating and bounding software problems to be solved, then matching subproblems to commonly occurring problem patterns or “frames”. A natural extension to that idea is to associate test strategies with particular frame concerns, guiding the student toward exploratory techniques that are well-suited to the frame. Once students become confident exploratory testers, they can add their own strategies to a growing body of knowledge. To illustrate the approach, we consider frame concerns and test strategies for workpieces problems, using Google Calendar as our test subject.

Preparing students for the communication realities of software development is as difficult as it is important. Training in specific genres of oral and written communication is vital, but successful software developers must also design their communication, choosing appropriate genres and styles to fit the audience and context. We introduce a pattern language for classifying and describing communication strategies. Communication Patterns serve both as an approach for rigorous qualitative analysis and as a library of established practices that students can draw from. The approach has clear links to software design patterns and highlights the fact that communication, like software, is a designed artifact. We focus on two software projects from our case study repository, using Communication Patterns. The two case studies have a great deal of overlap in objectives, stakeholders, responsibilities and timescales, but the outcomes are drastically different. Through patterns, we assess communication at strategic and tactical levels, and we find major differences in communication choices. We also discuss our attempts to expose students to Communication Patterns in the classroom. We conclude with a look at future efforts to deepen our pattern library and diversify our approaches to building and using them.

Two trends in the developed world - the marked growth in the percentage of the population identified as “elderly”, and an increased reliance on computing technology - make it imperative that the high technology designers of tomorrow understand the challenges, capabilities and context of elderly users. Our graduate course on “software for senior citizens” provides a broad background of material from human-computer interaction, gerontology, literacy studies and cognitive and learning sciences. Students also gain first-hand experience through weekly tutoring sessions with local elderly residents. These sessions yield observations and generate contacts from which students generate research projects. This paper discusses our goals and motivations for the course, our experiences to date, and our plans for future iterations and opportunities for expansion.

We introduce Communication Patterns (CPs) as a tool for rigorous qualitative analysis of project communication. Using our library of student capstone project case studies as a test bed, we describe our approach to communication analysis. We identify, analyze and compare the communication, at various granularities, that takes place in student projects. The patterns allow us to objectively describe the structure (what, how, who, where, when, why) of the different forms of communication that occur in a software project. Patterns range from strategic (choice of genre) to tactical (wording or tone). We use CPs to sensitize students to their communication choices as developers and users. The CP framework is familiar to students (akin to design patterns) and generative (readily extendible to new scenarios). In addition, we as researchers and instructors plan to use CPs to assess how new pedagogical practices, moving from traditional classroom communication towards more blended learning, are changing the student experience and assess the effectiveness of current software project communication practices. We use CPs to analyze the communication that occurs in teaching computer use to novice senior citizens. The examples illustrate how CPs can be used to study communication practices in many different contexts of software development or use.

Access control systems are a key component of computer system security. This paper presents the results of an effort to understand the usability of current access control systems. A study was conducted to observe users of three access control systems: UNIX discretionary access control (DAC), SELinux, and a novel access control system, a File System Firewall (FSF), which we have designed and implemented. Several recommendations for improving user experiences with access control systems are presented based on our analysis of the study results.

Scrum is one of the many agile approaches to software development that have been widely adopted over the past decade. Agile processes allow developers to embrace under-defined problems in complex environments where change in requirements is inevitable. The key agile features of Scrum are a flexible, adaptive schedule; democratic, collaborative teams; and frequent, iterative project and process reviews [2]. While students may engage with Scrum in the context of software development, the characteristics that suit many software problems to an agile approach also describe the student learning environment: complexity (new and unfamiliar concepts), under-defined problem space (students don't know what they don't know), short timeframe with frequent meetings (terms and class meetings), and inevitable change (apply new knowledge). This makes Scrum not only a software development strategy but a general learning strategy. Scrum facilitates frequent and iterative practice with timely feedback, development of mastery, and self-direction [1]. In this panel, the participants will describe how their students learn and practice Scrum in a software development context, how they use it to manage student projects outside the software development context, and how Scrum provides opportunities to integrate communication skills into the Computer Science (CS) and Software Engineering (SE) curricula. As participants in the NSF-funded CPATH II project (NSF Grants 0939122 and 0939081) "Incorporating Communication Skills Throughout Computer Science and Software Engineering Curricula," each panelist has developed Scrum-based assignments that exercise the skills of reading, writing, speaking, and teaming. The participants will discuss the design of these assignments and their experiences with them to date.

Communication - between humans - remains at the heart of software development. This workshop will serve as a forum for those invested in this topic to articulate challenges and solutions, and to build links for further work.

Failure in communication between software developers and other stakeholders is a common cause of requirements deficiencies, cost overruns, and delays. It is difficult to present in a classroom setting the complexities that can cause such failures. To address this need, we have developed instructional case study material in software communication. We demonstrate how our cases expose students to situations they will confront outside the classroom, and how they provide opportunities for critiquing and devising communication strategies. We also describe our use of the cases, in a software engineering course and a technical communication course. We give initial results of an ongoing evaluation of the material's effectiveness in the software engineering curriculum.

We have used the problem frames approach to teach software requirements analysis in an undergraduate software engineering setting for several years. Its lightweight formalism is rigorous without being intimidating, and its clarity and precision foster critical inquiry and careful reasoning among students. To guide newcomers to problem frames, and to aid experienced students in tackling larger problems, we have created a Java-based editor tool called PFEdit to construct and manipulate problem frame documents. This course module includes introductory presentation material, a documented version of PFEdit, and an annotated problem frame document that demonstrates the major concepts of problem frames and the capabilities of PFEdit

Summary form only given. The memory consistency model underlying the Unified Parallel C (UPC) language remains a promising but underused feature. We report on our efforts to understand the UPC memory model and assess its potential benefits. We describe problems we have uncovered in the current language specification. These results have inspired an effort in the UPC community to create an alternative memory model definition that avoids these problems. We give experimental results confirming the promise of performance gains afforded by the memory model's relaxed constraints on consistency.