Parallel and Distributed Computing (PDC) has increased in importance in recent years, with ABET requiring exposure to PDC topics, and CS2023 recommending at least 9 hours of coverage in required CS courses. However, injecting PDC topics quickly into a course is difficult due to time and expense to set up requisite hardware and lack of readily available materials to adopt for the classroom. In this demo, we -- the CSinParallel project -- present free, web-based, interactive textbooks for learning and practicing various forms of PDC. We developed the backend system and wrote the material based on decades of experience integrating these topics into courses throughout the computer science curriculum. Currently we have two books that educators can readily use: Parallel Computing for Beginners, and Intermediate Parallel and Distributed Computing, along with some additional materials. With just a laptop in class, students can edit and run PDC code examples on remote hardware that is professionally maintained, eliminating the need for instructors to prepare hardware and software. The material spans a range of PDC technology (OpenMP, MPI, CUDA, OpenACC), provides mini assessments as readers work, and is designed so that instructors can add brief modules into existing courses or can be used comprehensively for a course dedicated to PDC. All materials are available on learnpdc.org and the code used in the books is on https://github.com/csinparallel/csinparallel. Additional assignments for a PDC course can be found on https://github.com/csinparallel/pdc-assignments.

Parallel and distributed computing (PDC) concepts are now required topics for accredited undergraduate computer science programs. However, introducing PDC into the CS curriculum is challenging for several reasons, including an instructor's lack of PDC knowledge and difficulties in accessing PDC hardware. This paper addresses both of these challenges by presenting free, interactive, web-based PDC teaching modules using inexpensive Raspberry Pi single board computers (SBCs). Our materials include a free disk image that makes it possible for instructors to build Raspberry Pi clusters in minutes and use our software in a variety of curricular contexts. Our multi-year assessment of these materials on students and faculty members indicates that: (i) our materials increased students' confidence regarding important PDC concepts and motivated them to study PDC further; and (ii) our materials increased faculty members' confidence and preparedness in teaching key PDC concepts at their own institutions. • Free online interactive modules for learning PDC with Raspberry Pis and Pi clusters. • Self-organizing cluster: connects disparate Pis into a working cluster in minutes. • Free disk image pre-loaded with all activities for painless classroom adoption. • Our materials increase student confidence about PDC and motivation to learn more PDC. • Our materials increase faculty confidence and preparedness to teach PDC.

The 2019 ABET computer science criteria requires that all computing students learn parallel and distributed computing (PDC) as undergraduates, and CS2013 recommends at least fifteen hours of PDC in the undergraduate curriculum. Consequently, many educators are looking for easy ways to integrate PDC into courses at their institutions. This hands-on workshop introduces Message Passing Interface (MPI) basics in Python or C/C++ using clusters of Raspberry Pi single-board computers. MPI is a multi-language, platform independent, industry-standard library for PDC. Raspberry Pis are an inexpensive and engaging hardware platform for studying PDC as early as CS1. Participants will experience how to teach distributed computing essentials with MPI by means of reusable, effective "parallel patterns," including single program multiple data (SPMD) execution, send-receive message passing, and parallel loop patterns. No prior experience with MPI, PDC, or the Raspberry Pi is expected; participants will explore short programs designed to help students understand MPI basics, plus longer "exemplar" programs that use MPI to solve significant applied problems. The workshop includes: (i) personal experience with the Raspberry Pi (clusters provided); (ii) instructions on how to deploy Raspberry Pi clusters quickly in the classroom; (iii) self-paced hands-on experimentation with MPI programs; and (iv) a discussion of how to use Raspberry Pi clusters to align courses with CS2013 and ABET. All materials from this workshop are available from CSinParallel.org; participants should bring a laptop to access materials and connect to the Raspberry Pi clusters.

