This poster presents an analysis of student learning of basic workflow process for GitHub. It draws on data gathered by GitKit, a learning environment that supports the development of fundamental GitHub skills widely used in contemporary software development. The poster discusses the purpose and facilities of GitKit and presents an analysis of data from use of GitKit at multiple institutions. This analysis focuses on student misconceptions and strategies in trying to execute basic GitHub workflows.

Although Git is the most popular version control system used in software development it is not explicitly taught in many Computer Science degree programs. Those who do teach it face challenges in helping students understand the concept of version control, the commands students use to perform various actions as well as a workflow for collaborative software development. This panel will present four approaches for teaching Git, providing an overview of each approach, how it helps students learn Git and the challenges both students and faculty encounter using it. GitKit is a containerized version of an open source project where students work through the full workflow from forking a project to having a pull request accepted. The Shell Tutor provides a constraint-based tutoring system inside the student's command-line environment. GitHub Education provides short, free courses that introduce students to the basics of GitHub and workflow concepts. OSSDoorway teaches a GitHub workflow using a gamified, quest-based environment to support a first contribution. The session is designed to allow ample time for attendees to ask questions to determine how various approaches might be helpful in their context. Panelists will provide links to their approaches so attendees can further investigate them after the session.

This poster presents new developments related to GitKit, a scaffolded environment that supports both students and instructors in developing fundamental skills related to Git-based platforms like GitHub that are widely used in contemporary software development. The poster discusses the purpose and facilities of GitKit, including new capabilities, and preliminary data collection to analyze student skill development in learning GitHub tasks.

The aim of this tutorial is to teach faculty the fundamentals of Git and GitHub using the GitKit. The GitKit is a snapshot of the artifacts (codebase, issues, etc.) of an authentic Free and Open Source Software (FOSS) project, packaged with learning activities, an instructor guide, and a cloud-based development environment. The GitKit's learning activities introduce a GitHub workflow and Git basics by modeling the process of contributing to an authentic FOSS project. The activities introduce not only Git and GitHub, but also provide exposure to how these tools support the needs of Open Source (and commercial) development practices. The majority of the tutorial time will be dedicated to hands-on learning with the GitKit. Participants will work in small groups to complete key activities from the GitKit to learn both Git and GitHub fundamentals, and to see what their students would experience while using the GitKit. This will include an introduction to FOSS community principles, roles and practices as well at basic Git commands and GitHub workflow. The tutorial will conclude with information about how participants can deploy the GitKit as a short (1-2 session) or medium (4-6 session) length module in software development courses ranging from high school through college. A laptop is required for participants.

Modern version control tools and workflow practices are required skills for nearly all production software development, making them essential for students and in high demand among employers. Since these tools and processes were created for distributed, asynchronous collaboration on large scale projects, teaching them in an authentic context that makes clear their utility and design presents myriad challenges for both faculty and students. The GitKit is a snapshot of the FarmData2 Humanitarian Free and Open Source (HFOSS) project's artifacts (code, issues, documentation, etc.) frozen at a particular point in time and packaged with learning activities, an instructor guide, and a choice of containerized development environments. The GitKit thus provides students with the authentic context of a real-world project in which to learn and practice key Git and GitHub skills and workflows, while mitigating many of the challenges of doing so in an educational setting. The GitKit, including its learning activities and development environments are described in sufficient detail to encourage instructor adoption and feedback. A pilot study of student experiences with the GitKit is promising, suggesting that students gained an understanding of FOSS concepts and key skills, noticed automated guidance and feedback built into the development environment, and found it helpful in their learning. Future plans for the GitKit based on these surveys and instructor experiences with pilot uses are described along with plans for the development of HFOSS Kits for teaching and learning of other software development and aligned skills in authentic contexts.

Free and Open Source Software (FOSS) is interesting to many students and provides an excellent opportunity to observe and practice many aspects of software product development and management. FOSS projects can motivate many software engineering concepts by providing scale, complexity, and on-going product evolution that is difficult to mimic in classroom-only materials. Open source projects have been a major source of innovation in software engineering and many FOSS projects provide excellent case studies of advanced practices in action. Finally, FOSS projects motivate students by providing an authentic, collaborative engagement environment for learning. This BoF will provide an opportunity for instructors to discuss successes and challenges of teaching open source (TOS) in undergraduate computing programs. The discussion topics will include: fitting TOS in an already full curriculum, types of TOS learning activities that can be shared, instructor preparation and getting started teaching open source.

Engaging students in free and open source software (FOSS) is educationally rewarding but challenging. We aim to ease student engagement and faculty use by developing HFOSS (Humanitarian FOSS) Kits. An HFOSS Kit is a snapshot of an HFOSS project at a particular point in time, packaged with student learning activities, instructor guide, and containerized development environment (if necessary). HFOSS Kits in the classroom have several advantages. While active projects change and evolve, an HFOSS Kit enables a stable, reusable educational experience. Student learning activities and instructor guides are written against the stable project snapshot, thus the high cost of developing and revising activities and guides can be amortized by reuse across multiple semesters. Students are engaged in a more authentic learning experience as they develop their FOSS skills and concepts using actual projects, rather than typical, single-semester examples. The containerized development environment facilitates immediate context-sensitive feedback as students complete assignments. The instructor or automations built into the kit can simulate community interaction. Finally, a focus on HFOSS projects has the potential to broaden the appeal of learning FOSS skills. In our demonstration, we will expand upon the Kit details and reasons for using one. We will demonstrate GitKit - a kit for teaching Git and GitHub/Lab workflow, what it provides, and how it can be used in the classroom. We will also explain the Kits' technical architecture, tools developed to capture the snapshot of project artifacts and support Kit building, and future development plans. Keywords: Tools; Authentic Learning; Open Source

