Tech & Software90 DaysBeginner

First Year Computer Science Learning Roadmap

This roadmap provides a foundational understanding of core computer science principles, programming fundamentals, and essential data structures and algorithms, preparing beginners for advanced studies.

Curated by@peteriishakverified
  1. Phase 1

    Phase 1: Introduction to CS & Programming Basics

    Days 1-10

    Understand fundamental computer science concepts and write basic Python programs.

    Learn

    • What is Computer Science?
    • Computational Thinking & Problem Solving
    • Introduction to Python
    • Variables, Data Types (int, float, str, bool)
    • Basic Input/Output (print(), input())
    • Arithmetic Operators

    Practice & build

    • Set up Python development environment.
    • Write a 'Hello, World!' program.
    • Create a program to calculate simple arithmetic expressions.
    • Write a program that takes user's name and prints a greeting.

    Milestone

    Successfully write and run a Python program that takes user input and performs a simple calculation.

  2. Phase 2

    Phase 2: Control Flow & Logic

    Days 11-20

    Implement decision-making and repetitive tasks in programs using conditional statements and loops.

    Learn

    • Comparison Operators & Boolean Logic
    • Conditional Statements (if, elif, else)
    • Loops (for loop, while loop)
    • Break and Continue statements

    Practice & build

    • Build a simple 'guess the number' game.
    • Write a program that checks if a number is even or odd.
    • Implement a loop to print numbers from 1 to 10.
    • Calculate the factorial of a number using a loop.

    Milestone

    Develop a text-based game or utility that uses both conditional logic and loops effectively.

  3. Phase 3

    Phase 3: Functions & Modular Programming

    Days 21-30

    Organize code into reusable blocks and understand program structure through functions.

    Learn

    • Defining and Calling Functions
    • Function Parameters and Arguments
    • Return Values
    • Local vs. Global Scope
    • Introduction to Recursion (simple examples)

    Practice & build

    • Refactor previous programs by extracting logic into functions.
    • Write functions for common mathematical operations (e.g., 'add', 'subtract').
    • Implement a recursive function for Fibonacci sequence or factorial.
    • Create a module with a few utility functions.

    Milestone

    Design and implement a program with multiple, well-defined functions that pass data between them.

  4. Phase 4

    Phase 4: Basic Data Structures - Lists & Tuples

    Days 31-40

    Store and manipulate collections of data efficiently using lists and tuples.

    Learn

    • Introduction to Lists
    • List Indexing, Slicing, and Methods (append, insert, remove, sort)
    • List Comprehensions (basic)
    • Introduction to Tuples (immutable sequences)

    Practice & build

    • Create a program to manage a To-Do list (add, view, remove items).
    • Write a script to find the maximum/minimum value in a list.
    • Sort a list of numbers or strings.
    • Use tuples to store coordinates or immutable records.

    Milestone

    Build a program that effectively manages a collection of items, demonstrating list manipulation skills.

  5. Phase 5

    Phase 5: Review & Catch-up

    Days 41-50
    Buffer phase — time to catch up

    Consolidate understanding of the foundational concepts from the first four phases and reinforce learning.

    Learn

    • Review Python Syntax & Semantics
    • Practice Problem Solving with Control Flow
    • Revisit Function Design Principles
    • Reinforce List and Tuple Operations

    Practice & build

    • Re-attempt challenging exercises or projects from previous phases.
    • Work on a small, integrated project combining functions, loops, and lists.
    • Read official Python documentation for covered topics.
    • Explain key concepts to a peer (or rubber duck debugging).

    Milestone

    Confidently explain and implement solutions for problems requiring a mix of Python fundamentals, control flow, functions, and basic data structures.

  6. Phase 6

    Phase 6: Advanced Data Structures - Dictionaries & Sets

    Days 51-60

    Understand and apply more complex data storage mechanisms like dictionaries and sets.

    Learn

    • Introduction to Dictionaries (key-value pairs)
    • Dictionary Operations (add, retrieve, update, delete)
    • Dictionary Methods (keys(), values(), items())
    • Introduction to Sets (unique, unordered collections)
    • Set Operations (union, intersection, difference)

    Practice & build

    • Build a simple contact book using a dictionary.
    • Create a program to count word frequencies in a sentence using dictionaries.
    • Use sets to find unique elements in a list or common elements between two lists.
    • Implement a basic 'lookup' system (e.g., student grades).

    Milestone

    Develop a program that utilizes dictionaries to store and retrieve structured data efficiently.

  7. Phase 7

    Phase 7: File I/O & Error Handling

    Days 61-70

    Enable programs to interact with files and make them robust against common errors.

    Learn

    • Reading from Text Files (open(), read(), readline(), readlines(), close())
    • Writing to Text Files
    • Context Managers (with open() as file)
    • Understanding Exceptions
    • Handling Exceptions (try-except blocks)
    • Common Exception Types

    Practice & build

    • Write a program that reads data from a text file and processes it.
    • Create a script to write user-generated content to a file.
    • Implement error handling for potential file not found errors.
    • Add try-except blocks to user input validation loops.

    Milestone

    Create a program that reads and writes data to files, incorporating robust error handling for common issues.

  8. Phase 8

    Phase 8: Introduction to Object-Oriented Programming (OOP)

    Days 71-80

    Grasp the basic principles of Object-Oriented Programming for designing modular and reusable code.

    Learn

    • What is OOP? (Concepts: objects, classes)
    • Defining Classes and Creating Objects
    • Attributes (instance and class variables)
    • Methods (instance methods, `self` parameter)
    • Constructors (`__init__` method)

    Practice & build

    • Define a simple class like 'Car' or 'Person' with attributes and methods.
    • Create multiple objects (instances) from the defined class.
    • Implement a method that modifies an object's attribute.
    • Design a class for a bank account with deposit/withdraw methods.

    Milestone

    Design and implement at least two related classes with appropriate attributes and methods, demonstrating basic OOP principles.

  9. Phase 9

    Phase 9: Final Project & Review

    Days 81-90
    Buffer phase — time to catch up

    Apply all learned concepts to a comprehensive project and prepare for continued learning in computer science.

    Learn

    • Integration of all previously learned concepts
    • Project Planning and Design
    • Debugging and Testing Strategies
    • Review of Core CS Principles

    Practice & build

    • Develop a command-line application (e.g., simple library management system, text-based adventure game, basic inventory system) that incorporates functions, data structures, file I/O, and basic OOP.
    • Document your project code and design choices.
    • Review all topics covered in the roadmap, identify areas for further study.
    • Explore potential next steps in computer science (e.g., algorithms, web development, data science).

    Milestone

    Complete a functional personal project that integrates multiple core computer science and Python programming concepts, demonstrating proficiency gained over the 90 days.

Want one built around you?

Turn any learning goal into a clear, actionable plan in seconds.

Create your roadmap