With both CS2013 and the most recent ABET computing criteria requiring coverage of parallel and distributed computing (PDC), many CS faculty are looking for ways to incorporate PDC concepts into their curricula. However, the COVID-19 pandemic and the switch to remote teaching introduces new difficulties to teaching a subject that many already find challenging. This BOF provides a forum for computing educators to discuss strategies they have used to teach PDC remotely. The organizers will share techniques that they have found effective (including the different tradeoffs those techniques involve) and foster a discussion in which others can share novel ways of teaching PDC remotely. The end-goals are: (i) to provide a venue in which those who have taught PDC remotely can share their experiences, in the hopes of identifying best practices; and (ii) to enable participants who are new to PDC to learn from the experiences of faculty who have already taught such courses in this new environment. No laptop required; any materials resulting from this session will be distributed via CSinParallel.org.

Teaching parallel and distributed computing (PDC) concepts is an ongoing and pressing concern for many undergraduate educators. The ACM/IEEE CS Joint Task Force on Computing Curricula (CS2013) recommends 15 hours of PDC education in the undergraduate curriculum. Most recently, the 2019 ABET Criteria for Accrediting Computer Science requires coverage of PDC topics. For faculty who are unfamiliar with PDC, the prospect of incorporating parallel computing into their courses can seem very daunting. For example, should PDC concepts be covered in a single required course (perhaps computer systems) or be scattered throughout different courses in the undergraduate curriculum? What languages are the best/easiest for students to learn PDC? How much revision is truly needed? This Birds of a Feather session provides a platform for computing educators to discuss the common challenges they face when attempting to incorporate PDC into their curricula and share potential solutions. Chiefly, the organizers are interested in identifying "gap areas" that hinder a faculty member's ability to integrate PDC into their undergraduate courses. The multiple viewpoints and expertise provided by the BOF leaders should lead to lively discourse and enable experienced faculty to share their strategies with those beginning to add PDC across their curricula. We anticipate that this session will be of interest to all CS faculty looking to integrate PDC into their courses and curricula.

The 2019 ABET computer science criteria requires that all computing students learn parallel and distributed computing (PDC) as undergraduates, and CS2013 recommends at least fifteen hours of PDC in the undergraduate curriculum. Consequently, many educators look for easy ways to integrate PDC into courses at their institutions. This hands-on workshop introduces Message Passing Interface (MPI) basics in C/C++ and Python using clusters of Raspberry Pis. The Message Passing Interface (MPI) is a multi-language, platform independent, industry-standard library for parallel and distributed computing. Raspberry Pis are an inexpensive and engaging hardware platform for studying PDC as early as the first course. Participants will experience how to teach distributed computing essentials with MPI by means of reusable, effective "parallel patterns", including single program multiple data (SPMD) execution, send-receive message passing, the master-worker pattern, parallel loop patterns, and other common patterns, plus longer "exemplar" programs that use MPI to solve significant applied problems. The workshop includes: (i) personal experience with the Raspberry Pi (clusters provided for workshop use); (ii) assembly of Beowulf clusters of Raspberry Pis quickly in the classroom; (iii) self-paced hands-on experimentation with the working MPI programs; and (iv) a discussion of how these may be used to achieve the goals of CS2013 and ABET. No prior experience with MPI, PDC, or the Raspberry Pi is expected. All materials from this workshop will be freely available from CSinParallel.org; participants should bring a laptop to access these materials.

The ACM/IEEE CS 2013 report recommends fifteen hours of parallel & distributed computing (PDC) education for every undergraduate. This workshop illustrates the use of the Raspberry Pi as an inexpensive, multicore platform for teaching shared-memory parallel programming. The inexpensive and tactile nature of the Raspberry Pi enables each student to experience her own parallel multiprocessor through sight and touch. In this hands-on workshop, we will teach attendees how they can leverage the Raspberry Pi and the OpenMP library to teach shared-memory parallel concepts in their own classrooms. All CS educators who are interested in learning about the Raspberry Pi, shared memory parallelism, and OpenMP are encouraged to attend. In Part I of the workshop, each participant will connect to and learn about the Raspberry Pi's multicore capabilities. In Part II, each participant will engage in self-paced, hands-on exploration of basic parallel computing concepts using the OpenMP "patternlets" from CSinParallel.org. In Part III, participants will investigate more complex applications, such as numeric integration and drug design and study how these applications can be parallelized using OpenMP. We will conclude the workshop with a series of lightning talks discussing how the Raspberry Pi has been used to teach parallel computing concepts at different institutions. We will also present a summary of student perceptions of the Raspberry Pi. All materials from this workshop will be freely available from CSinParallel.org. Space is limited to 20 participants. A laptop is required.