Engaging students in humanitarian free and open source software (HFOSS) projects allows them to gain real-world software development skills while helping society. Participating in an existing HFOSS project, although ripe with learning opportunities, presents a number of hurdles for faculty and students. An alternative to joining an existing HFOSS project community is to participate in a faculty-led HFOSS project. These projects provide the instructor with more control over the learning environment, but often lack an active community outside of the classroom. This paper describes a multi-institutional effort to engage a community of developers in creating humanitarian open source projects to support their on-campus food pantries. Food insecurity on campus has become a national concern and many institutions have, or are starting, food pantries to support the student, staff, and faculty community. Starting a faculty-led HFOSS project involves making decisions not only about the features of the project but also about community norms, tool choices, project development workflow, and inter-institution cooperation. This paper provides an overview of the creation of LibreFoodPantry, a community who is developing a suite of projects that support on-campus food pantries. It describes instances of using LibreFoodPantry's projects in various classroom settings, the lessons learned from these experiences, and the resulting discussions and decisions made by the LibreFoodPantry Coordinating Committee. This process has led to a community dedicated to easing the on-ramp for faculty who want to help their students contribute to an HFOSS project.

This special session is intended for people who are curious about integrating Humanitarian Free and Open Source Software (HFOSS) into their courses and involving students in HFOSS projects. HFOSS participation provides an excellent vehicle to introduce students to computing for social good while also giving them experience with real-world software development. The session will begin with a series of lightning talks by faculty who have incorporated HFOSS participation into one or more of their courses. This will be followed by a small group activity to allow attendees to ask questions and discuss individual interests in integrating HFOSS activities and to become familiar with HFOSS educational resources available for instructors. The session will conclude with some closing comments on current and planned activities of instructors who are teaching with HFOSS and suggestions for faculty who would like to pursue this teaching approach themselves.

Integrating Free and Open Source Software (FOSS) into our curricula can provide students with a rich, motivating learning experience that helps them develop technical as well as soft skills. However, integrating FOSS into curricula does have its challenges. This birds-of-a-feather (BoF) seeks to bring together faculty to discuss challenges, share resources, share solutions, and make connections. So, whether you are considering integrating FOSS into a class for the first time, or you are looking for ways to improve what you are already doing, this BoF is for you. Members of the Teaching Open Source (http://teachingopensource.org) and the foss2serve (http://foss2serve.org/) communities will help guide the discussion and be on hand for questions.

Participating in free and open source (FOSS) software communities provides students with authentic learning while supplying instructors with a wide variety of educational opportunities including coding, testing, documentation, professionalism and more. However, instructors may be unfamiliar with how FOSS communities work and therefore may be reluctant to involve students in such communities. This workshop is a subset of material used in Red Hat's Professors' Open Source Summer Experience (http://communityleadershipteam.org/posse) workshop, now in its third year of successfully providing a ramp to FOSS projects for instructors. These instructors have demonstrated success in involving their students in FOSS communities where students have contributed code, interface design, and more. Intended audience: Computing educators at the college or high school level interested in involving students in open source software projects in any capacity (testing, coding, documentation, design, project management, observational shadowing of a large-scale project, etc). The workshop may also be of interest to pre-high school computing educators and members of the open source community. No experience with open source communities or contribution is necessary.

Involving students from a wide range of backgrounds in Free and Open Source Software (FOSS) project communities gets them a hands-on, portfolio-building experience in the creation of a real-world project while simultaneously building their institution's public profile. The Teaching Open Source (http://teachingopensource.org) community is an emergent (3 year old) group working on scaffolding to bridge the cultural differences between academic and FOSS communities of practice. Join us to share questions, challenges, and triumphs of incorporating FOSS participation into existing and new curricula as well support resources for doing so. Alumni and current members of the POSSE (Professors' Open Source Summer Experience, http://communityleadershipteam.org/posse) will attend in mentorship roles. Faculty attendance at the SIGCSE 2010 BoF on Teaching Open Source (TOS) indicates that student involvement in FOSS projects is a teaching and learning approach of interest for many faculty members. The transparency of both artifacts and process make FOSS an attractive real-world experience that enhances peer learning and intrinsic motivation for a diversity of courses, from introductory, interdisciplinary, and non-major classes to software engineering core offerings and senior capstones. However, such student participation involves a significant learning curve and effort on the part of the faculty member, and support structures for faculty are still maturing. 2011-2012 marks the 3rd academic year the TOS community has explored this realm together, and the past year has seen the emergence of more best practices, support resources, and curricular material. Community members are starting to design cross-institutional research on the impact of FOSS participation on students. BoF attendees will be encouraged to ask questions, network, and take advantage of the TOS community as a support structure for their own courses and projects.