Team AutoGen

• Collaboration & Workflow
  By holding daily stand‑ups, adopting clear branch naming, and using PR templates, we minimized merge conflicts and accelerated review cycles.
• Technical Mastery
  Debugging app_agent.py and architecting app_group.py deepened our understanding of multi‑agent AI frameworks, asynchronous messaging, and core Chainlit integration.
• Community Engagement
  Frequent, respectful communication with maintainers taught us to write concise issue reports, follow up efficiently, and iterate quickly on requested changes.

Week 14 | Presentations

This week was really exciting because we had two project presentations lined up — one from our classmates on Preswald, and one from our team on Huggingface.

1. Group Project Progress

This week our team met multiple times both online and offline to review the evaluation workflow of the Hugging Face Trainer. Originally, the Trainer could only trigger evaluation, saving, and logging based on training steps or epochs. However, in different hardware environments (slow local CPU vs fast GPU cluster), “every N steps” cannot guarantee outputs at the desired time intervals.

Open Source Reflections: Bazaars, Coffeehouses, and OSPOs

Cathedral vs. Bazaar in Our Group Project

Working on our group’s open source project, I’ve started to see just how real the concepts in Eric Raymond’s The Cathedral and the Bazaar are. One of the biggest takeaways for me has been the value of the “release early, release often” philosophy. In our group, we originally hesitated to push half-finished work—we were afraid of looking unpolished or incomplete. But once we started sharing drafts earlier, we realized how powerful early feedback can be. Maintainers and even fellow contributors helped guide our direction, and it turned into a much more collaborative experience.

Group Project Update & Reflection on Shivam’s Talk

Reflections on Two Presentations on Open Source Initiatives and the Definition of Open Source AI

This week I attended two presentations on open source initiatives and the definition of Open Source AI, which provided me with a deeper and more detailed understanding of the field. Below are some of my detailed reflections and insights after listening:

Blog Post Reflection

Our group chose this project because we all share a deep interest in Artificial Intelligence. Having previously worked with Hugging Face, we recognized it as one of the hottest platforms of our time. Beyond just curiosity, we saw it as an opportunity to gain hands-on experience that would be invaluable for our future careers in the AI field. We believe that by engaging with a platform at the cutting edge of technology, we can not only refine our technical skills but also better understand industry trends and challenges.

Reflection on My Open Source Contributions

Looking back at my open-source contributions, I have primarily focused on reporting issues, improving Wikipedia articles, and contributing to OpenStreetMap. While I haven’t yet made contributions involving writing code, I have actively engaged in identifying and fixing gaps in online resources.

Project Evaluation Reflection

What are your thoughts on the different projects you’ve looked into?

After reviewing multiple open-source projects, I found that their contribution barriers, community cultures, and technical requirements vary greatly. For instance, VSCode, as a widely used code editor, offers clear contribution guidelines and comprehensive documentation. However, due to its large codebase and rapid development pace, it may not be very beginner-friendly. In contrast, PyTorch, with its focus on deep learning and high-performance computing, provides abundant documentation but presents significant challenges for contributors without a machine learning background.

Part 1: Reflection on In-Class Git Instructions

This exercise comprehensively covered the basic functionalities and workflow of Git, allowing us to experience the power of version control through hands-on practice. Below are my key takeaways from this exercise:

Initialization and Basic Commits

At the beginning of the exercise, we used git init, git add, and git commit to familiarize ourselves with adding files to version control. By repeatedly checking git status and git log, we gained a clear understanding of how each operation affects the repository.

Change Tracking and Differences

After modifying files, we used git diff to compare the differences between commits. This gave me a deep understanding of the importance of version control—not only for recording history but also for precisely identifying changes. This is particularly useful for debugging and tracking modifications.

Understanding Git’s Internal Structure

By using git cat-file -p, we explored the structure of commits, trees, and blobs, which helped me understand how Git efficiently stores data. Gaining insights into these underlying mechanisms enhances our ability to utilize Git’s advanced features effectively.

Branch Operations and Merging Strategies

We created a new branch called potential_jokes in this exercise and added new content in different branches. Switching between branches, observing changes in the working directory, and merging branches highlighted the importance of branching in parallel development. Additionally, we intentionally introduced merge conflicts to learn how to resolve them using git mergetool.

Accidental Deletion and File Recovery (git restore)

This part of the exercise made me realize the importance of git restore, especially in collaborative development where erroneous versions can cause significant issues. In our Web Extension project, we encountered a similar situation—an incorrect version caused the entire project to break. Ultimately, we used git restore to revert to the previous correct version, successfully restoring the project. This experience reinforced the idea that Git is not just a version control tool but also a “lifeline” that allows us to quickly recover from critical issues and maintain a stable development environment.

Squashing Commits

Although the exercise only briefly touched on squashing commits, it provided valuable insight into maintaining a clean commit history. By merging multiple commits into one, we can keep the history concise and organized, making future maintenance and collaboration more manageable.

Overall, this Git exercise gave me a deep understanding of version control in real-world development. From tracking files to managing complex branches, resolving conflicts, and restoring data, every step contributes to a solid foundation for effective collaboration and code management. In particular, git restore proved to be a powerful tool for handling unexpected issues and ensuring project stability. Through these hands-on experiences, I gained a more comprehensive understanding of Git’s workflow and internal mechanisms, preparing me for more advanced project management in the future.

Team Collaboration on Browser Extension Development

With our team’s collaboration, we successfully developed a browser extension that allows users to open a sidebar for note-taking, supporting Markdown and LaTeX syntax. Users can save and load notes locally at any time, choosing their preferred storage path. We also provided separate panels for source code editing and previewing, enhancing user experience with a friendly interface.

Code of Conduct in Open Source Communities: A Cultural Guide Beyond Rules

In open source communities, a Code of Conduct (CoC) is more than just a set of rules—it is a reflection of the community’s culture. It establishes fundamental ethical and behavioral expectations, ensuring that all participants can collaborate in a friendly and inclusive environment. A well-structured CoC improves communication efficiency among community members, strengthens teamwork, and enhances the community’s overall reputation, attracting more contributors and users.

Go Language’s Code of Conduct: An Optimization of Contributor Covenant

In analyzing the Go language’s Code of Conduct 🔗 Go CoC, it is evident that it incorporates deeper modifications to the Contributor Covenant in two key areas:

Before this class, I didn’t know what open source meant. I had never been exposed to it, nor did I understand its significance in the world of technology and collaboration. However, after attending lectures and exploring various resources, I’ve gained a deeper understanding of its essence.

Open source is not just about sharing code; it’s about fostering transparency, collaboration, and innovation. It allows developers worldwide to contribute their expertise, learn from one another, and collectively solve problems. The idea of working together openly, without the limitations of proprietary systems, is what makes open source so powerful.

Through this journey of learning, I’ve come to appreciate how open source has shaped the tech industry. Projects like Python, Firefox, and even large-scale AI initiatives such as DeepSeek demonstrate the immense impact that open-source collaboration can have. It’s inspiring to see how collective efforts can transform small ideas into world-changing innovations, and I’m eager to become part of this movement.