Table of contents
Open Table of contents
What is CS50?
Disclaimer: I’m writing this based on my experience with CS50 in 2021. Some aspects of the course might have changed since then, and the structure may differ slightly now. The goal of this blog is to reflect on my journey through CS50 and to express my gratitude to the CS50 team once again.
CS50 is an introductory course to computer science offered by Harvard University. But don’t let the “introductory” label fool you—this is one course that even experienced software developers might find challenging. While some might call it easy just to flex, the reality is that CS50 is not a walk in the park. However, it’s the perfect course to set you on the right path in every way. The course is led by Professor David Malan (more on him later) and is completely free. The lectures are updated annually with minor improvements and better quality, and the course attracts thousands of students worldwide.
CS50 spans 10 weeks, starting with Scratch, a visual programming language. If you’re laughing at that, try it out—I’ll wait to hear back when you’re crying over solving Tideman! Scratch might seem simple, but don’t underestimate it. The course quickly ramps up to C, and the difficulty escalates fast. From there, it moves on to SQL and ends with some web programming, culminating in a final project.
Each week includes quizzes and problem sets that you must complete to receive a grade. You can work at your own pace, which is where the real learning happens. Some problem sets are easy, while others—like Tideman—can be extremely tough. Some may take just a few minutes, while others might take days. Some weeks even offer an advanced problem set, which, as the name suggests, is really difficult.
More details on my journey through CS50 to come later.
Want to know more about CS50? Check out the official website.
My CS50 journey
Background
I don’t exactly remember how I stumbled upon CS50, but it was around the end of my first semester in college, sometime in May 2020. With the pandemic in full swing, both my college and CS50 were online. At the time, I had a lot of passion for computer science but very little knowledge. Though I had some minor programming experience from a CS course during my higher secondary classes, honestly, I learned almost nothing from it. Half the blame goes to me, and the other half to the engineering entrance grind. Those days, it felt like there was barely any time to focus on anything other than Physics, Chemistry, and Math (seriously, it’s a cursed and unhealthy system—but that’s a rant for another blog post).
Anyway, with life feeling pretty monotonous, I decided to give CS50 a shot. I was already watching Linear Algebra lectures by Gilbert Strang for my linear algebra paper on the subject, trying to connect the dots between linear algebra, machine learning, and deep learning. That enthusiasm was short-lived once I realized the reality of college classes (let’s just say my expectations were way too high—definitely another college rant for later).
But the programming itch was still there. Around the same time, I got a new laptop, and since I had heard good things about CS50, I thought, why not? I had seen a few previews, and of course, it’s Harvard. How could it not be good?
For anyone interested in knowing how CS50 looked like in 2021, you can check out the 2021 version. Glad that they maintain versioned courses, so you can always go back and see how it was in a particular year.
Week 1 : C
I skipped the Week 0 labs and problem sets at first, opting to just watch the lectures because it was mostly Scratch, and I figured I could circle back to it later. What really drew me in was the C programming section, so I jumped straight to Week 1.
Week 1 was an introduction to C. It covered the basics like conditionals, loops, and I/O in C. But it wasn’t just surface-level; the explanations went into a depth I hadn’t expected. That’s what makes CS50 so impressive—it’s incredibly well-structured, and every minute feels valuable.
At that time, they were using their own cloud environment, CS50 IDE (I think now they’ve switched to GitHub Codespaces). It was my first real experience with an online IDE, and it worked smoothly. They even introduce basic shell commands in Week 1, which many other courses tend to skip over.
The Week 1 problems weren’t too hard. My programming logic was rusty, but after a few hours of trial and error, I got everything working and passed all the test cases. It felt great, and I was determined to complete the course no matter what.
Week 2 : Arrays
Week 2 was all about arrays, strings, and command-line arguments in C. But beyond that, it taught me how to think like a programmer and how to debug effectively. It’s funny now, but a lot of the things I do automatically today—like debugging through muscle memory—were first introduced to me by CS50. I remember using printf for debugging for the first time. It felt like magic. I was thinking, “How did I not know this before?” These little things, which we often take for granted now, were introduced in such a well-structured way that they just clicked.
And let’s not forget—CS50 has its own C library for I/O and string manipulation. How cool is that?
The Week 2 problem sets were about implementing a Caesar cipher if I remember correctly. I spent quite a bit of time on it, but I got through it, and that sense of accomplishment was real. I was learning, and it felt great.
Week 3 : Algorithms
Week 3 was when algorithms entered the picture. This was where I first learned about Big O notation and how to analyze the efficiency of algorithms. The course covered standard sorting and searching algorithms and introduced recursion. Learning to think recursively was a big shift in how I approached problems.
But, man, the problem sets this week were tough. I’m not exaggerating when I say they were hard. I encourage you to try them yourself (here’s the link).
CS50 also has an amazing Discord server, where you can ask questions and get help from the community. I found myself asking a lot of questions there and getting guidance from others who were in the same boat. The community support made a big difference for me during this week.
The first problem set wasn’t too bad, and with some help, I managed to solve it. But then there was the infamous second problem set—Tideman. Everyone in the Discord server was talking about it, and I decided to give it a shot, unaware of what I was getting myself into.
Tideman was incredibly hard. At least, it was for me. I worked on it for days, sitting down with paper and pencil every afternoon after my boring online college lectures. College lectures would finish around 1 PM, and then it was CS50 time. I tried different approaches, sought hints from the Discord server, and was able to fill in parts of the functions. But the final piece of Tideman remained elusive. I spent so much time on it, and this was probably the first time I started experiencing imposter syndrome. Thoughts like, “Am I cut out for this? Can I even do this? Did I pick the wrong field?” started creeping in.
Eventually, I had to make a decision. Tideman was an optional, harder problem set, and I had already completed the required one for grading. So, I told myself I would come back to Tideman when I was more equipped with the knowledge and skills to tackle it.
Week 4: Memory & Week 5: Data Structures
Weeks 4 and 5 are, without a doubt, the best weeks of the course. I still get a dopamine rush just thinking about them. There’s honestly no way to describe the feeling in words—you just have to experience it for yourself.
Week 4 is where the real magic of programming under the hood begins. You dive into concepts like hexadecimal, pointers, the call stack, the heap, runtime behavior, file pointers, dynamic memory allocation, and static memory allocation. It’s a lot to take in, but the way CS50 structures and presents these topics is out of this world. If you love computer science, you’re going to love this week.
And the problem set for Week 4? It’s legendary. You write a program to recover deleted images from a memory card. Tell me that’s not the coolest thing ever. It’s hands down the coolest problem set I’ve done to this day. Man, I wish I could take this course all over again—it was so fun and challenging at the same time.
Week 5 dives deep into data structures. You get introduced to linked lists, stacks, queues, trees, tries, and hash tables. But you don’t just learn about them like you might in a typical college data structures course. CS50 makes you think—it makes you question why these data structures matter and how they affect the efficiency of your programs. Honestly, I feel for those who just memorize solutions from LeetCode and regurgitate them in interviews. This is the real deal, the true essence of computer science.
And the Week 5 problem set? You write your own hash function for a spell checker. No words can do justice to how rewarding that feels. It’s a challenge, but it’s so worth it.
Week 6: Python
This is where CS50 switches gears from the rigorous C programming to the elegance of Python. Python feels like a breath of fresh air after the intensity of C. The week covers the basics—data types, conditionals, loops, functions, and more. It’s a lighter week, almost a break compared to the earlier grind, and it’s an excellent way to introduce a high-level language. The problem sets here are relatively straightforward, mostly revisiting problems you solved in C, but they’re still enjoyable.
One thing this week makes clear: Python is incredibly easy to take for granted. I think that’s the real motivation behind starting with C in CS50. They could have started with Python or another high-level language, but the choice to start with C makes perfect sense once you’ve gone through it. The power and simplicity of Python really shine through after wrestling with the low-level concepts in C.
Week 7: SQL
Week 7 is all about databases, focusing specifically on SQLite. You learn how to create tables, insert data, and query information. The problem set here involves working with an IMDb database, and you have to write queries to extract meaningful insights from it. It’s a great introduction to working with databases, but don’t let the “introductory” label fool you—this week also covers indexing and B-trees, diving deeper into the mechanics of databases.
The highlight of this week is the next pset, FiftyVille, where you become a detective and write SQL queries to solve a mystery and catch the thief who stole the CS50 duck. Easily the best SQL exercise I’ve ever done—it’s both challenging and incredibly fun.
Weeks 8 and 9: Web Programming
The weeks following Week 7 are all about web programming and development, starting with the fundamentals like how the internet works, protocols like TCP/IP, HTTP, and the basics of HTML, CSS, and JavaScript. It gradually moves into backend programming with Python and Flask in Week 9.
Week 8 wasn’t too tough for me, as I had prior experience with HTML and CSS. However, Week 9 was a completely different story. Even after watching the lectures multiple times, I struggled to grasp how web backend programming worked. I think it was mainly due to how different web development is from the simpler scripts I had been used to. Previously, it was all about writing a main function and making function calls, but now everything was event-driven, a concept I didn’t even know existed at the time.
Looking back, I realize that this kind of confusion is common when transitioning to web development. You end up taking many things for granted initially, whether it’s event-driven programming, concurrency, how databases and applications interact, or how ORM works. Although I could have pushed through without fully understanding these concepts, I wanted to get a solid grasp before diving deeper—especially knowing that a project was waiting for me in Week 10. So, I decided to take a break from CS50 and figure out web programming on my own.
I started learning more about HTML, CSS, and JavaScript and built a few static websites along the way. Although I never really got into the design aspects, I was more interested in understanding how everything fit together. Somewhere during this period, I paused CS50 indefinitely. I was still coding, still honing my skills, but I felt like I wasn’t ready to come back to CS50 just yet.
Diving into Web Development
During my break from CS50, I found Angela Yu’s Udemy course on the MERN stack. It was incredibly useful and helped me build some small server-side projects. I spent a few months completing the course, and by the end, I felt more than ready to tackle CS50 again.
Unfortunately, by that time, I was already in my third semester of college, and offline classes had resumed. Between classes and other college commitments, I barely had time for anything else. I hated being stuck in college with little time to explore real CS stuff, but I knew I had to attend for the sake of attendance.
Returning to CS50 and Final Project
Despite my hectic schedule, I eventually found the time to complete Week 9 of CS50, and this time I aced it. In a way, I didn’t really need CS50 anymore—I had already built enough knowledge and skills to do projects beyond the scope of the course. But CS50 had been such a transformative experience for me that I felt a deep sense of loyalty to finish what I started. After all, it was CS50 that taught me how to love computer science in the first place.
After completing the academic portion of the course, it was time for Week 10’s final project. Given my time constraints (thanks, college!), I decided to repurpose a project I had recently completed and submitted it as my CS50 final project.
And just like that, within a week, I had my CS50 certificate. Looking back, I could have easily let the course fade away and moved on to other things. But my heart was still with CS50 and the incredible teaching team led by David Malan and Brian Yu. CS50 was where my passion for computer science truly started, and for that, I will always be grateful.
Reflections
Writing this blog is a chance to reflect on the early days of my programming journey. No, I’m not Linus Torvalds or Ryan Dahl—I can’t whip up a kernel in a day (yet!). But looking back three years later, in 2024, I can hardly believe the progress I’ve made. I’ve built a couple of projects that a few people actually use daily, and they’ve found them useful. This reflection serves to highlight the immense impact that the incredible course and community of CS50 have had on my life.
CS50 taught me how to think like a programmer. It showed me how to learn independently, debug effectively, and ask for help when I needed it. The foundational skills I gained—understanding algorithms, data structures, and even the intricacies of memory management—are what I apply in my daily coding practices. I remember the first time I used a debugger to step through my code, gaining insights into how variables change over time. It was a game changer.
If you’re aspiring to become a software developer or want to dive into programming, this is the course for you—literally. You might come from a completely different field, but like I did, you’ll find that background doesn’t matter. I had little programming experience before CS50, and my formal education didn’t equip me with much either.
But let’s be real: this course is hard, and it’s meant to be. There’s no shortcut in the world of software engineering. If you’re passionate about computer science, you’ll stick with it, no matter how tough it gets. Sure, it may take months of dedication and late-night coding sessions, but this course will mold you into a competent engineer.
Thank you, CS50. Thank you, David Malan—you are awesome.
return “This was CS50.”