scaling a framework for client-driven open source software projects

SCALING A FRAMEWORK FOR CLIENT-DRIVEN OPEN SOURCE SOFTWARE PROJECTS: A REPORT FROM THREE SCHOOLS * Bonnie K. MacKellar Division of Computer Science, Mathematics and Science St. John's University Queens, NY 11439 (718) 990-7452 [email protected]

Mihaela Sabin Computing Technology Science &Technology Division University of New Hampshire Manchester, NH 03101 (603) 641 4144 [email protected]

Allen Tucker Computer Science Department Bowdoin College Brunswick, ME 04011 (207) 729-8111 [email protected]

ABSTRACT While large ongoing humanitarian open source software (HFOSS) projects are often seen as a way to engage students in capstone courses, they can be difficult to incorporate into an academic setting. One way this problem can be mitigated is by growing student-oriented open source projects within academia while still involving real world clients. One such project, called Homebase, involved a team of students working with a local Ronald McDonald House to develop volunteer scheduling software. In true open source fashion, this project has since been extended over a number of course iterations, with different clients, and has been adopted at other schools. In this paper, we report on our experiences using this approach for similar projects at three quite different schools, and discuss ways to adapt and enhance this approach for differing student populations.

___________________________________________ *

Copyright © 2013 by the Consortium for Computing Sciences in Colleges. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the CCSC copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Consortium for Computing Sciences in Colleges. To copy otherwise, or to republish, requires a fee and/or specific permission.

140

CCSC: Northeastern Conference INTRODUCTION There is a lot of interest in integrating both client driven and humanitarian open source software project experiences into capstone courses for computing majors. Such projects expose students to real world practices and increase interest and commitment since the students see their projects actually being used in the “real world.” However, as discussed in [1][2], it is a challenge to find appropriate clients and open source projects, develop faculty expertise in open source development methods, and then create, plan, and manage student projects that are integrated within one-semester courses. We believe that these challenges can be met by growing student-oriented open source projects within academia that serve the needs of local non-profit organizations who act as project clients. This was the approach taken by the Homebase project, which was first developed under the auspices of the Humanitarian Free and Open Source Software (HFOSS) project [2], and in collaboration with a local Ronald McDonald House. A major goal of the HFOSS project is to build collaborations among schools and engage students in building authentic, socially-relevant software projects. In true open source fashion, this approach has since been extended over multiple course iterations with different clients, and has been adopted at other schools. After attending HFOSS workshops together, the authors decided to collaborate and incorporate projects using the Homebase model in their software development courses. The authors’ schools have notable differences. Bowdoin is a small, residential, highly selective national liberal arts college. UNH-Manchester is a public college that serves commuter students. Most students enroll full-time while holding down outside jobs. Two thirds of the students qualify for financial aid, and close to three fourths of the computing students transfer from local community colleges and other schools. St. John’s University is a large urban Catholic university whose students are ethnically diverse; a large percentage are Pell-eligible and first in their family to attend college. Many students work off campus or have significant family responsibilities. In this experience report, we address the following question: can an approach like Homebase offer benefits to highly competitive computing programs and at the same time scale to programs with students who face challenges in terms of academic preparation, study time, and support outside of school? We present our efforts to extend and replicate the Homebase model at our institutions. In the following sections we describe and compare our experiences and outcomes. In particular, we discuss what we did to meet both the needs of our local clients and the needs of our differing student populations. Finally, we make recommendations on growing student-oriented HFOSS projects across diverse schools and computing programs. A CLIENT-DRIVEN OPEN SOURCE SOFTWARE FRAMEWORK History The original Homebase project involved a student team working with a local Ronald McDonald House to develop volunteer scheduling software. Its architecture was later reused in another project, Homeroom, which handled room scheduling at the Ronald McDonald House. These projects, implemented in PHP, HTML, and MySQL, make up 141

