Transitioning to Professional Local Development

What You Will Do

You will move one of your own CMU Academy programs out of the browser and into a real local development environment, then use Git to take versioned snapshots of your work — the same way professional developers do every day.

Learning Objectives

By the end of this 3-hour practicum, you will be able to:

Practicum Blocks

• Block 1 — Mission Briefing & Environment Validation 0–25 min
• Block 2 — Installing & Testing CMU Graphics 25–60 min
• Block 3 — Importing a Real CMU Program 60–100 min
• Block 4 — Introduction to Git 100–130 min
• Block 5 — Iteration & Versioning 130–160 min
• Block 6 — Final Deliverable Submission 160–180 min

Block 1 — Environment Validation0–25 min

Before you write a single line of code, professional developers verify their environment. A bad PATH, missing interpreter, or wrong terminal will silently waste hours later. Validate first, then code.

Your tasks

1. Open VS Code.
2. Open the integrated terminal (Ctrl + ` or View → Terminal).
3. Verify Python is installed and on PATH:

   python --version

   You should see something like Python 3.x.x. If you see "command not found" or a Microsoft Store popup, raise your hand — that's a PATH issue.
4. Create a project folder named exactly:

   cmu-local-project

5. Open that folder in VS Code (File → Open Folder).
6. Create a new file hello.py with one line:

   print("Python works!")

7. Run it from the terminal:

   python hello.py

Block 2 — Installing & Testing CMU Graphics25–60 min

You'll use pip (Python's standard package manager) to install cmu-graphics on your local machine and verify that a graphics window opens outside the browser.

Install the package

pip install cmu-graphics

If pip reports a permissions or network error, screenshot the exact error text — documented failures are still full credit, and the error text is what the supervisor will help you triage.

Smoke-test program

Create smoke_test.py:

from cmu_graphics import *

app.background = 'black'
Circle(200, 200, 50, fill='lime')

cmu_graphics.run()

Run it. A window should open with a black background and a green circle.

Block 3 — Importing a Real CMU Program60–100 min

Choose one of your existing CMU Academy programs — ideally one you're proud of. You'll copy it into VS Code and bring it up to a professional baseline.

Required improvements

• Copy the program into a new file in cmu-local-project (e.g. my_program.py).
• Add the from cmu_graphics import * import if it's missing.
• Add the cmu_graphics.run() call at the bottom.
• Rename any unclear variables (no more x1, temp, stuff).
• Add at least 3 comments explaining why something is there (not just what it does).
• Clean indentation; break long lines.

Block 4 — Introduction to Git100–130 min

Git is the version control system used by ~90% of professional software teams. The concepts in this block are the ones that show up on day one of any internship or developer job.

Vocabulary you need for this block

Your Git tasks

From the terminal, inside cmu-local-project:

git init
git status
git add .
git commit -m "Initial local CMU project"
git log

Block 5 — Iteration & Versioning130–160 min

One commit isn't version control — it's a save. You earn the benefits of Git by committing often, with meaningful messages, as you make real changes.

Make at least two more commits

Modify your program in a meaningful way. Pick one or more:

• Change colors / styling
• Add animation or movement
• Add keyboard or mouse interaction
• Change the layout or add a new shape group
• Refactor a section for clarity

Then:

git status
git add .
git commit -m "Improved visuals and added keyboard interaction"

Repeat with a second meaningful change and a second descriptive commit message.

Block 6 — Final Deliverable160–180 min

Compile everything into a single professional PDF named LASTNAME_FIRSTNAME_LocalDevPracticum.pdf and submit it through Schoology.

Required sections (in this order)

1. Cover page — your name, date, class period, lab title.
2. Environment verification — screenshots from Block 1 (Python version, hello.py run).
3. CMU Graphics test — screenshot of the smoke-test window plus your short paragraph on local vs. browser differences.
4. Imported program — screenshot of your program running, with notes on what you had to change.
5. Git evidence — screenshots of git status, the first git commit, and git log showing all three of your commits.
6. Iteration log — describe the two changes you made in Block 5 and why.
7. Reflection — 2 well-developed paragraphs covering: what you learned, how local dev differs from browser-based coding, why version control matters, and which of the "Profession Connection" callouts from this lesson surprised you most.

Grading Breakdown

Honest documented failures (with the exact error text) are worth full credit on the affected sections. Pretending something worked when it didn't is academic dishonesty.

Lesson Expectations

• Capture exact error text on any failure — screenshot plus the literal message.
• Try at least one documented workaround before escalating to the teacher. Bring the exact error text with you when you do escalate.
• If you finish early, the website lists extension activities (start with the Gitea publishing extension). Idle time is not an option.

Finished Early? Start the Required Extension

If you finished the main lab early, start the required extension now — otherwise you will complete it during a follow-up class meeting. The extension adds a remote-hosting step to your project and is part of the same PDF deliverable.

→ Open the Gitea Extension: Publishing to the Classroom Server

Other ways to use spare time productively

• Add more interaction to your program (mouse events, keyboard handlers, animation timing) and commit each change separately.
• Intentionally break your code, then use git restore . or git checkout <hash> -- . to roll back. Document what happened.
• Help a classmate troubleshoot their environment — mentoring others is on the TEKS rubric too.
• Read ahead about .gitignore and create one that excludes __pycache__/.

Quick Command Reference

# Check Python is installed
python --version

# Install CMU Graphics
pip install cmu-graphics

# Run a Python file
python my_program.py

# Git: initialize a repo (do this once per project)
git init

# Git: see what state the repo is in (use this constantly)
git status

# Git: stage all changes
git add .

# Git: take a snapshot
git commit -m "Descriptive message in imperative mood"

# Git: see your commit history
git log

# Git: see what you changed since last commit
git diff

# Git: throw away local edits (CAREFUL)
git restore <file>