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.

Team-based capstones are a cornerstone of computing education, designed to prepare students for professional computing practice. The rapid adoption of Generative AI (GenAI) is reshaping how students plan, implement, test, and document their capstone work, raising new questions about workflows, team dynamics, assessment practices, and graduate readiness for using GenAI in the workplace. This Working Group (WG) investigates how GenAI is influencing capstone design and practice from the perspectives of students, early-career graduates, instructors, and employers. Using a mixed-methods approach, including a scoping literature review, cross-institutional surveys, and semi-structured interviews, the WG will examine how GenAI is currently integrated into capstone courses, how students use and perceive GenAI across the project lifecycle, how instructors are adapting task design, supervision, feedback, and assessment, and how employer expectations for GenAI competencies align with university preparation. The ultimate goal is to produce evidence-based guidance that helps educators realign capstone experiences with the realities of GenAI-integrated professional computing practice.

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.

This is a hands-on laptop-recommended workshop that introduces participants to the PLCC compiler-compiler tool set for building Java-based language interpreters in an upper-level Programming Languages course. Our approach to teaching this course shows how programming language features such as language syntax, variable lifetime, procedure application, parameter passing, recursion, and object-orientation are implemented "under the hood". This workshop is designed for CS educators who want to explore how PLCC can be used to support such an approach.

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.

Student involvement in Humanitarian Free and Open Source Software (HFOSS) increases student self-reported learning while providing the motivation of "doing good" [11]. Supporting this type of student participation also impacts the instructors. This effect includes modifying one's teaching approach, providing a different perspective on the subject matter, and changing how instructors perceive their roles. This paper explores the impact on instructors that result from supporting student participation in HFOSS, including consideration of pedagogical practices, self-perceptions of teaching, and exposure to open source culture and technologies. The paper also examines resources that instructors consider important for HFOSS education. The analysis presented here is based upon a qualitative analysis of semi-structured interviews with 24 faculty members. Results indicate that exploring HFOSS education changes instructors' pedagogical approaches, broadens instructors' perspectives on the connections between academic content and professional practice, and has impact on instructors' attitudes and motivations when teaching.

Student participation in Humanitarian Free and Open Source Software (HFOSS) projects offers great learning opportunities for students, including: designing, coding, testing, documentation, collaboration and other professional skills. Humanitarian projects also foster understanding of computing's potential social impact. However, working with any open source project -- including HFOSS projects - presents some challenges to instructors. Identifying appropriate assignments, creating meaningful rubrics, mapping the academic schedule to a project's release cycle, and eliciting engagement from the HFOSS project community are just a few of the potential hurdles to overcome. This BOF will be led by a diverse group of faculty who have encountered and overcome these challenges. The organizers and other attendees will share approaches to student involvement in HFOSS as well as the challenges they've encountered and how they've overcome them. Faculty who are interested in involving students in real-world projects will be able to ask about topics including use of HFOSS in a range of courses including introductory courses, project selection, structuring courses and assignments, and gaining university buy-in, while making connections with more experienced faculty in this area. Participation of an open source community member will add perspective from open source communities.

Can students contribute to HFOSS projects as part of their computing curriculum? How and at what level can HFOSS be integrated? What are the success stories and challenges? This BOF will be led by a diverse group of faculty who have incorporated HFOSS into their classes. They will lead a discussion on the various approaches, successes and challenges they have encountered. Their experiences will provide a backdrop for this BOF session, which should lead to a lively discussion of how and why to use HFOSS in computing courses. Faculty who are interested in HFOSS, but who are novices, will learn about potential projects and classroom materials as well as make connections with more experienced faculty in this area.

Providing students with the professional, communication, and technical skills necessary to contribute to an ongoing software project is critical, yet often difficult in higher education. Involving student teams in real-world projects developed by professional software engineers for actual users is invaluable. Free and Open Source Software (FOSS) has emerged as an important approach to creating, managing, and distributing software products. Involvement in a FOSS project provides students with experience developing within a professional environment, with a professional community, and has the additional benefit that all communication and artifacts are publicly accessible. Humanitarian Free and Open Source Software (HFOSS) projects benefit the human condition in some manner. They can range from disaster management to microfinance to election-monitoring applications. This article discusses the benefits and challenges of students participating in HFOSS projects within the context of undergraduate computing degree programs. This article reports on a 6-year study of students' self-reported attitudes and learning from participation in an HFOSS project. Results indicate that working on an HFOSS project increases interest in computing. In addition, students perceive that they are gaining experience in developing software in a distributed environment with the attendant skills of communication, distributed teamwork, and more.

Curriculum guidelines for both Computer Science and Software Engineering emphasize the need for student experience working on a sizeable, real-world project. This poster presents student experience in a Humanitarian Free and Open Source Software (HFOSS) project that is jointly maintained by the GNOME Accessibility Team and three academic institutions. In this environment, students enjoy apprenticeship learning and learn directly from professionals within an active project. Results from a survey on student self-reported software engineering learning, attitude towards computing, and career plans are presented.