JCSC 28, 6 (June 2013) a code base and layered architecture which are freely available under an open source license. The architecture includes: 1) database modules which mediate access between users and the database; 2) domain classes which represent the persistent entities of the system; 3) user interface modules which implement the functionality that end users see; 4) an online help tutorial; and 5) unit tests. The Homebase and Homeroom projects were developed using agile software development practices. Each project had weekly milestones and follow-up meetings with the client. Development was intensely collaborative, aided by use of videoconferencing, online issue tracking, a version control system, and a “sandbox” server that hosts the software to be viewed by the client. Use of agile practices allows these projects to be easily adapted to new settings. Upgrading and Creating New Projects The Homebase approach has been used at Bowdoin since 2008. Most recently, the Spring 2012 course developed three new projects: Homebase 3.0, Homecheck, and Homeplate. Each team had three student members, a client representative, and the instructor as project leader. Homebase 3.0 is a major extension of Homebase, with new requirements provided by the Ronald McDonald House in Portland, ME. Homecheck is a new system for People Plus and the Police Department in Brunswick, ME that helps volunteers track call-ins from persons living alone. Homeplate is a new client-server system and Android tablet app for Second Helpings, a food rescue organization in South Carolina. Each team began with a requirements document and initial code base, and subsequently learned about updating a shared code repository, unit testing, collaborating with the client, debugging, and documentation. All project milestones were met by the Homecheck and Homeplate projects, while the Homebase project experienced some difficulties due to a change in requirements by the client. As a result, the reorganized Homebase project did not meet all of its milestones. The software for Homebase has since been completed and installed at the Ronald McDonald House in Portland, ME. The software for Homecheck has been installed for testing at People Plus in Brunswick, ME. The software for Homeplate was put into production in early September 2012. The outcomes of this course were very positive. Students gave the course strong evaluations (averaging 4.7 out of a possible 5), and went out of their way to acknowledge the value of working on a “real world” project as a strong motivator for learning. Clients unanimously praised the dedication and effectiveness of students working on their behalf.

REPLICATING AND SCALING THE FRAMEWORK Project Experience at UNH-Manchester In the computing program at UNH-Manchester, close to 70% of the undergraduates have more than 50 credits transferred from local two-year colleges into the program’s BS CIS major. The major requirements include: an introductory programming course in Java; a database course that uses SQL; a two-course sequence in web authoring (with HTML, 142

CCSC: Northeastern Conference CSS, PHP and JavaScript); and an object-oriented software development course. Student preparedness for developing software applications is uneven. Some of this can be traced back to their prior experience, where 1) projects were individual endeavors, 2) student exposure to FOSS principles and practices was limited or non-existent, and 3) prior programming experience did not include algorithm design and using abstraction to tackle more complex problems. An overarching challenge for UNH-Manchester’s computing program is a collection of hard constraints placed on students by their work, family obligations, and other commitments. When time on campus is reduced to class meetings only, students are forced to do project work once a week, typically the night before the class meeting, with almost no time to coordinate their work with other team members. In Spring, 2012, the Homebase approach was used in an upper-level elective course in the Web Application Development course. Eleven students enrolled in the course: four undergraduate CIS majors, two graduate IT majors, and five continuing education students. The continuing education students were engineers from a local company in Manchester, who were interested in open source technologies and gaining experience developing web-based services for their company’s in-house applications. The client was YWCA of Manchester, with whom the UNH-Manchester program had collaborated since Fall 2008 on various projects and student service learning activities. The project addressed the client’s need for an information system that tracks donations from individuals and organizations. Like the other nonprofits mentioned in this paper, YWCA cannot afford to buy software and pay developers or consultants. Open source is the only feasible approach that they have for developing a donation tracking system. At the beginning of the semester, the project’s prototype had a code base with the same layered architecture as the Homebase software. The project was a combined result from two other courses with student projects of smaller and dedicated scope – one database course and one web authoring course, both at sophomore level. The prototype’s back-end had a functional MySQL database, although incomplete, with a well-designed schema, sample data, and scripts to install, populate, and query the database. The frontend had a single use case implemented, i.e., viewing donors and searching donors by name. The prototype was staged on a virtual machine that runs on UNH-Manchester’s server. The code base is hosted by Google Code. In the first half of the semester students learned how to develop an open source client-based project through a variety of activities: 1) experimenting with the Homebase and Homeroom projects in the textbook [3]; 2) meeting with the YWCA business director to get clarifications on the system requirements; 3) learning from three experienced FOSS developers who joined the class via Skype; 4) receiving feedback and having their work reviewed by the software engineers who were auditing the class; and 5) doing assignments that provided practice with: PHP and SQL, model-view-controller architectural pattern, techniques for specifying requirements and design decisions, XAMPP run-time environment configuration, and a comprehensive development toolkit (Eclipse PHP, Xdebug, Doxygen, SimpleTest, and Balsamiq). In addition, project forum, wiki, and hosted project version control and issue tracking supported teamwork and collaboration. The code base became the “common denominator” for all design and implementation decisions. That is why the assignments were grounded in the code base and allowed students to learn first-hand about the developer roles needed for the project. 143

