Most applications we use today are multi-tier, yet students primarily learn and build stand-alone, monolithic programs. This tutorial introduces attendees to building modern, multi-tier applications, with the goal that attendees can in turn introduce this topic to their students. The tutorial will use Amazon Web Services (AWS), though the concepts are cloud-neutral. Topics include multi-tier design, data storage, web services, RESTful API design, and serverless computing. Attendees will build a complete, multi-tier app using a variety of AWS services: RDS, S3, Lambda, and API Gateway. These four services are sufficient for building a large variety of interesting, real-world projects. Materials for this tutorial are drawn from the Scalable Software Architecture course taught at Northwestern University, a 10-week class for undergraduates and first-year graduate students; these course materials are freely-available at https://www.joehummel.cs.northwestern.edu/ .

Most applications we use today are multi-tier, yet students primarily learn and build stand-alone, monolithic programs. This tutorial introduces attendees to building modern, multi-tier applications, with the goal that attendees can in turn introduce this topic to their students. The tutorial will use Amazon Web Services (AWS), though the concepts are cloud-neutral. Topics include multi-tier design, data storage, web services, RESTful API design, and serverless computing. Attendees will build a complete, multi-tier app using a variety of AWS services: RDS, S3, Lambda, and API Gateway. These four services are sufficient for building a large variety of interesting, real-world projects. Materials for this tutorial are drawn from the Scalable Software Architecture course taught at Northwestern University, a 10-week class for undergraduates and first-year graduate students; these course materials are freely-available at https://www.joehummel.cs.northwestern.edu/.

This experience report presents results from a quasi-experiment comparing course performance and student-reported survey constructs between two groups of students. One group took a Data Structures course with traditional, in-person modality. The second group took the same course with flexible, online modality. The work was motivated by the rapid adjustments computer science instructors made due to remote learning during the COVID-19 pandemic. In a response to these forced changes, this study was set up to investigate the differences between pre- and post- pandemic modalities. There are 212 students in the study, which took place in Fall 2021 at an R1, minority serving institution in the Midwestern United States. The study found that students in both groups performed similarly on common course components like projects, labs, homework, and a final Data Structures assessment. There were not significant differences in their self-reported ease of learning, enjoyment, belongingness, attitude, mindset, and self-efficacy. However, when taking into consideration gender, we found that women's performance was lower than men's in the traditional modality course. Women's performance in the flexible modality course was on par with men. Lastly, we present some feedback from students relating to assessments and modality.

The Early Research Scholars Program (ERSP) was launched in 2014 at UC San Diego as a way to provide the benefits of research experiences to a large and diverse group of students early in their undergraduate computing career. ERSP is a structured program in which second-year undergraduate computing majors participate in a group-based, dual-mentored research apprenticeship over a full academic year. In its first four years ERSP engaged 139 students with a high proportion of women (68%) and racially minoritized students (19%), and participation in ERSP correlated with increased class grades. In 2018 we partnered with three additional universities to launch their own version of ERSP. Implementations at our partner sites have seen similar diversity and initial success, and have taught us how to implement the program in different contexts (e.g. quarters vs. semesters, different credit structures). This paper describes the structure of ERSP and how it can be adapted to different contexts to construct a scalable and inclusive research experience for early-career undergraduates in computing and related fields.

The pace of technology for use in computing education is staggering. In recent years, the following technologies have completely transformed our teaching: Piazza, GradeScope, YouTube, Google Docs, Doodle and whenisgood.net, Skype and Google Hangout, and Khan Academy among others. Hardware has also played a part. We love our Zoom digital voice recorder (for recording CD-quality lecture audio), Blue Yeti USB mike (for audio/videoconferences), and iClickers (for engaging students in class). This panel is an outgrowth of a Technology that Educators of Computing Hail (TECH) Birds of a Feather session that we've held at SIGCSE for seven years, and the panel from SIGCSE 2015 [1] that served as a springboard for a regular column in ACM Inroads [2]. It will provide a chance for seasoned high school and university educators to show you the technologies that have "bubbled to the top" for them, and what key problems they solve. Like concert musicians, they will give live demonstrations and reveal the configuration options required to make their technology "sing". We hope this forum will allow the presenters to dive deeply into the common use cases of these technologies, highlight why they are invaluable, share any "gotchas" they've uncovered, and explain how others can adopt them at their institutions. The highlight of the panel is when the audience, inspired by the presentations, is invited to share their favorite "can't live without" technologies as well.

