Hello guys, I was thinking, y'all could as well add a few more points to the retrospective draft.

[GaiSamuel]

Retrospective ⏪

“Regardless of what we discover, we understand and truly believe that everyone did the best job they could, given what they knew at the time, their skills and abilities, the resources available, and the situation at hand.” NORM KERTH.

Over the past weeks, our group embarked on the journey of learning and practicing effective code reviews. This retrospective aims to reflect on our experiences, evaluate what went well, identify areas for improvement, and outline actionable steps to enhance our skills further. By reviewing our process and establishing the best practices for future code reviews, we hope to foster a collaborative environment.

Stop doing 🙅‍♂️

1. Stop merging changes without proper reviews.

Continue doing 👍

1. Regular code reviews.
2. Helping each other out to ensure no one is left behind.
3. Carrying out regular video calls
4. Being active in the group
5. Automated testing for critical features
6. Setting clear deadlines for deliverables
7. Sharing resources and insights to improve team knowledge and skills collectively.

Start doing 🚀

1. Conducting regular check-ins to align on progress and adjust priorities as needed.
2. Tracking and addressing recurring issues; We noticed that some issues, like not using descriptive enough names for variables (e.g., naming a variable s instead of binary_str), kept coming up during our reviews. To avoid making the same mistakes as a group and having to point them out individually each time, we plan to keep a shared list of these common issues. This way, everyone can see and remember them, helping us improve and use better practices in future projects.

Lessons Learned 🎓

1. Importance of clear communication and task assignment
2. Benefits of automated testing and continuous integration
3. Value of regular team feedback and retrospectives
4. The importance of role clarity: Assigning clear roles in each review cycle (e.g., reviewer, author, maintainer) ensures accountability and smoothens the workflow.
5. The value of iterative learning: Every mistake or challenge faced during this process offered an opportunity to grow and refine our practices.
6. Effective prioritization leads to efficiency: Focus on the most impactful changes during reviews to optimize time and effort.

---

Strategy vs. Board

What parts of your plan went as expected? 👍

1. Improved understanding of code-reviewing principles; Throughout this project, we gained a deeper understanding of the importance of code-reviewing and how to apply best practices.
2. Effective collaboration; Group members worked well together, providing constructive feedback and supporting each other in the learning process which allowed us to refine our approach and improve both our coding practices and communication. This made the code review process not only more effective but also more rewarding, as we could see visible improvements over time.
3. Keeping deadlines on track and the delivery of work as expected.

What parts of your plan did not work out? 👎

1. Initial struggle with code review tools; We faced some challenges getting familiar with the code review tools, but eventually got the hang of it.
2. We weren't quite able to fully help each other out as a colleague of ours decided not to continue with the program.

Did you need to add things that weren’t in your strategy? 🤔

1. Dedicated Learning Time for Tools; Some team members needed more time to learn and practice using tools like GitHub and setting up the environment. While we helped each other whenever needed during our meetings, it would have saved time if we had set aside time specifically for learning the tools. This could have been done either together in a session at the beginning or by giving everyone extra time upfront to get familiar with the tools. Extending the deadlines a bit would also have helped everyone feel more comfortable and avoided early delays.

Or remove extra steps? 🚮

[ViktoriyaHaiduk]

Hi Gai, Great Job!
Let's add to ##Continue doing :
Sharing resources and insights to improve team knowledge and skills collectively.

to ##Start doing ### 🚀
Conducting regular check-ins to align on progress and adjust priorities as needed.

to ##Lessons Learned
Clear task division and upfront planning save significant time and effort in later stages.
Continuous feedback fosters growth and helps avoid repeated mistakes.

Thank you!

[GaiSamuel]

Great suggestions Viktoriya. Added👌 Except ones' of lessons learned as they are repetitions.

[Mohamed-Elnageeb]

lets make those edits in a branch so that everyone can edit

[GaiSamuel]

The ones to make edits in the branch are me and Yonatan since we were assigned to this challenge and then those assigned to review will do so after. Meanwhile the rest of the group members can then add in points in this discussion.

[Mohamed-Elnageeb]

ok

[Khusro-S]

Start doing

Tracking and addressing recurring issues.

We noticed that some issues, like not using descriptive enough names for variables (e.g., naming a variable s instead of binary_str), kept coming up during our reviews. To avoid making the same mistakes as a group and having to point them out individually each time, we plan to keep a shared list of these common issues. This way, everyone can see and remember them, helping us improve and use better practices in future projects.

[Khusro-S]

What parts of your plan went as expected?

