Block programming and Git for teamwork

Why this matters

Many students start programming drones with block programs, such as HighGreat’s Hula app, dragging blocks like “take off”, “fly forward” and “turn” together. Block programs make program structure very visible, but as work grows you need a language that can be tested, reused and shared by a team: Python with Git.

The good news is that the ideas are almost identical. One block is one line of code, a Repeat block is for, an if block is if. What you gain are testing tools, simulation, and a traceable history of changes.

From blocks to Python

The class below models a drone on a flat plane. It does not command a real drone, but it checks a program’s logic before flight. Hula’s speed is a percentage command, not m/s, so the class does not model flight time.

import math


class SimDrone:
    """A flat-plane drone model for checking block programs before flight."""

    def __init__(self):
        self.x_cm = 0.0
        self.y_cm = 0.0
        self.heading_deg = 0.0
        self.flying = False
        self.distance_cm = 0.0
        self.turned_deg = 0.0

    def take_off(self):
        self.flying = True

    def land(self):
        self.flying = False

    def _require_flying(self):
        if not self.flying:
            raise RuntimeError("take off first")

    def fly_forward(self, cm):
        self._require_flying()
        self.x_cm += cm * math.sin(math.radians(self.heading_deg))
        self.y_cm += cm * math.cos(math.radians(self.heading_deg))
        self.distance_cm += cm

    def turn_clockwise(self, deg):
        self._require_flying()
        self.heading_deg = (self.heading_deg + deg) % 360
        self.turned_deg += deg

    def back_at_start(self):
        return math.isclose(self.x_cm, 0, abs_tol=1e-6) and math.isclose(self.y_cm, 0, abs_tol=1e-6)


drone = SimDrone()
try:
    drone.fly_forward(100)
except RuntimeError as err:
    print("error:", err)

error: take off first

The _require_flying() method enforces Hula’s “take off first” rule in code. Forget the Take off block and the simulation reports it immediately, instead of the problem surfacing in flight.

Polygons and stars

def fly_polygon(n, k, side_cm):
    drone = SimDrone()
    drone.take_off()
    for _ in range(n):
        drone.fly_forward(side_cm)
        drone.turn_clockwise(360 * k / n)
    drone.land()
    return drone


for n, k, side in [(4, 1, 60), (5, 2, 50)]:
    d = fly_polygon(n, k, side)
    print(f"{{{n}/{k}}}: turn {360 * k / n:.0f} deg, flown {d.distance_cm:.0f} cm, "
          f"turned {d.turned_deg:.0f} deg, back at start: {d.back_at_start()}")

{4/1}: turn 90 deg, flown 240 cm, turned 360 deg, back at start: True
{5/2}: turn 144 deg, flown 250 cm, turned 720 deg, back at start: True

def legs_until_back(n, k, side_cm=100):
    drone = SimDrone()
    drone.take_off()
    for leg in range(1, n + 1):
        drone.fly_forward(side_cm)
        drone.turn_clockwise(360 * k / n)
        if drone.back_at_start():
            return leg
    return None


for n, k in [(5, 2), (6, 2), (7, 3)]:
    print(f"{{{n}/{k}}}: back after {legs_until_back(n, k)} legs, n / gcd = {n // math.gcd(n, k)}")

{5/2}: back after 5 legs, n / gcd = 5
{6/2}: back after 3 legs, n / gcd = 3
{7/3}: back after 7 legs, n / gcd = 7

Concurrency

Hula’s level-5 example uses two scripts running at once: one flies a survey, the other searches for QR targets, communicating through a broadcast block and a shared variable. In Python this becomes two threads: threading.Event replaces the broadcast, and threading.Lock stops both threads changing the shared variable at the same moment and corrupting it.

import threading

mission_started = threading.Event()
lock = threading.Lock()
targets_marked = 0
QR_FOUND_AT_SCAN = {2, 5, 6}


def search_thread():
    global targets_marked
    mission_started.wait()
    scan = 0
    while targets_marked < 3:
        scan += 1
        if scan in QR_FOUND_AT_SCAN:
            with lock:
                targets_marked += 1
        threading.Event().wait(0.002)


searcher = threading.Thread(target=search_thread)
searcher.start()
mission_started.set()
while targets_marked < 3:
    threading.Event().wait(0.002)
searcher.join()
print("targets marked:", targets_marked)

targets marked: 3

searcher.join() waits for the search thread to finish before landing, like Hula’s stop all scripts block, which prevents a script from being left running. Concurrent code is easy to get wrong; if you do not need it, write a single sequence first.

Git: recording history

Git records snapshots of code (commits) with explanatory messages, lets you go back, and lets many people work on the same code. The Pro Git book is free at git-scm.com.

git config --global init.defaultBranch main   # Git still names the default branch master
git init
git add mission_tools.py test_mission_tools.py
git commit -m "feat: add battery_status and distance_m"
git log --oneline

A .gitignore file tells Git which files not to track. Add it in the very first commit.

.venv/
__pycache__/
*.tlog
.env

GitHub flow and commit messages

GitHub flow is simple: branch from main → change and commit → open a pull request → a teammate reviews → merge and delete the branch.

git switch -c feature/battery-check
# edit the code and make the tests pass
git add mission_tools.py test_mission_tools.py
git commit -m "fix: treat 15% as LOW, not OK"
git push -u origin feature/battery-check

Conventional Commits 1.0.0 uses the form type(scope): description, such as feat: for a new capability, fix: for a bug fix, and docs:, test: or refactor: for other work. A good message says what changed, not “fixed stuff” or “update”.

Module lab

Common mistakes

Summary

• Hula blocks translate directly to Python: Repeat is for, repeat until is while, broadcast is threading.Event
• A drone simulation class checks logic before flight; a $\{n/k\}$ figure turns $360^{\circ }k/n$ and closes after $n/\gcd (n,k)$ legs
• Threads sharing a variable need a Lock, and must be waited for with join()
• Git has four areas, and GitHub flow is branch → commit → pull request → review → merge
• Write commit messages following Conventional Commits, and never commit secrets

Check your understanding

1. Which Python statement matches the block Repeat 5 times?
2. For a regular hexagon $\{6/1\}$ with 100 cm sides, how many degrees is each turn, and how far is the total flight?
3. After how many legs does $\{8/2\}$ return to its start?
4. Which Git command moves changes from the working tree to the staging area?
5. You accidentally committed an API key to GitHub. What must you do first?