Rhobincu la 2 martie 2026 14:11

2026-03-02T14:11:50Z

Rhobincu: Pagină nouă: = Lab 2: Multi-Player Git, Merge Requests, and Conflict Resolution = == Introduction == In Week 1, you learned how to drive Git in "single-player mode." You initialized a reposito...

2026-03-02T14:04:49Z

Pagină nouă: = Lab 2: Multi-Player Git, Merge Requests, and Conflict Resolution = == Introduction == In Week 1, you learned how to drive Git in "single-player mode." You initialized a reposito...

Pagină nouă

= Lab 2: Multi-Player Git, Merge Requests, and Conflict Resolution =

== Introduction ==
In Week 1, you learned how to drive Git in "single-player mode." You initialized a repository, staged files, and pushed to your own remote server.

Today, we switch to "multi-player mode." Software engineering is a team sport. When multiple engineers edit the same codebase simultaneously, collisions are inevitable. By the end of this 2-hour lab, you and a partner will have:
# Configured a shared team repository.
# Enforced Trunk-Based Development by locking down the <code>main</code> branch.
# Worked in parallel on feature branches.
# Intentionally caused a Git Merge Conflict.
# Resolved the conflict using Git commands and GitLab Merge Requests (MRs).
# Conducted a formal Code Review.

'''Requirement:''' Find a partner. Decide who will be '''Student A (The Maintainer)''' and who will be '''Student B (The Developer)'''.

---

== Part 1: Team Setup and Branch Protection (20 Minutes) ==
We must first create a shared workspace and establish our "Traffic Laws" (Branch Protection).

=== 1. Create the Shared Repository (Student A) ===
* '''Student A:''' Log into GitLab and create a new blank project named <code>sdpt-lab2-collaboration</code>.
* Uncheck "Initialize repository with a README".
* On the left sidebar, go to '''Manage''' -> '''Members'''.
* Click '''Invite members'''. Search for '''Student B''' by their university email or username.
* Assign Student B the role of '''Developer''' and click Invite.

=== 2. Enforce Branch Protection (Student A) ===
We are using Trunk-Based Development. The <code>main</code> branch is sacred. No one should be allowed to push broken code directly to it.
* '''Student A:''' In the project sidebar, go to '''Settings''' -> '''Repository'''.
* Expand the '''Protected branches''' section.
* Ensure the branch is set to <code>main</code> (or <code>master</code>).
* Set '''Allowed to merge''' to: <code>Developers + Maintainers</code>.
* Set '''Allowed to push and merge''' to: <code>No one</code>.
* Click '''Protect'''.
''(Now, the ONLY way code gets into main is through a Merge Request!)''

=== 3. Initialize the Baseline (Student A) ===
Student A will push the initial skeleton code so you both have a starting point.
<syntaxhighlight lang="bash">
# Student A's Terminal:
mkdir sdpt-lab2-collaboration
cd sdpt-lab2-collaboration
git init
</syntaxhighlight>

Create a file named <code>main.cpp</code>:
<syntaxhighlight lang="cpp">
#include <iostream>

void init_hardware() {
// TODO: Initialize communication protocol
}

int main() {
std::cout << "System Booting..." << std::endl;
init_hardware();
return 0;
}
</syntaxhighlight>

Commit and push:
<syntaxhighlight lang="bash">
git add main.cpp
git commit -m "Initial baseline code"
git remote add origin git@gitlab.com:<Student-A-Username>/sdpt-lab2-collaboration.git
git push -u origin main
</syntaxhighlight>

=== 4. Clone the Repository (Student B) ===
* '''Student B:''' Go to Student A's GitLab project page. Copy the SSH clone URL.
* Open your terminal and clone the shared repository to your machine:
<syntaxhighlight lang="bash">
git clone git@gitlab.com:<Student-A-Username>/sdpt-lab2-collaboration.git
cd sdpt-lab2-collaboration
</syntaxhighlight>

---

== Part 2: Parallel Realities (30 Minutes) ==
Both students will now create isolated branches and attempt to implement the hardware initialization logic at the exact same time.

=== 1. Branching Out (Both Students) ===
Both students must run the following commands on their own machines:
<syntaxhighlight lang="bash">
# Student A runs:
git checkout -b feature-spi-init

# Student B runs:
git checkout -b feature-i2c-init
</syntaxhighlight>

=== 2. Writing the Code (Both Students) ===
Open <code>main.cpp</code> in your text editor. Find the <code>init_hardware()</code> function.

'''Student A (SPI Logic):''' Replace the TODO comment with this exact code:
<syntaxhighlight lang="cpp">
void init_hardware() {
std::cout << "Initializing SPI Bus on Port A..." << std::endl;
}
</syntaxhighlight>

'''Student B (I2C Logic):''' Replace the TODO comment with this exact code:
<syntaxhighlight lang="cpp">
void init_hardware() {
std::cout << "Initializing I2C Bus on Port B..." << std::endl;
}
</syntaxhighlight>