JCSC 28, 6 (June 2013) By the time the six week-long project sprints occurred in the second half of the semester, students understood well the roles they would assume to maximize their contributions to the project. At UNH-Manchester, the Homebase approach yielded several good outcomes. First, having continuing education engineers as observers allowed creation of the role of configuration manager, who was the most active and involved student during class meetings. These observers also participated in client meetings, reviewed and gave feedback on use cases, database and UI design, and code quality. Students also learned from one of the invited speakers about the Asana service for project management activities, which they ended up using for issue tracking. Project Experience at St. John’s University At St. John’s University, the Homebase approach and the Homeroom codebase were used in a required software engineering course in Spring, 2012 and again in Fall 2012. The students worked with the Ronald McDonald House of Manhattan on a room scheduling system similar enough to the original Homeroom project that much of its overall architecture could be reused. However, there were also significant differences in requirements, which meant that the database schema and much of the GUI and business logic had to be rewritten. The 25 students coming into this course faced a number of challenges. Similar to the situation at UNH-Manchester, few of them had ever written a program longer than a hundred lines, and none had ever collaborated with another student on a software project. The Homeroom software was written in PHP, a programming language with which most of the students had little experience. Several expressed low confidence in their programming skills at the beginning of the course. A central concern in this course was to fill in their missing skills at the same time they were developing requirements and a system design for the project. Thus, students were not able to begin project implementation until about halfway into the course. The course was run using a multi-role, whole-class organization. This organization worked well because it provided roles for students with less programming preparation. We placed students into groups organized by the project architecture. To enable communication, we used a Google discussion list and directed all automated commits, issue tracker notices, and student discussions, to that list. This worked well because the class met only once a week and many students did not come to campus on other days. To teach students the skills they would need for the project, the first half of the semester provided in-class labs on the basics of PHP, version control, and databases. Students also wrote a requirements document that captured the needs of RMH Manhattan. After that, students began to implement the project. The outcome for this semester was that students finished the infrastructure, but were unable to bring a fully functional system to completion. However, there was enough functionality that they were able to demo the system at RMH Manhattan. During the Fall of 2012, another group of students taking the same course are completing the project. A two-part survey was administered to students at the end of the Spring 2012 course to determine which components had worked and which had not. Students were also asked 144