The Raspberry Pi (R-Pi) is a single board computer priced at 35 USD -- less than the cost of many textbooks. The current model (3B) includes a quad-core ARM 64-bit CPU, 1GB of RAM, a GPU, and numerous communication ports, including USB, HDMI, Ethernet, WiFi and Bluetooth. This combination of low cost and high functionality creates many new pedagogical possibilities for CS educators, ranging from using the R-Pi to teach assembly language to using it as a multiprocessor. Relatedly, mathematics educators have produced an extensive literature on the use of pedagogical tools known as "manipulatives" that have been shown to be effective at starting students through a "concrete, representational, abstract" progression of understanding of an abstract topic. We believe that by using the R-Pi as a manipulative, this same "concrete, representational, abstract" progression can be used to help CS students master many topics that are often taught as abstractions. By providing a "concrete" foundation on which to build, a single board computer like the R-Pi can provide the first step in helping students build mental models of such abstractions, and thus enhance student learning. Experience also indicates that many students find the R-Pi to be a fun and enjoyable way to learn about these abstractions. In this panel session, four CS educators will share their experiences using the R-Pi in their courses, followed by a Q&A conversation between the audience and the panelists.

CS2013 brings parallel and distributed computing (PDC) into the CS curricular mainstream. The Message Passing Interface (MPI) is a platform independent, industry-standard library for parallel and distributed computing. The MPI standard includes support for C, C++, and Fortran; third parties have created implementations for Python and Java. This hands-on workshop introduces MPI basics and applications in C/C++ using Raspberry Pi single-board computers, as an inexpensive and engaging hardware platform for studying PDC. The workshop includes: (i) personal experience with the Raspberry Pi (units provided) accessed via participant laptops (Windows, Mac, or Linux); (ii) assembly of Beowulf clusters of Raspberry Pis quickly in the classroom; (iii) self-paced hands-on experimentation with the working MPI programs; and (iv) a discussion of how such clusters can be used to engage students in and out of the classroom. Participants will experience how to teach distributed computing essentials with MPI by means of reusable, effective "parallel programming patterns," including single program multiple data (SPMD) execution, send-receive message passing, the master-worker, parallel loop, and other common patterns. Participants will then explore more in-depth "exemplar" applications, such as drug design and epidemiology. All materials including the Raspberry Pi software system setup from this workshop will be freely available from CSinParallel.org. No prior experience with MPI, PDC, or the Raspberry Pi is required. Windows, Mac, or Linux laptop required.

With the requirement that parallel & distributed computing (PDC) topics be covered in the core computer science curriculum, educators are exploring new ways to engage students in this area of computing. In this paper, we discuss the use of the Raspberry Pi single-board computer (SBC) to provide students with hands-on multicore learning experiences. We discuss how the authors use the Raspberry Pi to teach parallel computing, and present assessment results that indicate such devices are effective at achieving CS2013 PDC learning outcomes, as well as motivating further study of parallelism. We believe our results are of significant interest to CS educators looking to integrate parallelism in their classrooms, and support the use of other SBCs for teaching parallel computing.