=== 3. Commit and Push (Both Students) ===
Because you are on separate branches, you can both push to the server safely.
<syntaxhighlight lang="bash">
# Student A:
git add main.cpp
git commit -m "Add SPI hardware initialization"
git push -u origin feature-spi-init

# Student B:
git add main.cpp
git commit -m "Add I2C hardware initialization"
git push -u origin feature-i2c-init
</syntaxhighlight>

=== 4. Open Merge Requests (Both Students) ===
* Both students: Go to the GitLab project page.
* You should see a blue banner saying "You pushed to feature-...". Click '''Create merge request'''.
* Assign your partner as the '''Reviewer'''.
* Click '''Create merge request'''.

---

== Part 3: The Collision & Code Review (30 Minutes) ==
Right now, both Merge Requests look green and ready to merge. Git doesn't know there is a problem yet.

=== 1. Review and Merge Student A's Code ===
* '''Student B:''' Go to the Merge Requests tab and click on Student A's MR (SPI init).
* Go to the '''Changes''' tab to review the code.
* Leave a comment on the line of code: "Looks good, SPI is the correct protocol."
* Click '''Approve''', then click the green '''Merge''' button.

Student A's code is now officially part of the <code>main</code> branch!

=== 2. The Conflict Appears ===
* '''Student B:''' Go back to the Merge Requests list and open your own MR (I2C init).
* You will see a glaring error: '''Merge blocked: merge conflicts must be resolved.'''
* ''Why did this happen?'' Both of you edited the exact same line in <code>main.cpp</code>. Git refuses to guess whether the SPI code or the I2C code should win. A human must intervene.

---

== Part 4: Resolving the Conflict (30 Minutes) ==
Student B must pull the new changes from the server and fix the conflict locally before they can merge.

=== 1. Update the Local Main Branch (Student B) ===
Student B, your local machine does not know about Student A's merged code yet.
<syntaxhighlight lang="bash">
# Switch back to main
git checkout main

# Download the latest changes from the server
git pull origin main
</syntaxhighlight>

=== 2. Rebase or Merge? (Student B) ===
Switch back to your feature branch. We need to integrate the new <code>main</code> into your feature branch. We will use a merge to resolve the conflict.
<syntaxhighlight lang="bash">
git checkout feature-i2c-init
git merge main
</syntaxhighlight>

Git will output: <code>CONFLICT (content): Merge conflict in main.cpp. Automatic merge failed.</code>

=== 3. Fix the Code (Student B) ===
Open <code>main.cpp</code> in your text editor. Git has injected markers into your code:

<syntaxhighlight lang="cpp">
void init_hardware() {
<<<<<<< HEAD
std::cout << "Initializing I2C Bus on Port B..." << std::endl;
=======
std::cout << "Initializing SPI Bus on Port A..." << std::endl;
>>>>>>> main
}
</syntaxhighlight>

* '''Task:''' Discuss with Student A. Decide that you actually need ''both'' protocols to initialize.
* Delete the Git markers (<code><<<<<<<</code>, <code>=======</code>, <code>>>>>>>></code>) and combine the logic so it looks like this:

<syntaxhighlight lang="cpp">
void init_hardware() {
std::cout << "Initializing SPI Bus on Port A..." << std::endl;
std::cout << "Initializing I2C Bus on Port B..." << std::endl;
}
</syntaxhighlight>

=== 4. Finalize the Merge (Student B) ===
Now that the conflict is manually fixed, tell Git it is resolved:
<syntaxhighlight lang="bash">
git add main.cpp
git commit -m "Resolve merge conflict between SPI and I2C initialization"
git push origin feature-i2c-init
</syntaxhighlight>

=== 5. Final Approval (Student A) ===
* '''Student A:''' Go to Student B's Merge Request on GitLab.
* Notice the conflict warning is gone. The MR is green again!
* Review the Changes to ensure both SPI and I2C are initialized.
* Click '''Approve''', then click '''Merge'''.

---

== Lab Deliverable ==
To receive full credit for this week's lab, both partners must call the professor or teaching assistant over to your workstation and demonstrate:
# The shared GitLab repository showing the <code>main</code> branch with both SPI and I2C logic combined.
# The '''Settings -> Repository -> Protected branches''' screen showing that <code>main</code> cannot be pushed to directly.
# The '''Merge Requests''' tab showing two Closed/Merged MRs with review comments visible.
# Run <code>git log --graph --oneline</code> on your terminal to show the visual graph of the diverging branches and the merge commit.

SDPT Lab 2 - Revizia istoricului

Rhobincu la 2 martie 2026 14:11

Rhobincu: Pagină nouă: = Lab 2: Multi-Player Git, Merge Requests, and Conflict Resolution = == Introduction == In Week 1, you learned how to drive Git in "single-player mode." You initialized a reposito...