Peer Instruction (PI) is an active learning technique with over 25 years of research supporting its efficacy. Documented benefits in CS include lower WDF rates, higher exam scores, and improved retention in the CS major. One key difference between PI and traditional lecture is the use of "clicker questions" in class to challenge students' conceptual understanding. Students discuss and answer these questions in small groups before the instructor goes over the question with the entire class. This BoF is for both those using PI and those interested in starting. Attendees will meet other PI practitioners, discuss tips and tricks, and exchange materials. We will provide pointers to PI materials for a variety of courses, including CS1 & CS2, Machine Organization, Programming Languages, OS and more.

Peer Instruction (PI) is an active learning technique with over 25 years of research supporting its efficacy in Physics Education. More recently, the CS Education community has found that the benefits of PI are true for CS as well, including lower WDF rates, higher exam scores, and improved retention in the CS major. One of the key differences between PI and traditional lecture is the use of a series of multiple choice "clicker questions" in class to challenge the students' conceptual understanding. Students discuss and answer these questions in small groups, then the instructor reviews why each choice was right or wrong with the entire class. The workshop is a practical look at the kinds of clicker questions used in PI. Attendees with see examples of some of our best and worst questions, and also work to design and improve some of their own questions. In addition, we will provide a demonstration of PI, and share our practical experiences in adopting PI in a wide variety of class sizes.

Recent work in computing has converged on a collection of complementary findings suggesting the value of the Peer Instruction (PI) pedagogy. Compared to lecture, PI has been shown to decrease fail rates, increase final exam grades, and increase engagement and enjoyment. In PI, students work together to exchange perspectives and use clickers to answer challenging conceptual questions in the presence of a knowledgeable instructor.

Recent work in computing has converged on a collection of complementary findings suggesting the value of the Peer Instruction (PI) pedagogy. Compared to lecture, PI has been shown to decrease fail rates, increase final exam grades, and increase engagement and enjoyment. In PI, students work together to exchange perspectives and use clickers to answer challenging conceptual questions in the presence of a knowledgeable instructor.

As hardware designers turn to multi-core CPUs and GPUs, software developers must embrace parallel programming to increase performance. No single approach has yet established itself as the "right way" to develop parallel software. However, C++ has long been used for performance-oriented work, and it's a safe bet that any viable approach involves C++. This position has been strengthened by ratification of the new C++0x standard, officially referred to as "C++11". This workshop will introduce the new features of C++11 related to parallel programming, including type inference, lambda expressions, closures, multithreading support, and thread-local storage. The workshop will close with brief discussion of other technologies, including Intel TBB, ArBB, Cilk Plus, and Microsoft PPL, AAL, AMP. This is a laptop optional workshop.

No abstract available.

Visual Basic is currently the most popular programming language in the United States. And yet, it is rarely found in traditional Computer Science (and related) curriculums. Perhaps this is due to the fact that VB is not truly object-oriented, but object-based. Or perhaps because VB is not an open language, instead supported only by tools from Microsoft Corporation and available only on the Windows platform. Or perhaps it is simply Microsoft itself, with its monopolistic tendencies.This panel will argue that Visual Basic --- while it should not replace the use of more traditional languages such as C++, Java, or Scheme --- fulfills an important role in modern CS and related curriculums. The panelists will highlight a few of the cases in which they have found VB to be exceedingly useful, and discuss their rationale for choosing VB over other languages.

The Java bytecode language lacks expressiveness for traditional compiler optimizations, making this portable, secure software distribution format inefficient as a program representation for high performance. This inefficiency results from the underlying stack model, as well as the fact that many bytecode operations intrinsically include sub-operations (e.g. iaload includes the address computation, array bounds checks and the actual load of the array element). The stack model, with no operand registers and limiting access to the top of the stack, prevents the re-use of values and bytecode re-ordering. In addition, the language has no mechanism to indicate which sub-operations in the Java bytecode stream are redundant or subsumed by previous ones. As a consequence, the Java bytecode language inhibits the expression of important compiler optimizations, including register allocation and instruction scheduling. The Java bytecode stream generated by a Java bytecode compiler is a significantly under-optimized program representation. The most common solution to overcome this inefficiency is the use of a just-in-time (JIT) compiler to not only generate native code, but perform optimization as well. However, the latter is a time-consuming operation in an already time-constrained translation process. In this paper we present an alternative to an optimizing JIT compiler that makes use of code annotations generated by a Java bytecode compiler. These annotations carry information concerning compiler optimizations. During the translation process, an annotation-aware Java Virtual Machine (JVM) system then uses this information to produce high-performance native code without performing much of the necessary analyses or transformations. We describe the implementation of a prototype of an annotation-aware JVM consisting of an annotation-aware JIT compilation system. We conclude the paper showing performance results comparing our system with other JVMs running on SPARC architecture. Copyright © 2000 John Wiley & Sons, Ltd.