Parallel computing is one of the new knowledge units in the ACM/IEEE CS 2013 curriculum recommendations. This workshop will present the Raspberry Pi as an inexpensive hardware platform for providing each student with her own parallel processor. The tactile and visceral benefits of each student having her own machine and being able to take full advantage of its multicore capabilities are significant. In this hands-on workshop, we show how parallelism can be used to spread the workload of compute-intensive applications across the multiple cores of a Raspberry Pi, and explore its use as an inexpensive hardware platform for teaching parallel computing. CS educators who are interested in learning about parallel computing, OpenMP, and how to teach these concepts on a Raspberry Pi are encouraged to attend. Attendees will enjoy a hands-on hardware/software experience, exploring how parallel computations operate and work in practice. In Part I of the workshop, attendees will set up and explore a Raspberry Pi multi-core computer in small teams. In Part II, each team will use the parallel capabilities of the Raspberry Pi to explore parallel computation through the use of OpenMP "patternlets" published on CSinParallel.org. Part III explores applications of the Raspberry Pi to parallel applications such as image processing and population dynamics, using OpenMP. All materials from this workshop will be freely available from CSinParallel.org.

OpenMP is an industry-standard, platform-independent parallel programming library built into all modern C and C++ compilers. Unlike complex parallel platforms, OpenMP is designed to make it relatively easy to add parallelism to existing sequential programs, as well as write new parallel programs from scratch. In this fun, interactive, hands-on workshop, participants will use OpenMP to learn about a variety of parallel programming concepts, including single program multiple data (SPMD) execution, fork-join threading, parallel loops, parallel blocks, atomic execution, mutual exclusion, and others. Participants will explore 15 short programs designed to help students understand specific parallel concepts, plus several longer programs in which OpenMP is used to solve significant problems. The workshop includes: (i) an introduction to OpenMP, (ii) self-paced hands-on experimentation with the OpenMP programs, and (iii) a discussion of how OpenMP may be used to achieve parallel computing objectives in CS 2013. Participants will also view visual examples that let students see parallelism happening in real time. Participants will need a laptop with an SSH client (e.g., BitVise, PuTTY), or a laptop with a compiler that supports OpenMP (e.g., gcc 4.2 or later, Visual Studio 2008 or later); Linux, Mac, and Windows laptops will be supported. Knowledge of a C-family language (e.g., C, C++, Java, ...) may be helpful but is not required to benefit from the workshop. All materials from this workshop will be freely available from csinparallel.org.

Just as a micro-computer is a personal, portable computer, a micro-cluster is a personal, portable, Beowulf cluster. In this special session, six cluster designers will bring and demonstrate micro-clusters they have built using inexpensive single-board computers (SBCs). The educators will describe how they have used their clusters to provide their students with hands-on experience using the shared-memory, distributed-memory, and heterogeneous computing paradigms, and thus achieve the parallel and distributed computing (PDC) objectives of CS 2013 [1].

Map-reduce computation is the on-ramp to data-intensive cloud computing, and arguably the most widely deployed form of parallel/distributed computing. Participants will carry out exercises designed for students at CS1, intermediate, and advanced levels that introduce data-intensive scalable computing concepts using WebMapReduce (WMR), a simplified open-source interface to the dominant Hadoop map-reduce programming environment. WMR supports programming in a choice of languages including Python, Java, C++, and C#. Besides a hands-on experience with introductory teaching materials, the workshop includes an overview of teaching advanced map-reduce programming using WMR, and a comparison of WMR to direct Hadoop programming. All materials will reside on csinparallel.org, and the demonstration WMR system is reservable for participants' courses. Intended audience: CS instructors. Web-enabled laptop required.

CS2013 brings parallel and distributed computing (PDC) into the CS curricular mainstream. The Message Passing Interface (MPI) is a platform independent, industry-standard PDC library that includes support for C, C++, and Fortran; third parties have created implementations for Python and Java. This hands-on workshop introduces MPI basics using parallel patterns, including the single program multiple data (SPMD), send-receive message passing, master-worker, parallel loop, broadcast, reduction, scatter, gather, and barrier patterns. Participants will explore 12 short programs designed to help students understand MPI and PDC basics, plus longer programs that use MPI to solve significant problems. The intended audience is CS educators who want to learn about how message passing can be used to teach PDC. No prior experience with PDC or MPI is required; familiarity with a C-family language and the command-line are helpful but not required. The workshop includes: (i) self-paced hands-on experimentation with the working MPI programs, and (ii) a discussion of how these may be used to achieve the goals of CS2013. Participants will work on a remote Beowulf cluster accessed via SSH, and will need a laptop or a tablet with an SSH client (e.g., BitVise, iSSH), or a laptop with both a recent C/C++ compiler and MPI (e.g., OpenMPI or MPICH) installed. See http://csinparallel.org.

