|1. Description - |
|This course is an introduction to the tools for, and culture of, contributing to open source software projects. Tool-based topics include Git repositories, pull requests, forks, logs, merges, tagging, rebasing and server configuration . Concept topics include commit guidelines, branching workflows, small-team vs. large-team workflows, project maintenance, iterative staging, selecting viable source communities, joining public projects, setting up accurate dev environments, testing and prepping patch merges, and becoming a committer.|
|Advisory: 15 units of Computer Science core courses and C S 40A.|
|2. Course Objectives - |
|The student will be able to: |
- Install a Git client repository (repo).
- Perform the basic Git commands of repository check-in and check-out.
- Use the Git log to reveal differences in version snapshots.
- Pull-from and push-to remote repos.
- Tag commits for version tracking.
- Perform the all the commonly used branching commands.
- Explain different styles of branching workflows.
- Set up a Git server.
- Describe the main aspects of collaborative project participation.
- Demonstrate a mastery of Git project maintenance tools.
- Use Git tools such as stashing and iterative staging.
- Select a viable open source project for contribution.
- Research the project culture and duplicate the development environment locally.
- Identify a problem or bug that needs fixing.
- Explain how to become a project committer.
- Establish a term project and demonstrate successful milestones leading toward an open source contribution.
|3. Special Facilities and/or Equipment - |
- The college will provide access to a computer laboratory with language compilers and internet connectivity.
- The college will provide a website or course management system with an assignment posting component (through which all lab assignments are to be submitted) and a forum component (where students can discuss course material and receive help from the instructor). This applies to all sections, including on-campus (i.e., face-to-face) offerings.
- When taught via Foothill Global Access on the Internet, the college will provide a fully functional and maintained course management system through which the instructor and students can interact.
- When taught via Foothill Global Access on the Internet, students must have currently existing e-mail accounts and ongoing access to computers with internet capabilities.
|4. Course Content (Body of knowledge) - |
- Setting Up Git Tools
- Installing Git (client)
- Configuring Git
- Establishing a GitHub account
- Git Basics
- Stack structure of Git
- Creating repos with init vs. clone
- File status lifecycle
- Commands: status, remove and reset
- Ignoring files
- The Git log
- Using log
- Using diff
- Hash tags and the SHA-1 protocol
- Remote Server Operations
- Removing and renaming
- Annotating tags
- Signed tags
- Lightweight tags
- Verifying tags
- Git Branches
- Tree structure of branches
- Forking (creating branches)
- Checking-out branches
- Graph structure of merged branches
- Branching Workflows
- Forking a development branch
- Forking a topic branch
- Forking a hotfix branch
- Tracking and deleting remote branches
- Destroying remote branches
- Rebasing and executing fast-forward
- Setting up a Git Server
- Protocols (local, Git, HTTPS, SSH)
- Public keys and Gitosis
- Configuring a server
- Web-based visualizers
- Hosted Git: GitHub
- Project Contribution with Git
- Commit Guidelines
- Private: small-team vs. large-team
- Public: suall-team vs. large-team
- Project Maintenance
- Topic branch options
- checking-out remote branches by manager
- Examining contributed work
- Integrating contributed work
- Tagging releases
- Build numbers
- Special Git Techniques
- Interactive staging
- Short SHA
- Changing history
- Viable Open Source Projects
- Selecting an open source that is of interest
- Reading the public discussion forums
- Evaluating the code through user comments
- Evaluating the code through contributor response
- Reading the code docs
- Getting on Board
- Watching projects
- Pull requests
- Setting up a dev environment
- Unbundling tests for student environment
- Fixing Bugs and Solving Problems
- Solving a problem that the student need solved
- Confirming the problem is the code's, not student's
- Confirming the problem is supported by the forums
- Making student patch mergable
- Understanding the test requirements for the student patch
- Asking the forums about student patch idea
- Submitting student patch
- Becoming a Committer
- Getting commit privileges
- Writing good documentation
- Contributing regularly
- Making relevant commits
- Project Plan Timeline
- Instructor list of suggested repos
- Student repo proposal and forum participation
- Acceptance of proposal by instructor
- Student demonstration of working dev environment
- Student demonstration of successful patch
- Student demonstration of documentation of patch
- Student demonstration of patch pushed to community
|5. Repeatability - Moved to header area.|
|6. Methods of Evaluation - |
- Tests and quizzes
- Written laboratory assignments which include source code, sample runs and documentation.
- Final examination
|7. Representative Text(s) - |
- Karl Fogul, Producing Open Source Software: How to Run a Successful Free Software Project, O'Reilly, 2006 (considered an industry classic)
- Scott Chacon, "Pro Git", Publisher: Apress, 2009.
|8. Disciplines - |
|Computer Science |
|9. Method of Instruction - |
- Lectures which include motivation for tools of Git, GitHub and Open Source.
- On-line labs (for all sections, including those meeting face-to-face/on campus) consisting of
- A programming assignment web-page located on a college-hosted course management system or other department-approved Internet environment. Here, the students will review the specification of each programming assignment and submit their completed lab work.
- A discussion web-page located on a college hosted course management system or other department-approved Internet environment. Here, students can request assistance from the instructor and interact publically with other class members.
- Detailed review of programming assignments which includes model solutions and specific comments on the student submissions.
- In person or on-line discussion which engages students and instructor in an ongoing dialog pertaining to all aspects of designing, implementing and analyzing programs.
- When course is taught fully on-line:
- Instructor-authored lecture materials, handouts, syllabus, assignments, tests, and other relevant course material will be delivered through a college hosted course management system or other department-approved Internet environment.
- Additional instructional guidelines for this course are listed in the attached addendum of CS department on-line practices.
|10. Lab Content - |
- Installation of Client Git Environment
- Download and install a Git environment.
- Create a local repository using clone and init.
- Modify and commit changes.
- Use log to track changes.
- Establishing Remote Repositories
- Create a local repository (repo) on GitHub.
- Use the local computer to connect to the remote repo.
- Do an initial push to the remote repo.
- Do a pull from the remote repo.
- Creating Tagged Branches
- Commit annotated branches to your repo.
- Use lightweight tags in your project
- Verify the tags using Git's verification support
- Create a hotfix or new topic branch and establish parallel development separate from the master branch.
- Check-in the new branch and merge the new branch with the master.
- Server and Project Local Contribution Exercise
- Set up a Git server on a local computer.
- Select a protocol for transfer and configure the server to use it.
- Establish public access and confirm that other computers can reach and connect to the server.
- Establish commit guidelines for projects for this server
- Demonstrate repo check-ins to this server that involve tagged releases, interactive staging and/or history changes.
- Final Open Source Project Phase 1
- Use your local lab system to research a viable open source project.
- Interact with the current contributors in public forums and document this discussion.
- Report on existing public commentary on the code and current bugs.
- Summarize the code docs you find on the project site.
- Final Open Source Project Phase 2
- Issue a pull request and set up a development clone on your lab system.
- Test the repo to make sure it is an accurate representation of the public repo.
- Select a small bug on which you intend to work.
- Give supporting evidence that the forum contributors believe this bug to be worth fixing.
- Open Source Project Phase 3
- Fix the bug.
- Test the fix using all available tests, both of your own design and those available from the community.
- Document the bug fix according to the standards of the open source community from which it comes.
- Open Source Project Phase 4
- Report to the forums that you have a bug fix.
- Document the reaction and interaction of your report.
- Request that you be allowed to commit your branch to the public repo.
- Document the response and submit copies or screen shots of the public repo and/or the forums that indicate the bug has been received.
|11. Honors Description - No longer used. Integrated into main description section.|
|12. Types and/or Examples of Required Reading, Writing and Outside of Class Assignments - |
- Textbook assigned reading averaging 30 pages per week.
- Reading the supplied handouts and modules averaging 10 pages per week.
- Reading on-line resources as directed by instructor though links pertinent to programming.
- Reading library and reference material directed by instructor through course handouts.
- Writing technical prose documentation that supports and describes the programs that are submitted for grades.
|13. Need/Justification - |
|This course is a restricted support course for the AS degree in Computer Science. |