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.
Phase 1: Introduction to CS & Programming Basics
Days 1-10Understand fundamental computer science concepts and write basic Python programs.
- 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
- 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.
Successfully write and run a Python program that takes user input and performs a simple calculation.
Phase 2: Control Flow & Logic
Days 11-20Implement decision-making and repetitive tasks in programs using conditional statements and loops.
- Comparison Operators & Boolean Logic
- Conditional Statements (if, elif, else)
- Loops (for loop, while loop)
- Break and Continue statements
- 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.
Develop a text-based game or utility that uses both conditional logic and loops effectively.
Phase 3: Functions & Modular Programming
Days 21-30Organize code into reusable blocks and understand program structure through functions.
- Defining and Calling Functions
- Function Parameters and Arguments
- Return Values
- Local vs. Global Scope
- Introduction to Recursion (simple examples)
- 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.
Design and implement a program with multiple, well-defined functions that pass data between them.
Phase 4: Basic Data Structures - Lists & Tuples
Days 31-40Store and manipulate collections of data efficiently using lists and tuples.
- Introduction to Lists
- List Indexing, Slicing, and Methods (append, insert, remove, sort)
- List Comprehensions (basic)
- Introduction to Tuples (immutable sequences)
- 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.
Build a program that effectively manages a collection of items, demonstrating list manipulation skills.
Phase 5: Review & Catch-upBuffer Phase
Days 41-50Consolidate understanding of the foundational concepts from the first four phases and reinforce learning.
- Review Python Syntax & Semantics
- Practice Problem Solving with Control Flow
- Revisit Function Design Principles
- Reinforce List and Tuple Operations
- 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).
Confidently explain and implement solutions for problems requiring a mix of Python fundamentals, control flow, functions, and basic data structures.
Phase 6: Advanced Data Structures - Dictionaries & Sets
Days 51-60Understand and apply more complex data storage mechanisms like dictionaries and sets.
- 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)
- 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).
Develop a program that utilizes dictionaries to store and retrieve structured data efficiently.
Phase 7: File I/O & Error Handling
Days 61-70Enable programs to interact with files and make them robust against common errors.
- 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
- 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.
Create a program that reads and writes data to files, incorporating robust error handling for common issues.
Phase 8: Introduction to Object-Oriented Programming (OOP)
Days 71-80Grasp the basic principles of Object-Oriented Programming for designing modular and reusable code.
- What is OOP? (Concepts: objects, classes)
- Defining Classes and Creating Objects
- Attributes (instance and class variables)
- Methods (instance methods, `self` parameter)
- Constructors (`__init__` method)
- 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.
Design and implement at least two related classes with appropriate attributes and methods, demonstrating basic OOP principles.
Phase 9: Final Project & ReviewBuffer Phase
Days 81-90Apply all learned concepts to a comprehensive project and prepare for continued learning in computer science.
- Integration of all previously learned concepts
- Project Planning and Design
- Debugging and Testing Strategies
- Review of Core CS Principles
- 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).
Complete a functional personal project that integrates multiple core computer science and Python programming concepts, demonstrating proficiency gained over the 90 days.