Have you ever wanted your students to contribute to or learn from a real-world software project that benefits society? Want some help getting started? Many students find involvement in Humanitarian Free and Open Source Software (HFOSS) projects engaging and motivating. As a first step, this workshop will introduce faculty to FOSS tools and culture. Through a virtual field trip into the world of HFOSS you will learn how to find a project, discern characteristics of a good project for student participation and understand how to use IRC, a communication tool used by FOSS developers. The use of version control to support project development will also be discussed. Along the way, you will learn how to support student learning in such projects. All topics will be covered at an introductory level. Participants will take away exercises that can be used in the classroom. Additionally, participants will have access to support in the creation of assignments or curriculum and their implementation from teachers experienced in supporting students in HFOSS participation. Additional information at: http://www.foss2serve.org/index.php/SIGCSE_2014_Workshop Laptop required.

Programming contests have been used at the high school level to motivate students to study computing and generate excitement about computing topics. However, little investigation has been done into whether the selection of programming language impacts success in such contests. This poster presents the results of an analysis of five years of high school contest results held at Western New England University. The analysis looks at the languages used by winning teams and number of submissions. Results appear to indicate that winning teams use Java and Python for programming languages while less successful teams use BASIC, VisualBasic and C++. Interestingly, the majority of teams used BASIC as their programming language. Another interesting result was that low performing teams tend to have a disproportionately large number of submissions.

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.

Humanitarian Free and Open Source Software (HFOSS) projects provide a real-world application with an approachable and welcoming community for both faculty and students. Many faculty members are excited by the prospect of their students contributing to HFOSS. They perceive it as an opportunity to engage students, regardless of race or gender, in projects that have societal impact. However trying something new in the classroom though can be daunting, and many barriers to entry exist. Locating an appropriate project, trying to figure out how to incorporate a dynamic, real-world project into the curriculum and learning how to interact with the project's community each present their own set of challenges. This BOF provides a gathering place for faculty who are interested in student participation in FOSS or HFOSS. The discussion will include an overview of an NSF-funded project, OpenFE. The goal of OpenFE is to develop faculty expertise in working with HFOSS projects and to develop curriculum materials that support faculty members in bringing this approach into their classrooms. The members of the OpenFE team will discuss plans for this grant and welcome both novices and experienced contributors to join us and provide feedback.

Many institutions are considering offering a course on mobile application development to harness its popularity to attract new majors, retain those we have, and to motivate learning. The panelists present four experiences in teaching a mobile application development course. They share their experiences in an effort to start a discussion about mobile application development in computing curricula. In the first half of the session, each panelist presents their experience including: an overview of the course; its audience, position in the curriculum, and pre-requisites; the platform, language, and development environment used; positives about the course; and roadblocks and negatives about the course. This provides a foundation for an audience directed discussion in the second half.

Some "non-" or "extra-functional" features, such as reliability, security, and tracing, defy modularization mechanisms in programming languages. With distributed, heterogeneous (DH) systems, these features induce complex implementations which crosscut different languages, OSs, and hardware platforms, while still needing to share data and events. The DADO approach helps program crosscuting features by improving DH middleware. A DADO service comprises pairs of adaplets which are explicitly modeled in IDL. DADO supports flexible and type-checked interactions (using generated stubs and skeletons) between adaplets and between objects and adaptlets. Adaptlets can be attached at run-time to an application object.

Some "non-" or "extra-functional" features, such as reliability, security, and tracing, defy modularization mechanisms in programming languages. This makes such features hard to design, implement, and maintain. Implementing such features within a single platform, using a single language, is hard enough With distributed, heterogeneous (DH) systems, these features induce complex implementations which cross-cut different languages, OSs, and hardware platforms, while still needing to share data and events. Worse still, the precise requirements for such features are often locality-dependent and discovered late (e.g., security policies). The DADO/sup 1/ approach helps program cross-cutting features by improving DH middleware. A DADO service comprises pairs of adaplets which are explicitly modeled in IDL. Adaplets may be implemented in any language compatible with the target application, and attached to stubs and skeletons of application objects in a variety of ways. DADO supports flexible and type-checked interactions (using generated stubs and skeletons) between adaplets and between objects and adaplets. Adaplets can be attached at run-time to an application object. We describe the approach and illustrate its use for several cross-cutting features, including performance monitoring, caching, and security. We also discuss software engineering process, as well as run-time performance implications.

Software developers writing new software have strong incentives to make their products compliant to standards such as CORBA, COM, and Java Beans. Standards compliance facilitates interoperability, component based software assembly, and software reuse, thus leading to improved quality and productivity. Legacy software, on the other hand, is usually monolithic and hard to maintain and adapt. Many organizations, saddled with entrenched legacy software, are confronted with the need to integrate legacy assets into more modern, distributed, componentized systems that provide critical business services. Thus, wrapping legacy systems for interoperability has been an area of considerable interest. Wrappers are usually constructed by hand which can be costly and error-prone. We specifically target command-line oriented legacy systems and describe a tool framework that automates away some of the drudgery of constructing wrappers for these systems. We describe the Cal-Aggie Wrap-O-Matic system (CAWOM), and illustrate its use to create CORBA wrappers for: a) the JDB debugger, thus supporting distributed debugging using other CORBA components; and b) the Apache Web server, thus allowing remote Web server administration, potentially mediated by CORBA-compliant security services. While CORBA has some limitations, in several relatively common settings it can produce better wrappers at lower cost.