🎓 CS50: Introduction to Computer Science

"This is CS50!" - David J. Malan

🚀 About This Repository

Welcome to my CS50 journey! This repository contains comprehensive notes, code examples, and implementations from Harvard's CS50: Introduction to Computer Science course, taught by the legendary David J. Malan.

💡 Understanding What's Underneath the Hood

As David always emphasizes, CS50 isn't just about learning to code—it's about understanding what's happening underneath the hood. This course teaches us to think computationally and solve problems methodically, building a strong foundation that transcends any single programming language.

🎯 Course Philosophy

David's Key Mantras:

• 🔍 "Understanding underneath the hood" - We don't just use tools; we understand how they work
• 🧠 "Computational thinking" - Breaking down complex problems into manageable pieces
• 🎨 "Correctness, Design, Style" - The three pillars of good programming
• 🌟 "This is less comfortable → more comfortable" - Growth happens outside your comfort zone
• 🎪 "Algorithms in pseudocode" - Think first, code second
• 🔢 "Off by one errors" - Attention to detail matters
• 📊 "Big O notation" - Efficiency and scalability are crucial

📚 Course Structure

Week 0: Scratch - Thinking Algorithmically

• Binary representation - How computers really "think"
• Pseudocode - Planning before programming
• Visual programming with Scratch blocks

Week 1: C - Getting Closer to the Machine

• Low-level programming - Understanding memory and pointers
• Functions and scope - Building reusable code
• Data types - Choosing the right tool for the job

Week 2: Arrays - Data Structures Fundamentals

• Memory layout - How data is actually stored
• Strings as arrays - Characters under the hood
• Command-line arguments - Programs that take input

Week 3: Algorithms - Efficiency Matters

• Big O notation - Measuring algorithmic efficiency
• Searching algorithms - Linear vs Binary search
• Sorting algorithms - Selection, Bubble, and Merge sort
• Recursion - Functions calling themselves

Week 4: Memory - Manual Memory Management

• Pointers - Direct memory access
• Dynamic memory allocation - malloc() and free()
• Memory leaks - What happens when you forget to clean up

Week 5: Data Structures - Abstract Data Types

• Linked lists - Dynamic memory allocation
• Trees and binary search trees - Hierarchical data
• Hash tables - Fast lookups with O(1) average time
• Tries - Efficient string storage and retrieval
• Stacks and queues - LIFO and FIFO data structures

Week 6: Python - Higher-Level Programming

• Python syntax - From C to Python transition
• Data structures - Lists, dictionaries, sets, tuples
• File I/O - Reading/writing files, CSV, JSON
• Libraries - Importing modules and packages
• Image processing - PIL for image manipulation
• Face recognition - Computer vision applications

Week 7: Artificial Intelligence - Machine Learning & AI

• Generative AI - ChatGPT, image generation, and AI applications
• Decision trees - Classification algorithms and information gain
• Minimax algorithm - Game-playing AI with alpha-beta pruning
• Machine learning - Supervised and unsupervised learning concepts
• Neural networks - Deep learning and large language models
• Prompt engineering - Crafting effective AI prompts
• AI ethics - Hallucinations, bias, and responsible AI use

Week 8: SQL - Databases and Data Management

• Relational databases - Moving beyond flat files to structured data
• SQL syntax - CREATE, SELECT, INSERT, UPDATE, DELETE operations
• Database design - Schema creation, normalization, and relationships
• Primary and foreign keys - Data integrity and table relationships
• Joins and complex queries - Combining data from multiple tables
• Indexes - Performance optimization for large datasets
• Python integration - Using sqlite3 and database APIs
• Security - SQL injection prevention and parameterized queries
• Concurrency - Race conditions and transaction management

Week 9: HTML, CSS, JavaScript - Web Development Fundamentals

• Web protocols - HTTP, DNS, and how the internet works
• HTML for structure - Semantic markup, forms, tables, and accessibility
• CSS for style - Selectors, box model, flexbox, and responsive design
• JavaScript for behavior - DOM manipulation, events, and client-side interactivity
• Web APIs - Geolocation, local storage, and other browser capabilities
• Code Organization - The importance of separating structure, style, and behavior into different files

Week 10: Flask - Web Application Development