Valuable feedback from peers.
The feedback we received from each other allowed us to refine our approach and improve both our coding practices and communication. This made the code review process not only more effective but also more rewarding, as we could see visible improvements over time.

[Khusro-S]

Did you you need to add things that weren't in your strategy

Dedicated Learning Time for Tools

Some team members needed more time to learn and practice using tools like GitHub and setting up the environment. While we helped each other whenever needed during our meetings, it would have saved time if we had set aside time specifically for learning the tools. This could have been done either together in a session at the beginning or by giving everyone extra time upfront to get familiar with the tools. Extending the deadlines a bit would also have helped everyone feel more comfortable and avoided early delays.

[linahKhayri]

I feel like we can add this point here:
What parts of your plan went as expected? 👍

• keep the deadlines on track and deliver work as expected by having clear timelines

[TekaMesfinAbel]

Okay some idea on the last three.

Lessons Learned 🎓

• The importance of role clarity: Assigning clear roles in each review cycle (e.g., reviewer, author, maintainer) ensures accountability and smoothens the workflow.
• The value of iterative learning: Every mistake or challenge faced during this process offered an opportunity to grow and refine our practices.
• Effective prioritization leads to efficiency: Focus on the most impactful changes during reviews to optimize time and effort.

---

Suggestions for Strategy Adjustment 📋

• Enhance onboarding for new tools: Provide a structured learning path or documentation to reduce initial struggles with tools.
• Break down tasks into manageable units: Large tasks can overwhelm both authors and reviewers. Smaller, well-defined tasks make reviews more focused and efficient.
• Implement feedback loops for recurring challenges: By assigning team members to track specific recurring issues, we can ensure they’re addressed proactively in subsequent projects.

---

Moving Forward ➡️

• Emphasize collective learning: Encourage team members to share their experiences in a bi-weekly knowledge-sharing session.
• Streamline workflow: Explore opportunities to use project management tools like Trello or Jira to better track progress and adjust priorities dynamically.
• Refine the code review checklist: Regularly revisit and update the checklist to adapt to new challenges and maintain relevance.

[GaiSamuel]

I'm not sure i understand the suggestions on strategy adjustment and moving forward. Could you elaborate where they fall.

[TekaMesfinAbel]

The "Suggestions for Strategy Adjustment 📋" could be added as "Start Doing", and the "Moving Forward ➡️" could be added to the "Lessons Learned" as a stand-alone, i.e., if necessary. Also, you could leave them if they are already mentioned.

[GaiSamuel]

Did anyone have to remove extra steps that were included in y'all strategies? @Mohamed-Elnageeb and @linahKhayri does removing the docstrings that were explaining the function's strategy in y'all challenges fall under this?

[linahKhayri]

We removed part of the docstring which should only explain the function's behavior but you can include a point in the continue doing or lessons learned section regarding the importance of distinguishing between a function's behavior, strategy, and implementation

[Zeinab15]

Hello Team,
Thank you for the fantastic work you've done! I just wanted to share some points for the first questions:

[Zeinab15]

Stop Doing:

• Avoid sharing external links or performing actions that do not comply with the application’s policy to ensure security and consistency.
• Stop opening Pull Requests without verifying the target branch to prevent errors and confusion in the version control process.

[Zeinab15]

Continue Doing:

• Divide tasks before starting to ensure clear responsibilities.
• Ask for help when facing challenges to avoid unnecessary delays.
• Consider all perspectives when solutions differ. Refer to reliable resources, and discuss the options with the team to decide on the best approach.

[Zeinab15]

Start Doing:

• Sharing knowledge among team members before starting the project: By sharing our individual skills and knowledge at the start, we can help each other become more effective and efficient in the work we do.
• Creating a list of each member’s skills and capabilities: Knowing who is best suited for each task will enable us to make better decisions on task delegation and leverage everyone's strengths.
• Documenting work steps, policies, and best practices: Clear documentation will ensure that all team members are on the same page, reducing confusion and the chances of mistakes in the future.

[Zeinab15]

Lessons Learned:

• Focusing on weaknesses and learning from others: Recognizing areas of improvement, learning from mistakes, and taking guidance from others are crucial for personal and team growth.
• Frequent code reviews enhance expertise: Regular code reviews not only improve the quality of our code but also reduce errors in our own work.
• Clear initial planning and sharing it with the team: Creating a clear plan at the beginning and sharing it with everyone helps to streamline the project and avoid confusion later on.

[GaiSamuel]

Great suggestions Zeinab!🙌 Will add them to the branch straight since i've created a pull request already.