CCSC: Northeastern Conference to name the course topics that they felt were most difficult, most important, and least important to their careers, as well as the topics they had learned the best. Out of 20 surveys, half chose group communication as the topic they had learned best and almost half (9) felt that web programming (PHP) was the most difficult topic. Group communication was also mentioned by 4 students as being most difficult. Two representative comments on the “most difficult” question were: “Web programming – unfamiliar with PHP, need more labs and guidance," and “communication – some people were not on top of things/uncaring, miscommunication." The main takeaway was that many students felt overwhelmed by the need to learn so much material and, in particular, how to work as a team. However, they also expressed pride in developing software that would be used by an organization that many students admired greatly. This may have been the reason that the students made more progress on this project than similar students had made in previous iterations of the course that did not offer projects for real clients. Based on these results, the Fall 2012 course has been modified to incorporate more labs on PHP and more scaffolding. Since the students are now adding specific functionality to existing code and fixing bugs, their tasks are better defined and we anticipate better outcomes. In addition, we have added a new prerequisite course which will cover more sophisticated software design skills, open source development strategies, and the use of collaboration tools. SUMMARY AND LESSONS LEARNED It is clear to us that the Homebase approach works well across differing computing student populations. In all three schools, using a common architecture, codebase, and HFOSS practices has led to better outcomes in project-based courses. At Bowdoin, these projects have been run successfully since 2008, developing a wealth of experience and satisfied clients. UNH-Manchester has used this model with success since 2010. And at St. John’s University, with only one semester of experience, students made far more progress on the HFOSS-oriented project than in the past with more traditional approaches. Our experiences also raised several challenges: Implementing an HFOSS project at schools where students have more challenges such as commuting and working long hours outside of class requires modifications to the approach. Students who have lower confidence in programming are less likely to respond productively to teaching themselves new languages and skills, and thus need more scaffolding. Teaching in this manner always requires a significant time investment by the instructor. At Bowdoin, this was exacerbated because the instructor tried to accomplish three projects in one semester. At UNH-Manchester and St. John’s University , the instructors spent copious amounts of time introducing students to open source practices, software tools, and programming issues. The presence of an existing code base can be both a blessing and a curse. On the one hand, the code base provides an organizational structure and code that student developers can creatively reuse to solve similar problems on the new project. On the other hand, some of the code must be tweaked so much that it would have been better to rewrite from scratch. 145

JCSC 28, 6 (June 2013) It is more difficult for a student team to add new features to an existing code base than to develop a new code base from a minimum set of domain classes. This was the case with Homebase 3.0, which began with the original Homebase code base. There, students spent significant time reading and refactoring the code so that it would pass new unit tests. Follow-up for client-centered projects is critically important. The natural constraints of a one-semester course prevent the kind of refinement and field-testing that is important when deploying a software artifact for production use. So at the end of the semester, some commitment must be made to ensure that the software is properly deployed and supported. Tutorial materials and in-class labs seem to have low impact on the development of open source skills. Extensive scaffolding is needed because of large scope of the material and highly collaborative approaches. Using Homebase helps in many ways because it provides a ready-made framework; however it is not always enough. Student use of version control systems and communication tools is, at times, sporadic. They tend to revert to the traditional, “develop-in-a-silo” methods that they use in other courses on a regular basis. Some have difficulty communicating comfortably with teammates, while others need assistance learning how to phrase questions about technical material. Using the Homebase approach for HFOSS project-based courses has worked well at three different schools, albeit with modifications for local conditions. For UNHManchester and St John’s University, piggybacking on an existing approach and codebase made the task of developing a client-project course far easier than if we had tried to develop our projects completely from scratch. Using an open source codebase and architecture that had been developed in an academic course strikes a desirable balance between relying on a traditional self-contained toy project and engaging students in an industrial-strength full-scale open source project, such as Fedora or Firefox. A promising finding is that schools have the opportunity to share and make HFOSS contributions in two ways, by (1) creating new, fully-developed, exemplary projects to extend the current collection, and (2) integrating and adapting existing projects to scaffold learning, improve skills, and empower learners with diverse academic backgrounds, talents, and life experiences. We are hopeful that the Homebase approach will continue to expand and evolve and that similar HFOSS projects will propagate from other schools. REFERENCES [1] H. J. C. Ellis, M. Purcell, and G. W. Hislop, “An approach for evaluating FOSS projects for student participation,” Proceedings of the 43rd ACM Technical Symposium on Computer Science Education - SIGCSE ’12, p. 415, 2012. [2] Morelli, R., T. de Lanerolle, and A. Tucker, “The HFOSS Project: Engaging Students in Service Learning through Building Software,” Chapter 5 in Nejmeh, B (ed), Service Learning in the Computer and Information Sciences, Wiley and IEEE Press, 2012.

146

CCSC: Northeastern Conference [3] Tucker, A., R. Morelli, R., and C. de Silva, Software Development: An Open Source Approach, CRC Press, Boca Raton, 2011.

147