The efficient execution of Java programs presents a challenge to hardware and software designers alike. The difficulty, however, lies with the Java bytecodes. Their model of a simplistic, platform-independent stack machine is well-suited for portability, though at the expense of execution speed. Various approaches are being proposed to increase the speed of Java bytecode programs, including: (i) on-the-fly compilation to native code (also known as JIT or ‘just-in-time’ compilation); (ii) traditional (‘ahead-of-time’) compilation of bytecodes to some higher-level intermediate form and then to native code; and (iii) translation of bytecodes to a higher-level language and then use of an existing compiler to produce native code. Speedups of the order of 50 over standard bytecode interpretation have been claimed. All of these approaches rely upon bytecode analysis (of varying sophistication) to extract information about the program, which is then used to optimize the native code during the translation process. However, extracting information from a lower-level representation such as the Java bytecodes can be very expensive. Also, given the fact that most approaches for executing Java bytecodes cannot spend a great deal of time recovering high-level information, the solutions adopted during the translation process must use faster and less accurate analysis techniques, thus penalizing the quality of the native code. In this paper we propose an optimization approach based on bytecode annotations. The bytecodes are annotated during the original source code to bytecode translation, allowing both traditional interpretation by a JVM and aggressive optimization by an annotation-aware bytecode compiler. Annotations hinder neither portability nor compatibility, while preserving optimization information that is expensive to recompute. Preliminary results yield bytecode with C-like performance using JIT technology. © 1997 John Wiley & Sons, Ltd.

In the presence of pointers, data dependence testing is a difficult and increasingly common problem. Existing approaches work well for pointers to named memory locations (i.e. other variables), but are overly conservative given pointers to unnamed memory locations. In this paper we present a new framework for performing more accurate data dependence testing in the latter case, which occurs in the context of dynamic, pointer-based data structures. We will demonstrate the effectiveness of our approach by breaking false dependences that existing approaches cannot, and provide results which show that removing such dependences can enable significant paralleltzation.

Optimizing compilers require accurate dependence testing to enable numerous, performance-enhancing transformations. However, data dependence testing is a difficult problem, particularly in the presence of pointers. Though existing approaches work well for pointers to named memory locations (i.e. other variables), they are overly conservative in the case of pointers to unnamed memory locations. The latter occurs in the context of dynamic, pointer-based data structures, used in a variety of applications ranging from system software to computational geometry to N-body and circuit simulations.

Even though impressive progress has been made in the area of optimizing and parallelizing programs with arrays, the application of similar techniques to programs with pointer data structures has remained difficult. In this paper we introduce a new approach that leads to improved analysis and transformation of programs with recursively-defined pointer data structures.We discuss how an abstract data structure description can improve program analysis by presenting an analysis approach that combines an alias analysis technique, path matrix, with information available from an ADDS declaration. Given this improved alias analysis technique, we provide a concrete example of applying a software pipelining transformation to loops involving pointer data structures.

In teaching an undergraduate course in Operating Systems, it is instructive if the students have an actual operating system they can study and modify. Care should be taken, however, in selecting a system that the students can realistically be expected to understand. Xinu/WU retains the advantages of its parent PC-Xinu [Fossum 1987]; a small yet relatively complete operating system for the IBM PC, supplied with full source code and able to run within its development environment. Xinu/WU incorporates three particular enhancements: an improved implementation, integration into Borland International's Turbo C™ run-time environment, and more effective use of the windowing system. The conclusion is that Xinu/WU increases the possibility of using such a system in an undergraduate Operating Systems course. Two ways in which it can be utilized are presented.