Difficulty: Beginner | Prerequisites: CS 124 Course Overview notes. Familiarity with basic file management on your computer.
CS 124 does not just teach you to write code; it teaches you to work like a professional developer. The tools and practices introduced here (IDEs, version control, automated testing, linting, build systems) are the same ones used in industry. Learning them now means you spend less time fighting your environment and more time solving problems. These tools are also directly tested: one of the course's programming objectives is demonstrating competency with each of them.
You will use Android Studio as your IDE, Git for version control, Gradle as a build system, and either checkstyle (Java) or ktlint (Kotlin) for code style enforcement. You will also practise test-driven development and pair programming. All of these are examinable skills.
Integrated Development Environment (IDE)
A software application that combines a code editor, compiler/interpreter, debugger, and other tools in a single interface. Think of it as your workshop, where all the tools you need to write and test code are within arm's reach.
Android Studio
The official IDE for Android development, built on JetBrains' IntelliJ IDEA. CS 124 uses it for both regular coursework and the semester-long machine project.
Version control
A system that tracks changes to files over time, allowing you to revert to earlier versions, compare changes, and collaborate without overwriting each other's work. Think of it as an infinite undo history for your entire project.
Git
The most widely used distributed version control system. Each developer has a full copy of the project history on their own machine.
Test-driven development (TDD)
A development approach where you write automated tests for a feature before writing the code that implements it. In simple terms, you define "what does correct look like?" first, then write code until all those tests pass.
Linting / code style enforcement
Automated checking of source code for stylistic and structural issues (naming conventions, indentation, unused variables). Think of it as a spell-checker for code formatting.
checkstyle
A linting tool for Java that enforces a configurable set of coding conventions.
ktlint
A linting tool for Kotlin with a similar purpose to checkstyle, enforcing idiomatic Kotlin style.
Build system
A tool that automates compiling source code, running tests, packaging the application, and managing dependencies. Think of it as the assembly line that turns your raw code into a working program.
Gradle
The build system used by Android Studio and CS 124. It handles compilation, dependency management, and test execution.
Pair programming
A practice where two programmers work at one computer: one "drives" (types), the other "navigates" (reviews, thinks ahead). They switch roles regularly. This is both a collaboration technique and a learning method.
The course's programming objectives explicitly include learning to use these tools. You will be assessed on them.
Adopting good habits early (version control, testing, style consistency) prevents painful rewrites later.
The machine project in the second half of the semester is a real Android application; you cannot complete it without competency in Android Studio, Git, and Gradle.
Provides code completion, syntax highlighting, real-time error detection, and a built-in debugger.
Includes an Android emulator so you can test your app without a physical device.
Requires a machine capable of running it (most modern laptops and desktops are sufficient).
Learning to navigate the IDE efficiently (keyboard shortcuts, project structure view, the debugger panel) saves significant time on homework and quizzes.
Tracks every change you commit, so you can always return to a working state.
Essential for the machine project: you will submit code through Git.
Core workflow: add changed files, commit with a message describing the change, push to the remote repository.
Allows collaboration with a partner on the machine project while keeping a clear history of who changed what.
Write a test that describes the expected behaviour.
Run the test (it should fail, because the feature does not exist yet).
Write the minimum code to make the test pass.
Refactor, keeping all tests green.
This cycle forces you to think about the problem before coding the solution, which aligns with the course's emphasis on planning before implementation.
Enforces consistent formatting across your codebase.
Catches common style errors (missing braces, inconsistent naming, excessive line length) automatically.
Running the linter before submitting saves you from losing marks on style.
Configured through build files that specify dependencies, compiler settings, and tasks.
Running gradle build compiles your code, runs your tests, and reports any failures.
You do not need to understand Gradle's internals deeply for CS 124, but you should know how to trigger a build and interpret its output.
Two people, one keyboard, switching who drives on a timer.
The navigator is not idle; they review every line, catch mistakes, and think about the bigger picture.
In CS 124, pair programming is an option for the machine project. If you choose it, all work must be done together (no solo coding sessions).
Git is used by virtually every professional software team in the world. Comfort with version control is one of the most immediately transferable skills from CS 124.
Test-driven development is standard practice at many companies, from startups to large tech firms. Writing tests first reduces bugs and makes code easier to change later.
Students often think they can ignore the IDE's debugger and rely on print statements. The debugger lets you pause execution, inspect variables, and step through code line by line, which is far more efficient for complex bugs.
Students sometimes treat linting errors as optional. In CS 124, style matters. Clean code is easier to debug, easier for collaborators to read, and expected in professional settings.
Students sometimes assume version control is only useful for teams. Even working solo, Git protects you from losing work and makes it easy to experiment (you can always revert).
Students often underestimate pair programming, treating the navigator role as passive. Effective pairing means both people are engaged at all times.
⚠️ One of the course's assessed programming objectives is demonstrating competency with Android Studio, Git, TDD, linting, Gradle, and pair programming.
⚠️ Quizzes may include questions about development workflow, not just raw coding. Understanding what these tools do and why you use them is examinable.
⚠️ The machine project requires all of these tools working together. Struggling with the toolchain mid-project is a common source of lost time.
True or false: Git stores only the most recent version of your files.
Fill in the blank: In test-driven development, you write the ________ before you write the code.
True or false: checkstyle is a linting tool for Kotlin.
Fill in the blank: In pair programming, the person typing is called the ________.
True or false: Gradle is an IDE.
Answers: 1. False (Git stores the full history of all committed changes). 2. Tests. 3. False (checkstyle is for Java; ktlint is for Kotlin). 4. Driver. 5. False (Gradle is a build system; Android Studio is the IDE).
Q: What is the purpose of version control, and which version control system does CS 124 use?
A: Version control tracks changes to files over time, allowing you to revert, compare, and collaborate safely. CS 124 uses Git.
Q: Describe the four-step cycle of test-driven development.
A: Write a failing test, run it to confirm it fails, write the minimum code to pass the test, then refactor while keeping all tests passing.
Q: What is the difference between a linter and a compiler?
A: A compiler translates source code into executable code and catches syntax errors that would prevent the program from running. A linter checks for style and structural issues (naming, formatting, potential logical mistakes) that the compiler would accept but that make code harder to read or maintain.
Q: Why does CS 124 use a staggered, checkpoint-based approach for the machine project instead of separate unconnected assignments?
A: Working on a single evolving project mirrors real software development, where you build on and improve existing code over time rather than starting from scratch each week. It encourages students to fix earlier mistakes and results in a more substantial final product.
Git proficiency carries directly into every subsequent CS course and into professional software work.
The debugging skills you develop in Android Studio apply to any IDE or debugger you encounter later.
Test-driven development connects to software engineering courses (e.g. CS 427) where testing methodologies are studied in depth.
CS 124, UIUC, Android Studio, IDE, integrated development environment, Git, version control, test-driven development, TDD, checkstyle, ktlint, linting, code style, Gradle, build system, pair programming, debugging, machine project, Android development, software development tools, CS 124 tools, CS 124 exam prep