In response to the shift to multicore processors, the ACM-IEEE CS2013 curriculum recommendations [1] include parallel and distributed computing (PDC) as a new core knowledge area. Some of the key concepts in PDC are the distinctions between shared-memory, distributed-memory, and heterogeneous system architectures.

Curriculum 2013 brings parallelism into the CS curricular mainstream. This hands-on workshop is intended for faculty with little or no background in parallel computing. OpenMP is a platform independent, industry-standard library for shared-memory parallel programming supported by all modern C and C++ compilers. The workshop introduces the basics of OpenMP multithreading using parallel patterns, including single program multiple data (SPMD) execution, fork-join threading, and pragmas for parallel loops, parallel blocks, mutual exclusion, etc. The workshop includes: (i) an overview of OpenMP, (ii) self-paced hands-on experimentation with the OpenMP programs, and (iii) a discussion of how these may be used to achieve the goals of Curriculum 2013. Workshop materials will be distributed from csinparallel.org. Participants will receive and explore 15 short programs designed to help students understand multithreading concepts, plus longer programs that use OpenMP to solve significant problems. A participant may explore these programs on their own laptop, provided it has installed a C/C++ compiler that supports OpenMP (e.g., gcc 4.2 or later; Visual Studio 2008 or later). Those comfortable with the command-line may explore the programs on our remote servers using a laptop or tablet with a suitable SSH client. Laptop recommended.

The industry shift to emerging forms of parallel and distributed computing (PDC), including multi-core CPUs, cloud computing, and general-purpose use of GPUs, have naturally led to increased presence of PDC elements undergraduate Computer Science curriculum recommendations, such as the new and substantial "PD" knowledge area in the ACM/IEEE CS2013 recommendations. How can undergraduate students grasp the extensive and complex range of PDC principles and practices, and apply that knowledge in problem solving, while PDC technologies continue to evolve rapidly? Parallel design patterns occur at all computational levels, ranging from low-level concurrent execution patterns (such as message passing or thread pool patterns) to high-level software design patterns suitable for organizing entire systems or their components (such as model-view-control or pipe and filter patterns). The ubiquity of these patterns in all forms of parallel and distributed computation makes parallel patterns relevant and illuminating at all undergraduate levels, and knowledge of those patterns can guide effective problem solving for parallel programs. This panel presents four viewpoints representing various approaches for teaching parallel patterns to CS undergraduates at various academic levels, including short "patternlets" examples, patterns in domain applications and parallel problem solving, and two tools, Seeds and Paraguin, for teaching parallel design patterns to undergraduates.

The ACM-IEEE CS2013 curricular recommendations include a dramatic growth in parallel and distributed computing (PDC) topics, in response to the necessary industry shift toward multicore computing, and to emerging technologies such as cloud computing. How can your institution integrate those recommendations into your undergraduate CS curriculum? In this special session, leaders in PDC education will succinctly present their curricular strategies in relation to CS2013 recommendations, while attendees carry out a workshop-style activity to identify opportunities and assemble resources for blending more PDC content into their own local CS curricula.

We describe five years of experience using Beowulf clusters of virtual machines in teaching and research at liberal arts colleges. Each virtual node in each undergraduate student-managed cluster is hosted on a standard classroom/laboratory machine, otherwise dedicated to general computing in support a CS curriculum. Applications highlighted include teaching purposes ranging from introductory CS to advanced projects, research efforts including classical analysis of cluster performance, map-reduce computations in social-networking research, and numerous interdisciplinary applications in natural sciences and other fields. Recent developments and next steps such as portable design and multi-level heterogeneous computing are discussed.

