CS 2820: Version Control, LLMs, and Software Development Models

Vocabulary practice cards covering Version Control with Git, LLMs in Software Development, and Software Development Life Cycle models.

Version Control System (VCS)

Software that tracks, manages, and records revisions to a set of files across individual and collaborative software projects over time.

Repository (Repo)

A centralized or distributed storage location that holds all source code, build configurations, resource files, and complete revision history for a project.

Working Directory

The local workspace directory on a developer's machine containing current uncommitted file modifications, distinct from the staging index and local repository.

Staging Area

An intermediate phase (also known as the Index) in Git where modified files are formatted as snapshot preparations prior to being committed to the repository.

Remote Repository

A shared repository hosted on central platforms like GitHub or GitLab that enables team members to push local updates and pull shared changes.

HEAD Pointer

A reference pointer in Git that indicates the active branch or commit currently checked out in the local working directory.

Main Branch

The primary production-ready branch in a repository serving as the canonical source of truth, expected to contain stable and compilable code.

Git Four Workflow Phases

The sequential stages through which code changes progress: Working Directory, Staging Area/Index, Local Repository, and Remote Repository.

git add

A Git command that transfers modified or new files from the working directory into the staging area to prepare them for the next commit snapshot.

git commit

A Git command that records a permanent snapshot of all staged changes into the local repository with a mandatory descriptive message.

git status

A Git command that displays the state of the working directory and staging area, identifying staged, modified, and untracked files.

git diff

A Git command that compares line-by-line differences between files in the working directory and those in the staging area or repository.

git pull

A composite Git operation that fetches the latest commits from a remote branch and automatically attempts to merge them into the current active branch.

git push

A Git command that uploads committed local repository changes to a specified remote repository branch.

Large Language Model (LLM)

An artificial intelligence system trained on extensive text datasets to predict word sequences, understand human language, and generate source code.

LLM Token

The atomic fragment of text processed by a language model, typically representing approximately 4 characters or 0.75 English words.

Context Window

The maximum total token capacity an LLM can evaluate in a single prompt cycle, including system instructions, uploaded context, and the output response.

Lost in the Middle Phenomenon

The tendency of language models to accurately retrieve information located at the extreme start or end of long prompts while ignoring details in the center.

Prompt Caching

An optimization feature in AI platforms that stores repeated context tokens to reuse them across prompts, lowering API costs by up to 90%.

Extended Thinking Mode

A test-time compute technique where an LLM pauses before rendering text to dynamically generate hidden reasoning blocks, outline logic, and self-correct.

Scratchpad Block

An internal workspace generated during an LLM reasoning phase to draft algorithms and verify constraints prior to producing visible user output.

Thinking Tokens

Internal reasoning tokens generated during LLM extended thinking, billed to developers at the higher output rate rather than the standard input rate.

Software Development Life Cycle (SDLC)

The structured pipeline of software development stages: Conception, Requirements gathering, Design, Coding/debugging, Testing, Release, Maintenance, and Retirement.

Plan-Driven Models

Heavyweight development methodologies characterized by strict, sequential execution phases, exhaustive upfront planning, and extensive formal documentation.

Agile Development Models

Lightweight, iterative development approaches focusing on continuous customer collaboration, frequent working software releases, and flexibility to change.

Waterfall Process Model

A classical plan-driven SDLC model where project execution flows strictly downward through sequential phases from requirements gathering to maintenance.

Evolutionary Prototyping Process Model

An iterative model where a rapid prototype is built, evaluated by customers, and continuously refined through feedback until the final product release.

Refactoring

The disciplined software development technique of restructuring internal source code to improve design, readability, and maintainability without altering external behavior.

Extreme Programming (XP)

An Agile software engineering framework prioritizing practices such as test-driven development (TDD), pair programming, continuous integration, and frequent releases.

Pair Programming

An Agile XP technique where two developers work together at one workstation, alternating between the 'driver' writing code and the 'navigator' reviewing it every 30 to 60 minutes.

Scrum Framework

An Agile management process organized around fixed-length Sprints (up to 1 month), Daily Scrums, Product Backlogs, and key roles like Product Owner and Scrum Master.

Coding Standards

Organization-wide rules and guidelines governing code layout, naming conventions, and header formats to ensure uniform readability and quality across teams.

Checkstyle

A developer tool/plugin used to automatically inspect Java code against predefined coding style rules, such as Google or Sun guidelines.

Defensive Programming

A software design practice where code is written to protect itself against invalid inputs, unexpected environmental conditions, and runtime failures.

Assertion

A diagnostic check that tests an expression assumed to always be true, throwing an error if false, primarily used during debugging to catch unrecoverable flaws.

JavaDoc

A documentation tool that automatically generates HTML-based API technical documentation directly from structured doc comments embedded in Java source code.

Runtime Errors

Program execution failures (such as NullPointerException or ArrayIndexOutOfBoundsException) that cause a compiled application to crash while running.

Testing vs. Debugging

Testing is the process of executing a program to reveal the presence of defects, whereas debugging is the process of locating, isolating, and fixing those defects.

Fault Injection

A testing technique where unusual failures (such as network drops or memory allocation errors) are intentionally introduced to evaluate how code handles uncommon edge cases.