This program gives graduates of the discernment class an opportunity to put what they have learned into practice. They form a team and collaborate on a real-world project using Agile Methodology to plan each sprint, refine and estimate the size of issues, divide the work and review each other's code through PRs.

Much to the dismay of collaborators, the project is designed to give everyone many chances to run into merge conflicts, miscommunication, and other common problems that can emerge when working on a team. But they will also have the support of seasoned professionals to work through the challenges and learn from the mistakes.

The first TeamCode team was assembled from graduates from every Refcode cohort to date! They rebuilt the refcode.org website from the ground up.

This video shows TeamCode collaborators at an early sprint planning meeting.

Building communication and collaboration skills

TeamCode collaborators met once per sprint for a sprint planning where we created tasks for work to be done, estimated them, and assigned them according to how much time each collaborator could commit to. The team coordinated throughout the sprint using Slack, in-person office hours, and GitHub. All code was checked into GitHub and reviewed by other team members.

The Project

The TeamCode collaborators rebuilt the refcode.org website from the ground up using HTML, CSS, Javascript and React.

To enable many team-members collaborating on a complex site, they utilized Atomic Design and maintained a pattern library to keep track of the components as they were built and updated. Once individual components (comprised of Atoms, Molecules and Organisms) were built, the final pages were assembled using the components.

As the skills of the collaborators grew, we decided to increase the complexity of the code to match their skill level, resulting in some pages being built out using React. The final website is a hybrid of static HTML and React pages.

A screenshot from the refcode.org pattern library.

Collaborating with GitHub

Merge conflicts. So many merge conflicts. TeamCode was designed to give real-world experience with real team collaboration and communication, and that's exactly what happened. Following Agilie Methodology, the team chose their own set of sprint ceremonies to follow, which included sprint planning stand-up meetings, and project refinement. Collaborators got familiar with planning and tracking a project through GitHub Issues. They coordinated their work using GitHub issues and used GitHub pull requests to review each-other's code.

The Git feature branch workflow was used to manage code contributions, which means each collaborator had to fork the main repository ("upstream") and maintain it as their own "origin" repo. For each new feature that was added, collaborators:

  1. Pulled latest from upstream (to avoid merge conflicts!)
  2. Created a new feature-branch
  3. Coded the feature and committed it to that branch
  4. Pushed their changes to their "origin" fork.
  5. Created a pull-request and asked team-mates for code review and input
  6. Made additional updates based on code review
  7. Merged the branch into the main "upstream" repository

The best lessons were learned when things did not go smoothly. Not only did the collaborators learn the importance of creating processees to avoid accidental merge conflicts, but they were forced to deepen their knowledge of git and GitHub as well.

The Team

Here are the collaborators for the first TeamCode cohort. More info can be found on the GitHub team page.

Mustafa Alsaeedi

From cohort: Summer 2017
Contributions

Sintayehu Mekonnen

From cohort: Summer 2018
Contributions

Tariku Kebede

From cohort: Spring 2019
Contributions

Nezira Usmael

From cohort: Spring 2019
Contributions

Yohannes Bahta

From cohort: Summer 2018
Contributions

Nai Sai Aung

From cohort: Summer 2019
Contributions