• Web programming basics - HTTP, client-server model, request/response cycle
• Flask microframework - Routing, views, and application structure
• HTML forms - Handling user input and validation
• Templates (Jinja2) - Dynamic content and code reuse
• Sessions and cookies - Maintaining state across requests
• SQLite integration - Persistent data storage
• APIs and JSON - Building and consuming web APIs

🛠️ Technologies & Tools

Languages: C, Python, SQL, HTML, CSS, JavaScript
Tools: VS Code, GitHub, Flask, SQLite, MySQL
Libraries: CS50, PIL, face_recognition, sqlite3, csv, json
Web Technologies: HTML5, CSS3, JavaScript ES6+, Responsive Design, DOM Manipulation
Databases: SQLite, relational database concepts
AI Concepts: Machine Learning, Neural Networks, Decision Trees, Minimax

📁 Repository Structure

CS50/
├── 📂 Lecture 0 - Scratch/
│   └── Scratch.txt
├── 📂 Lecture 1 - C/
│   ├── C_Programming.txt
│   ├── hello.c
│   ├── calculator.c
│   ├── discount.c
│   ├── mario.c
│   ├── conditions.c
│   ├── loops.c
│   └── data_types.c
├── 📂 Lecture 2 - Arrays/
│   ├── Arrays.txt
│   ├── arrays_basic.c
│   ├── strings.c
│   ├── caesar.c
│   ├── readability.c
│   ├── substitution.c
│   ├── argv.c
│   └── scores.c
├── 📂 Lecture 3 - Algorithms/
│   ├── Algorithms.txt
│   ├── linear_search.c
│   ├── binary_search.c
│   ├── selection_sort.c
│   ├── bubble_sort.c
│   ├── merge_sort.c
│   ├── recursion.c
│   └── phonebook.c
├── 📂 Lecture 4 - Memory/
│   ├── Memory.txt
│   ├── addresses.c
│   ├── copy.c
│   ├── memory.c
│   ├── swap.c
│   ├── phonebook.c
│   ├── files.c
│   ├── linked_list.c
│   └── buffer_overflow.c
├── 📂 Lecture 5 - Data Structures/
│   ├── Data_Structures.txt
│   ├── linked_lists.c
│   ├── binary_tree.c
│   ├── hash_table.c
│   ├── trie.c
│   ├── stack.c
│   └── queue.c
├── 📂 Lecture 6 - Python/
│   ├── Python.txt
│   ├── hello.py
│   ├── calculator.py
│   ├── mario.py
│   ├── phonebook.py
│   ├── dna.py
│   ├── cash.py
│   ├── readability.py
│   ├── data_structures.py
│   ├── file_io.py
│   └── face_recognition.py
├── 📂 Lecture 7 - Artificial Intelligence/
│   ├── Artificial_Intelligence.txt
│   ├── decision_tree.py
│   ├── minimax_tictactoe.py
│   ├── simple_chatbot.py
│   └── prompt_engineering.py
├── 📂 Lecture 8 - SQL/
│   ├── SQL.txt
│   ├── create_database.sql
│   ├── queries.sql
│   ├── python_sql.py
│   ├── race_conditions.py
│   └── csv_to_sql.py
├── 📂 Lecture 9 - HTML, CSS, JavaScript/
│   ├── Web_Development.txt
│   ├── bingo.html
│   ├── homepage.html
│   ├── form_validation.html
│   ├── autocomplete.html
│   ├── geolocation.html
│   ├── 📂 css/
│   │   ├── bingo.css
│   │   ├── homepage.css
│   │   ├── form_validation.css
│   │   ├── autocomplete.css
│   │   └── geolocation.css
│   └── 📂 js/
│       ├── bingo.js
│       ├── homepage.js
│       ├── form_validation.js
│       ├── autocomplete.js
│       └── geolocation.js
├── 📂 Lecture 10 - Flask/
│   ├── forms_app/
│   │   ├── app.py
│   │   └── templates/
│   │       └── index.html
│   ├── frosh_ims_app/
│   │   ├── app.py
│   │   └── templates/
│   │       └── index.html
│   └── shows_app/
│       ├── app.py
│       └── templates/
│           └── index.html
└── README.md

🎓 Key Learning Outcomes

By the end of CS50, students will:

• ✅ Think computationally and solve problems methodically

