Difficulty: Beginner | Prerequisites: Three years of high school maths (or Math 112). No prior programming experience required.
CS 124 is the entry point to computer science at UIUC. It covers both how to think about computational problems and how to build working solutions in Java or Kotlin. The course splits roughly into two halves: daily lessons on programming fundamentals in the first half, then a multi-part Android application project in the second half. If you are coming in cold, the single most important thing to know is that programming is treated as a skill here, not a body of facts to memorise, so consistent daily practice matters far more than cramming.
CS 124 teaches you to design algorithms, write programs in Java or Kotlin, and reason about how computers represent and manipulate data. It pairs conceptual understanding (how algorithms work, why data structures matter) with hands-on programming using professional tools like Android Studio and Git. Everything builds cumulatively, so keeping up with daily lessons is the core study strategy.
Computer science
Both an applied and a conceptual discipline. The applied side is programming; the conceptual side is designing efficient solutions (algorithms) and reasoning about data.
Algorithm
A step-by-step procedure that a computer follows to solve a problem. In this course you will work with both iterative algorithms (loops) and recursive algorithms (a function that calls itself).
Iterative algorithm
An algorithm that repeats a block of instructions using a loop (e.g. for, while) until a condition is met. Think of it as: "keep doing this until you are done."
Recursive algorithm
An algorithm where a function solves a problem by calling itself on a smaller version of the same problem, plus a base case that stops the chain. Think of it as: Russian nesting dolls, each one opening the next smaller one until you reach the solid one at the centre.
Object-oriented programming (OOP)
A programming paradigm that organises code around objects, which bundle data (fields) and behaviour (methods) together. Java and Kotlin are both object-oriented languages.
Object
An instance of a class. It holds its own data and exposes methods you can call. In simple terms, if a class is a blueprint for a house, an object is one actual house built from that blueprint.
Class
A template or blueprint that defines what data an object holds and what it can do.
Encapsulation
The practice of hiding an object's internal state and requiring all interaction to go through well-defined methods. Think of it as: you use a TV remote's buttons (public interface) without needing to know the circuit board inside (private implementation).
Inheritance
A mechanism where one class (the child or subclass) acquires the properties and behaviours of another class (the parent or superclass), then extends or overrides them. In simple terms, a "SportsCar" class can inherit from a "Car" class and add a turbo mode.
Data types
Categories of data a program can work with: numbers (integers, floating-point), strings (text), booleans (true/false), and more complex structures like arrays and lists.
Data structures
Ways of organising and storing data so it can be accessed and modified efficiently. Examples include arrays, lists, maps and sets. CS 124 covers simple built-in data structures available in Java and Kotlin.
Runtime (computational complexity)
A measure of how the time or space an algorithm needs grows as the input gets larger. Understanding runtime tradeoffs helps you choose the right algorithm or data structure for a given problem.
Integrated development environment (IDE)
Software that combines a code editor, compiler, debugger and build tools in one application. CS 124 uses Android Studio.
Version control (Git)
A system that tracks every change made to your code so you can revert mistakes, compare versions and collaborate safely. Git is the industry standard.
Build system (Gradle)
A tool that automates compiling your code, running tests, and packaging the finished application. Gradle is the default build system for Android projects.
Linter / style checker (checkstyle, ktlint)
A tool that scans your source code for style violations and potential errors. checkstyle is used for Java; ktlint for Kotlin.
Test-driven development (TDD)
A workflow where you write automated tests before writing the code that makes them pass. It forces you to think about what correct behaviour looks like upfront.
Debugging
The process of finding and fixing errors (bugs) in your code. CS 124 treats debugging as a core skill, assessed alongside writing new code.
CS is both applied (you build things) and conceptual (you reason about how to build them well).
Programming gives you the ability to turn ideas into working software, but the deeper skill is learning to design solutions that are correct, clear and efficient.
The problem-solving loop taught in this course:
Read and understand the problem description.
Formulate a plan, including edge cases and unusual inputs.
Express the plan precisely in code.
Test, find mistakes, and revise.
These steps, reading comprehension, planning, precise expression and iterating on errors, are transferable well beyond programming.
An iterative approach uses loops to repeat operations. Most early CS 124 problems use iteration.
A recursive approach breaks a problem into smaller instances of itself. You need a base case (the simplest version that can be answered directly) and a recursive case (the step that reduces the problem).
The course expects you to reason about the computational and storage requirements of your algorithms, meaning you should be able to say roughly how much work an algorithm does as input size grows.
Computers represent everything as numbers at the lowest level.
CS 124 covers how computers handle:
Numbers (integers, floating-point, and the precision quirks that come with them)
Strings (sequences of characters, how text is stored and manipulated)
Multimedia data including images and audio
Understanding data representation helps explain why, for example, floating-point arithmetic can produce surprising results (0.1 + 0.2 ≠ 0.3 in many languages).
Both Java and Kotlin are object-oriented and run on the Java Virtual Machine (JVM).
Core OOP concepts covered:
Object orientation: structuring programs around objects rather than functions.
Object types: every object belongs to a class, which defines its type.
Encapsulation: keeping internal state private, exposing only what is needed.
Inheritance: building new classes on top of existing ones.
You are expected to design and implement small-to-medium programs using iterative, object-oriented and recursive approaches as appropriate.
Android Studio: the IDE for writing, running and debugging Java/Kotlin code and Android apps.
Git: version control. You track changes, create branches and revert mistakes.
Gradle: builds and tests your project automatically.
checkstyle / ktlint: enforces a consistent coding style.
Test-driven development: write the test first, then write the code to pass it.
Pair programming: two developers working on one machine, alternating who types ("drives"). Used in the machine project if you choose a human partner.
A single, multi-part Android application built across several checkpoints in the second half of the semester.
Unlike isolated assignments, this simulates real software development: you start simple, add features iteratively, and live with earlier design decisions.
Reinforces all core concepts (OOP, data structures, algorithms) in a practical, applied context.
The problem-solving framework (understand, plan, code, test, revise) is identical to the workflow used in professional software engineering. The specific tools, Android Studio, Git, Gradle, are all industry standards. Building an Android app from scratch mirrors how real mobile development teams work: incremental feature delivery on a shared codebase.
"CS is just coding." Coding is the applied half. The other half, designing algorithms, reasoning about efficiency, structuring data, is equally important and is what the quizzes test conceptually.
"Prior experience gives an enormous advantage." The course reports only a 2% grade gap between students with and without prior experience (Fall 2024 data). Consistent daily practice closes the gap quickly.
"Recursion and iteration are interchangeable choices." They often can solve the same problem, but they have different tradeoff profiles in clarity, memory usage and performance. The course expects you to reason about when each approach is appropriate.
"Encapsulation is just making fields private." Encapsulation is about controlling access and behaviour. Private fields are the mechanism; the purpose is to protect the integrity of an object's state and make code easier to change later.
⚠️ Quizzes contain multiple-choice questions on conceptual content and timed programming/debugging challenges. Knowing the theory without being able to code it under time pressure is not enough.
⚠️ Quiz programming problems are similar (but not identical) to the daily homework. Completing homework is the single best preparation strategy.
⚠️ All material is cumulative. Each quiz emphasises recent content, but anything covered so far in the semester is fair game.
⚠️ You will need to understand runtime and design tradeoffs between different algorithms and data structures, not just write code that works.
⚠️ Debugging is assessed as its own skill. Quizzes include debugging challenges alongside writing new code.
True or false: An algorithm must use a loop to be considered iterative.
True. Iteration is defined by the use of a loop construct (for, while, etc.) to repeat instructions.
True or false: Encapsulation means the same thing as inheritance.
False. Encapsulation is about hiding internal state behind a public interface. Inheritance is about one class acquiring properties and behaviours from another.
Fill in the blank: A recursive algorithm requires a ________ to stop calling itself.
Base case.
True or false: Git is a build system.
False. Git is a version control system. Gradle is the build system used in CS 124.
True or false: CS 124 uses Python as its primary language.
False. CS 124 uses Java or Kotlin.
Q: What are the two broad categories of algorithms covered in CS 124, and how do they differ?
A: Iterative algorithms, which use loops to repeat operations, and recursive algorithms, which solve a problem by calling themselves on progressively smaller sub-problems until reaching a base case.
Q: Name three core principles of object-oriented programming discussed in this course.
A: Object orientation (organising code around objects), encapsulation (hiding internal state behind a public interface), and inheritance (building new classes from existing ones).
Q: Why does CS 124 ask you to reason about the computational and storage requirements of your algorithms?
A: Because a solution that works on small inputs may become impractically slow or memory-hungry on larger inputs. Understanding these tradeoffs lets you choose the right approach for the problem at hand.
Q: What is the difference between a class and an object?
A: A class is a blueprint that defines data fields and methods. An object is a specific instance of a class, holding its own values for those fields.
Q: Name four professional development tools used in CS 124 and state what each does.
A: Android Studio (IDE for writing and debugging code), Git (version control for tracking changes), Gradle (build system for compiling and testing), and checkstyle or ktlint (linter for enforcing coding style).
This material feeds directly into CS 128 (Introduction to Computer Science II) and more advanced data-structures and algorithms courses. The OOP foundations (encapsulation, inheritance) reappear in every object-oriented language and in design-patterns coursework. Version control with Git is used in virtually every subsequent CS course and in industry.
CS 124, UIUC, Intro to Computer Science, Java, Kotlin, algorithm, iterative, recursive, recursion, loop, object-oriented programming, OOP, class, object, encapsulation, inheritance, data types, data structures, Android Studio, Git, Gradle, checkstyle, ktlint, test-driven development, TDD, debugging, pair programming, machine project, Android app, computational complexity, runtime tradeoffs, Geoffrey Challen, University of Illinois Urbana-Champaign