Difficulty: Beginner | Prerequisites: Three years of high school mathematics or Math 112. No prior programming experience required.
CS 124 is the entry point to computer science at UIUC, designed equally for complete beginners and those with some prior experience. The course covers two parallel tracks: conceptual understanding (how to think about computation, algorithms, and data) and practical skill (writing real programs in Java or Kotlin). By the second half of the semester, you will be building a multi-part Android application, so the early weeks of fundamentals feed directly into that project. Everything here is foundational for CS 128 and beyond.
Computer science is both a way of thinking and a practical craft. CS 124 teaches you to design algorithms, represent and manipulate data, use object-oriented programming principles, and reason about the efficiency of your solutions, all through Java or Kotlin.
Algorithm
A step-by-step procedure for solving a problem that a computer can execute. Think of it as a recipe written precisely enough that a very literal machine can follow it without ambiguity.
Iterative algorithm
An algorithm that repeats a set of instructions using loops (e.g. for, while) until a condition is met. In simple terms, this means "keep doing the same thing over and over until you're done."
Recursive algorithm
An algorithm that solves a problem by calling itself on a smaller version of the same problem, with a base case to stop. Think of it as solving a big task by breaking it into smaller identical tasks, each of which breaks down further.
Data representation
How information (numbers, text, images, audio) is encoded and stored inside a computer. In simple terms, this is how a computer turns everything into patterns of bits it can work with.
Object-oriented programming (OOP)
A programming paradigm that organises code around objects, which bundle data (fields) and behaviour (methods) together. Think of it as modelling real-world things in code, each with its own properties and actions.
Encapsulation
The practice of hiding an object's internal state and requiring interaction through well-defined methods. In simple terms, this means an object controls its own data and only lets the outside world access it in approved ways.
Inheritance
A mechanism where one class (child) derives properties and behaviours from another class (parent), allowing code reuse and hierarchical relationships. Think of it as a more specific thing automatically getting the features of a more general thing.
Object type
The class or interface that defines what data an object holds and what operations it supports. In simple terms, the "blueprint" that says what kind of thing an object is.
Data structure
A particular way of organising and storing data so that specific operations (searching, inserting, sorting) can be performed efficiently. Think of it as choosing the right container for the job.
Computational complexity / runtime
A measure of how the time (or space) an algorithm requires grows as the input size increases. In simple terms, this is how you answer "will this still be fast when the data gets big?"
CS is both an applied discipline (you build things) and a conceptual one (you reason about problems).
Programming is the applied side: translating ideas into precise instructions a computer can execute.
Algorithm design is the conceptual side: creating solutions that are correct, complete, and efficient enough for computers to carry out at scale.
The combination is distinctive: analytical thinking, creative design, and global-scale deployment all in one field.
Read and understand the problem description.
Formulate a plan that handles both typical and unusual cases.
Express that plan precisely in code.
Test, identify mistakes, and revise.
This cycle (comprehension, planning, expression, debugging) is a transferable skill, not limited to programming.
Algorithms and problem-solving: Design both iterative and recursive solutions. Reason about how much time and memory they require.
Data representation: Understand how computers store and manipulate numbers, strings, and multimedia data (images and audio).
OOP concepts: Object orientation, object types, encapsulation, and inheritance in Java or Kotlin.
Runtime and design tradeoffs: Compare different algorithms and data structures by their efficiency and suitability for a given task.
Design and implement small-to-medium Java or Kotlin programs using iterative, object-oriented, and recursive approaches.
Use standard Java/Kotlin libraries, including objects and built-in data structures.
Work with professional development tools: Android Studio (IDE), Git (version control), test-driven development, a linting tool (checkstyle or ktlint), and Gradle (build system).
Debug and test programs systematically.
Apply programming to solve problems outside pure CS contexts.
The semester follows a three-phase arc:
Phase 1 – Imperative programming (roughly Quizzes 1–5): Variables, types, control flow, loops, functions. The building blocks.
Phase 2 – Objects (roughly Quizzes 6–9): Classes, instances, encapsulation, inheritance, polymorphism. Organising code at a larger scale.
Phase 3 – Data structures and algorithms (roughly Quizzes 10–15): How to store, search, and sort data efficiently. Reasoning about performance.
Each phase builds on the previous one. Falling behind in Phase 1 makes Phase 2 significantly harder, and so on.
No specific formulas are introduced in the syllabus overview. Computational complexity notation (e.g. Big-O) will appear in Phase 3. Keep an eye out for runtime analysis once you reach data structures.
The Android application you build in the second half of the semester is a real, working piece of software on a real platform, the kind of project that mirrors how apps are built in industry.
Algorithm design and data structure choices underpin everything from search engines to route planning to social media feeds.
Students often think CS 124 requires prior programming experience. It does not; the course is designed for complete beginners, and historically the grade gap between experienced and inexperienced students has been only around 2%.
Students often confuse "knowing how to use a computer" with "knowing computer science." Using apps is not the same as designing algorithms and writing programs.
Students sometimes assume that if they find the material difficult early on, they are not suited for CS. Programming is a skill that improves with consistent daily practice, not a talent you either have or lack.
Students sometimes treat the conceptual objectives (algorithm analysis, data representation) as less important than the coding. Quizzes test both, and the conceptual side is what separates CS from "just coding."
⚠️ Quizzes cover both conceptual understanding and programming. You will be tested on ideas (multiple-choice) and on writing/debugging code under timed conditions.
⚠️ The three-phase structure (imperative → objects → data structures) means each quiz assumes mastery of all prior material, not just the most recent week.
⚠️ Expect quiz programming questions to be similar (but not identical) to the homework problems from the previous week. Completing homework is the single best quiz preparation.
⚠️ You get unlimited attempts on quiz programming and debugging challenges, but time is limited. Speed comes from practice, not from cramming.
True or false: An algorithm must be written in a programming language to count as an algorithm.
Fill in the blank: A ________ algorithm solves a problem by calling itself on a smaller instance of the same problem.
True or false: Encapsulation means making all of an object's data publicly accessible.
Fill in the blank: The measure of how an algorithm's resource usage grows with input size is called ________.
True or false: CS 124 covers only Java, not Kotlin.
Answers: 1. False (an algorithm is a procedure; code is one way to express it). 2. Recursive. 3. False (encapsulation hides internal state). 4. Computational complexity (or runtime complexity). 5. False (both Java and Kotlin are used).
Q: What are the two parallel tracks that CS 124 covers, and why does each matter?
A: The conceptual track (algorithm design, data representation, complexity analysis) teaches you to think about problems rigorously. The practical track (programming in Java/Kotlin, using development tools) teaches you to build working software. Together they form the core of computer science.
Q: Name the four key OOP concepts covered in CS 124.
A: Object orientation, object types, encapsulation, and inheritance.
Q: Describe the difference between an iterative algorithm and a recursive algorithm.
A: An iterative algorithm uses loops to repeat steps until a condition is met. A recursive algorithm calls itself on a smaller sub-problem, reducing the problem size each time until it hits a base case.
Q: Why is reasoning about computational and storage requirements important when designing algorithms?
A: Two algorithms can both produce the correct answer but differ enormously in how long they take or how much memory they use. Analysing these requirements lets you choose solutions that will still perform well as data grows larger.
Q: What types of data representation does CS 124 cover?
A: Numbers, strings, and multimedia data including images and audio.
The OOP concepts in CS 124 (encapsulation, inheritance) lay the groundwork for design patterns and software architecture in later courses.
Data structures and algorithm analysis connect directly to CS 225 (Data Structures), where you will go much deeper into trees, graphs, hashing, and complexity.
The Android development skills feed into mobile development and software engineering coursework, and are directly applicable to personal or professional projects.
CS 124, UIUC, intro to computer science, Java, Kotlin, algorithm, iterative, recursive, data representation, object-oriented programming, OOP, encapsulation, inheritance, object types, data structures, computational complexity, runtime analysis, Android Studio, Git, test-driven development, checkstyle, ktlint, Gradle, pair programming, CS 124 study guide, CS 124 exam prep, intro CS concepts, beginner programming