• ✅ Understand computer science fundamentals that transcend programming languages

• ✅ Write correct, well-designed, and stylish code

• ✅ Debug effectively using proper techniques and tools

• ✅ Implement fundamental algorithms and data structures

• ✅ Manage memory and understand system-level programming

• ✅ Build web applications from front-end to back-end

• forms_app/ — A simple app showing how to handle HTML forms, process user input, and display responses. Great for learning about routing, request methods, and templates.

• frosh_ims_app/ — A registration system for intramural sports, demonstrating form validation, user feedback, and storing submitted data. This mirrors the classic CS50 “Frosh IMs” example.

• shows_app/ — An app that queries a SQLite database and displays TV show data using templates. Illustrates database integration and dynamic content rendering.

Each app is self-contained with its own app.py and templates/ folder. To run an app, navigate to its directory and execute:

python app.py

You can then visit the app in your browser at http://127.0.0.1:5000/.

🏆 Problem Sets & Projects

Each week includes hands-on problem sets that reinforce the concepts:

• 🎮 Scratch Project - Interactive game or animation
• 🔢 Mario Pyramids - ASCII art with nested loops
• 🔐 Caesar/Substitution Ciphers - Cryptography fundamentals
• 📊 Readability - Text analysis algorithms
• 🗳️ Plurality/Runoff - Election simulation systems
• 💾 Filter - Image processing and manipulation
• 🔍 Speller - Hash tables and spell checking
• 🧠 Memory Recovery - Digital forensics and file systems
• 📞 Dynamic Phonebook - Memory management and data structures
• 🌳 Family Trees - Binary search trees and genealogy
• 📚 Dictionary - Trie implementation for fast word lookup
• 🧬 DNA Analysis - String processing and pattern matching
• 🎭 Face Recognition - Computer vision and image processing
• 💰 Cash/Credit - Greedy algorithms and validation
• 🎯 Tic-Tac-Toe AI - Minimax algorithm implementation
• 🤖 Chatbot - Natural language processing basics
• 🗄️ Movies Database - SQL queries and database design
• 🏠 Fiftyville Mystery - SQL detective work with complex queries
• 🌐 Homepage Portfolio - Building a personal website with HTML, CSS, and JS
• ✅ Form Validation Demo - Client-side validation using JavaScript and Regex
• 📍 Geolocation App - Using browser APIs to get user location

💻 How to Use This Repository

1. Clone the repository:

   git clone <repository-url>
   cd CS50

2. Compile C programs:

   clang -o program program.c -lcs50
   ./program

3. Run Python programs:

   python program.py

4. Execute SQL scripts:

   sqlite3 database.db < script.sql

5. Open HTML files:

   # Simply open in your web browser (e.g., double-click the file).
   # All CSS and JS are linked externally for best practice.

6. Install Python dependencies (for advanced programs):

   pip install cs50 pillow face-recognition sqlite3

7. Follow along with lectures using the organized notes and code examples

🌟 David's Inspirational Quotes

"The best way to learn to program is to program."

"Programming is not about what you know; it's about what you can figure out."

"Don't be afraid to break things. That's how you learn."

"In programming, there's often more than one way to solve a problem. Focus on correctness first, then optimize."

"AI is a tool to augment human intelligence, not replace human judgment."

"Understanding what's underneath the hood applies to AI too - know how these systems work."

"Databases are just fancy filing cabinets - but the organization makes all the difference."

"SQL injection is like leaving your front door wide open - always sanitize your inputs!"

"The web is just computers talking to each other. HTML provides the nouns, CSS the adjectives, and JavaScript the verbs."

🤝 Contributing

Feel free to:

• 📝 Suggest improvements to notes
• 🐛 Report errors or typos
• 💡 Share alternative implementations
• 🎯 Add more practice problems

📞 Connect & Collaborate

• 💬 Discuss CS50 concepts and problems
• 🤔 Ask questions about implementations
• 🎯 Share learning experiences
• 🌟 Celebrate coding victories!

---

🎪 "This is CS50!"

Building tomorrow's problem solvers, one algorithm at a time.

Happy Coding! 🚀✨

---

This repository is a tribute to CS50's incredible teaching methodology and David Malan's inspiring approach to computer science education. Understanding what's underneath the hood has never been more engaging!