The new CS curricular recommendations call for a heightened emphasis on parallel and distributed computing (PDC), in response to the explosive growth of multicore processors and "cloud" distributed computing. How can an educator incorporate this urgent priority into undergraduate CS courses? This panel describes four approaches: exploring GPU architecture and programming in a Computer Organization course; incorporating shared memory parallelism into several core courses; adding the PDC notion of reduction to multiple CS courses; and inserting short PDC modules into many courses at multiple curricular levels. We will illustrate how these contrasting approaches all respond to PDC recommendations within the feasibility constraint of incrementally modifying individual courses.

The emerging CS2013 Curriculum recommendations call for greatly expanded emphasis on parallel and distributed computing (PDC), in response to recent industry changes. CS2013's PDC knowledge units relate to many undergraduate courses. Participants in this BOF will consider responses to CS2013 PDC recommendations that involve multiple undergraduate CS courses at an institution, as opposed to approaches that concentrate PDC topics primarily within a single course. This sharing and brainstorming session will bring together: people having experience with a multi-course or multi-level approach to teaching PDC; people contemplating a multi-course approach to introducing PDC material; and people wishing to provide and/or hear rationale for a multi-course strategy for teaching PDC.

Map-reduce, the cornerstone computational framework for cloud computing applications, has star appeal to draw students to the study of parallelism. Participants will carry out hands-on exercises designed for students at CS1/intermediate/advanced levels that introduce data-intensive scalable computing concepts, using WebMapReduce (WMR), a simplified open-source interface to the widely used Hadoop map-reduce programming environment. These hands-on exercises enable students to perform data-intensive scalable computations carried out on the most widely deployed map-reduce framework, used by Facebook, Microsoft, Yahoo, and other companies. WMR supports programming in a choice of languages (including Java, Python, C++, C#, Scheme); participants will be able to try exercises with languages of their choice. Workshop includes brief introduction to direct Hadoop programming, and information about access to cluster resources supporting WMR. Workshop materials will reside on csinparallel.org, along with WMR software. Intended audience: CS instructors. Laptop required (Windows, Mac, or Linux).

It is no longer news that undergraduates in computer science need to learn more about parallelism. The range of options for parallel programming is truly staggering, involving hundreds of languages. How can a CS instructor make informed choices among all the options? This panel provides a guided introduction to parallelism in programming languages and their potential for undergraduate CS education, organized into four progressive categories: low-level libraries and; higher-level libraries and features; programming languages that incorporate parallelism; and frameworks for productive parallel programming. The four panelists will present representative examples in their categories, then present viewpoints on how those categories relate to coursework, curriculum, and trends in parallelism.

Parallel computing with more and more cores is here to stay. This workshop presents four independent, class-tested, primarily hands-on modules for incrementally adding parallelism in undergraduate CS courses, each requiring 1 to 3 class days and versatile for diverse courses and curricula: parallelizing loops and sharing memory on Intel's Manycore Testing lab (for a second CS course or for computer organization); parallel web crawler in Java or C++ (second CS course); parallel sorting (algorithms); À- calculus theory for communicating sequential processes (theory of computation). Workshop materials provided, drawn from CSinParallel.org. Intended audience: CS instructors. Laptop recommended (Windows, Mac, Linux).

Recent industry changes, including multi-core processors, cloud computing, and GPU programming, increase the need to teach parallelism to CS undergraduates. But few CS programs can afford to add new courses or greatly alter syllabi, and the large parallelism body of knowledge relates to many courses. Participants in this BOF will share incremental approaches for adding parallelism to undergraduate CS curricula, where students study parallel computing in brief units. This networking event/ brainstorming session/ swap meet will bring together: " people with sharable parallelism expository readings, hands-on exercises, tech support ideas, etc.; "people wishing to include such materials in their courses; and" people curious about incremental approaches to teaching parallel computing.

The reality of multicore machines as a standard and the prevalence of distributed cloud computing has signaled a need for parallel and distributed computing to become integrated into the computer science curriculum. At the same time, operating system virtualization has become a common technique with open standard tools available to any practitioners. Virtual machines (VMs) installed on available computer lab resources can be used to simulate high-performance cluster computing environments. This paper describes two such virtual clusters in use at small colleges, demonstrates their effectiveness for parallel computing education, and provides information about how to obtain the VMs for use in an educational lab setting. We have used these clusters to introduce parallelism into several courses in our undergraduate curriculum.

Given the recent emergence of multi-core and distributed computing that is transforming mainstream application areas in industry, demand is rising for teaching more parallelism and concurrency in CS curricula. We argue for teaching these topics incrementally in CS courses at all undergraduate levels, and propose a comprehensive approach involving flexible teaching modules with experiential programming exercises, technical and instructor supplementary materials, and an online community of educators to support adopters and module contributors. Progress on developing these materials and online resources is reported.

WebMapReduce (WMR) is a strategically simplified user interface for the Hadoop implementation of the map-reduce model for distributed computing on clusters, designed so that novice programmers in an introductory CS courses can perform authentic data-intensive scalable computations using the programming language they are learning in their course. The open-source WMR software currently supports Java, C++, Python, and Scheme computations, and can readily be extended to support additional programming languages, and configured to adapt to the practices at a particular institution for teaching introductory programming. Potential applications in courses at all undergraduate levels are indicated, and implementation of the WMR software is described.

MOTIVATION: To improve the ability of biologists (both researchers and students) to ask biologically interesting questions of the Gene Ontology (GO) database and to explore the ontologies by seeing large portions of the ontology graphs in context, along with details of individual terms in the ontologies. RESULTS: GoGet and GoView are two new tools built as part of an extensible web application system based on Java 2 Enterprise Edition technology. GoGet has a user interface that enables users to ask biologically interesting questions, such as (1) What are the DNA binding proteins involved in DNA repair, but not in DNA replication? and (2) Of the terms containing the word triphosphatase, which have associated gene products from mouse, but not fruit fly? The results of such queries can be viewed in a collapsed tabular format that eases the burden of getting through large tables of data. GoView enables users to explore the large directed acyclic graph structure of the ontologies in the GO database. The two tools are coordinated, so that results from queries in GoGet can be visualized in GoView in the ontology in which they appear, and explorations started from GoView can request details of gene product associations to appear in a result table in GoGet. AVAILABILITY: Free access to the GoGet query tool and free download of the GoView ontology viewer are provided to all users at http://db.math.macalester.edu/goproject. In addition, source code for the GoView tool is also available from this site, along with a user manual for both tools.

Database systems instructors face an ongoing challenge to develop meaningful assignments for their courses. We have found that instructors can successfully use large scientific datasets in teaching a database systems course to better prepare students for real-world database systems work.

Abstract Summary: TableView is a generalized scientific visualization program for exploration of various biological data, including EST, SAGE, microarray and annotation data. Written in Java, TableView is portable, is easily used together with other software including DBMSs and is versatile enough to be applied to any tabular data Availability: TableView is freely available at: http://ccgb.umn.edu/software/java/apps/TableView/ Contact: [email protected] * To whom correspondence should be addressed. † Present address: Macalester College, Mathematics and Computer Science, St Paul, MN 55105, USA.

Abstract Motivation: Protein sequence and family data is accumulating at such a rapid rate that state-of-the-art databases and interface tools are required to aid curators with their classifications. We have designed such a system, MetaFam, to facilitate the comparison and integration of public protein sequence and family data. This paper presents the global schema, integration issues, and query capabilities of MetaFam. Results: MetaFam is an integrated data warehouse of information about protein families and their sequences. This data has been collected into a consistent global schema, and stored in an Oracle relational database. The warehouse implementation allows for quick removal of outdated data sets. In addition to the relational implementation of the primary schema, we have developed several derived tables that enable efficient access from data visualization and exploration tools. Through a series of straightforward SQL queries, we demonstrate the usefulness of this data warehouse for comparing protein family classifications and for functional assignment of new sequences. Availability: Access to the MetaFam database is provided through a Java applet called MetaFamView, which can be run from the MetaFam web site at http://www.metafam.ahc.umn.edu/. Access to the relational data via named Oracle accounts can be arranged with the authors. Arrangements can also be made to obtain the data in Oracle ‘export dump’ format. Contact: [email protected] Supplementary information: The complete relational schema, integration scripts, and analysis queries are available from the authors. * To whom correspondence should be addressed.

Abstract Motivation: Protein sequence classification is becoming an increasingly important means of organizing the voluminous data produced by large-scale genome sequencing projects. At present, there are several independent classification methods. To aid the general classification effort, we have created a unified protein family resource, MetaFam. MetaFam is a protein family classification built upon 10 publicly-accessible protein family databases (Blocks\batchmode \documentclass[fleqn,10pt,legalpaper]{article} \usepackage{amssymb} \usepackage{amsfonts} \usepackage{amsmath} \pagestyle{empty} \begin{document} \(+\) \end{document}, DOMO, Pfam, PIR-ALN, PRINTS, PROSITE, ProDom, PROTOMAP, SBASE, and SYSTERS). MetaFam’s family ‘supersets’, as we call them, are created automatically using set-theory to compare families among the databases. Families of one database are matched to those in another when the intersection of their members exceeds all other possible family pairings between the two databases. Pairwise family matches are drawn together transitively to create a new list of protein family supersets. Results: MetaFam family supersets have several useful features: (1) each superset contains more members than the families from which it is composed, because each of the component family databases only works with a subset of our full non-redundant set of proteins; (2) conflicting assignments can be pinpointed quickly, since our analysis identifies individual members that are in conflict with the majority consensus; (3) family descriptions that are absent from automated databases can frequently be assigned; (4) statistics have been computed comparing domain boundaries, family size distributions, and overall quality of MetaFam supersets; (5) the supersets have been loaded into a relational database to allow for complex queries and visualization of the connections among families in a superset and the consensus of individual domain members; and (6) the quality of individual supersets has been assessed using numerous quantitative measures such as family consistency, connectedness, and size. We anticipate this new resource will be particularly useful to genomic database curators. Availability: Free access to the MetaFam web server is provided to all users at http://metafam.ahc.umn.edu/. Contact: [email protected] Supplementary information: Detailed distribution plots on MetaFam 2.0 supersets and its constituent family databases (e.g. superset/family sizes, domain boundary comparisons) are shown at http://metafam.ahc.umn.edu/mf2.0/stats.html. Statistics on the current release of MetaFam can be found at http://metafam.ahc.umn.edu/current_release/stats.html. * To whom correspondence should be addressed.

Information visualization faces challenges presented by the need to represent abstract data and the relationships within the data. Previously, we presented a system for visualizing similarities between a single DNA sequence and a large database of other DNA sequences (E.H. Chi et al., 1995). Similarity algorithms generate similarity information in textual reports that can be hundreds or thousands of pages long. Our original system visualized the most important variables from these reports. However, the biologists we work with found this system so useful they requested visual representations of other variables. We present an enhanced system for interactive exploration of this multivariate data. We identify a larger set of useful variables in the information space. The new system involves more variables, so it focuses on exploring subsets of the data. We present an interactive system allowing mapping of different variables to different axes, incorporating animation using a time axis, and providing tools for viewing subsets of the data. Detail-on-demand is preserved by hyperlinks to the analysis reports. We present three case studies illustrating the use of these techniques. The combined technique of applying a time axis with a 3D scatter plot and query filters to visualization of biological sequence similarity data is both powerful and novel.

Biological sequence similarity analysis presents visualization challenges, primarily because of the massive amounts of discrete, multi dimensional data. Genomic data generated by molecular biologists is analyzed by algorithms that search for similarity to known sequences in large genomic databases. The output from these algorithms can be several thousand pages of text, and is difficult to analyze because of its length and complexity. We developed and implemented a novel graphical representation for sequence similarity search results, which visually reveals features that are difficult to find in textual reports. The method opens new possibilities in the interpretation of this discrete, multidimensional data by enabling interactive investigation of the graphical representation.