Hi, this is Xinyue (Kiera). In this post, I want to reflect on what version control has come to mean for me, especially through my experiences working on two collaborative digital projects: Reframing Collections: From Geographic Generalizations to Cultural Context and Mapping East Lansing Memories. Both projects have been meaningful in completely different ways, but together they have reshaped how I understand collaboration, communication, and what it means to work responsibly in a shared digital space.
Before joining the CHI fellowship, I already had a solid foundation in programming. I had worked with front‑end tools like HTML, CSS, JavaScript, Vue.js, and Bootstrap, and I was also comfortable with back‑end work using Python. Because my research interest is in Computer Science Education(particularly computational thinking). I’ve also spent a lot of time with creative coding environments like Processing, P5.js, Turtle Art, Scratch, and Snap!. In short, I wasn’t new to writing code.
Despite all that experience, I had never actually used version control before this fellowship. In my undergraduate and master’s programs, even when I collaborated with classmates, we never used GitHub or anything similar. Instead, we either divided the project into separate sections and stitched everything together at the end, or we used some type of synchronous online editor that functioned sort of like Google Docs for code. It “worked,” but in retrospect, it also created unnecessary chaos, like files overwriting each other, inconsistent naming, and endless confusion about what counted as the “final version.”
Working on these two CHI projects completely changed that. For the first time, I learned to collaborate through GitHub Desktop, which quickly became one of the most exciting tools I’ve used. I didn’t realize how empowering and organized collaboration could feel until I saw how seamlessly GitHub integrates with VS Code. Being able to pull, commit, and push changes, while seeing everyone else’s contributions, made teamwork feel more transparent and intentional. It felt like the digital equivalent of breathing fresh air. Of course, there were also surprises and many lessons learned. One thing I discovered early on is that version control doesn’t magically prevent conflicts; people still need to coordinate thoughtfully. I learned quickly that it’s best if team members avoid working on the same page at the same time, because merge conflicts can easily become overwhelming. I also learned a much more basic but equally important lesson: always open the collaborative repository through the invitation link. If you accidentally fork or clone the wrong version, you can unintentionally work in a parallel universe without realizing it.
One habit I’m proud of, and one that I’ve kept consistently throughout both projects, is documenting my code clearly. Adding comments, explanations, and notes isn’t just good practice for readability; it’s one of the best gifts you can give your teammates. Good documentation shows respect for others’ time and helps the group move forward together, especially when projects evolve quickly.
After gaining this firsthand experience, I’ve also been thinking a lot about how version control connects to my research interests in computational thinking and computer science education. At first, I thought of version control purely as a technical skill, something programmers use to manage files. But now I see it as something much deeper and more conceptual. Version control embodies many of the core ideas in computational thinking: abstraction, decomposition, debugging, iteration, and especially collaboration as a computational practice. Experiencing version control in a real collaborative environment has made me realize how valuable it could be for teaching. It encourages students to externalize their thinking, make their design processes visible, and understand that computing is rarely an individual activity. There is something powerful about seeing your own work as one commit in a long chain of shared contributions. It makes you feel both responsible and supported.
Looking forward, I’m also starting to think about how I could incorporate the idea of version control into my future research or curriculum design. For example, version control could become a metaphor or structural tool in creative coding activities—students could explore how ideas evolve over iterations, or how collaboration shapes computational artifacts. In maker‑based learning environments, versioning could be a way to trace design decisions, connect artifacts to cultural context, or help students understand how their thinking develops over time. Even in more artistic creative coding projects, like generative art or culturally situated designs, version control could document the aesthetic reasoning behind each revision.
Overall, this experience has shown me that version control is not just a technical tool. For me, it represents a mindset — a commitment to collaborative responsibility, transparency, and intentionality. Learning GitHub for the first time during the CHI fellowship has not only improved my workflow; it has reshaped how I think about teaching, learning, and creating together.
Trackbacks/Pingbacks