My CS Online Journey

This week focused on the core mechanics of algorithm design, specifically the differences between Divide and Conquer and Decrease and Conquer. One of the most important takeaways for me was breaking down QuickSort. While I knew it was a popular sorting method, I didn't fully appreciate how much the "pivot" choice matters. The fact that it's an in-place algorithm is a huge advantage over Merge Sort because it doesn't require extra memory, but the trade-off is that a bad pivot choice can tank the performance from a fast O(n log n) down to a slow O(n^2). Seeing the partitioning process step by step made it much easier to understand how the elements are actually swapped around the pivot to get them into the right spots. I also spent time looking at Binary Tree Traversals. It was helpful to see how Pre-order, In-order, and Post-order aren't just different ways to list nodes, but tools for different problems. For example, I realized that Post-order traversal is the ...

This week I was learning and reading about the foundational concepts of algorithmic design, specifically Brute Force methodologies. I explored how these approaches, while conceptually straightforward, provide a comprehensive way to solve optimization problems by evaluating every possible solution. I also went through the examples like the Traveling Salesman Problem (TSP) and the Knapsack problem.  The homework (HW3) was a great way to put this into practice. For the DFS part, I had to be careful with sorting the adjacency list to make sure the stack processed neighbors in the correct numerical order. It was a good reminder that the data structure details really matter. Then for the TSP program, generating all those permutations to find the cheapest path really proved the point about how computationally expensive exhaustive search is. It was satisfying to finally get the correct path costs after reviewing the logic for a bit. I also looked into the theory side of Graph Traversal and...

This week covered asymptotic notations and algorithm analysis, which felt math-heavy at first but started making sense once I applied it to my homework. The textbook reading explained the three main notations: Big-O for worst-case upper bounds, Big-Omega for best-case lower bounds, and Big-Theta for when both are the same. I found the Theta notation video helpful because it showed concrete examples of when to use each one. The best part of this week was seeing how analysis applies to real code through both homework problems. HW2_1 (Closest Pair Problem): I needed to find the minimum distance between any two numbers in an array. The brute force approach would compare every pair, which takes quadratic time. Instead, I sorted the array first and then scanned consecutive elements. This is much faster because sorting takes n log n time and scanning takes linear time. After sorting, the minimum distance must be between adjacent elements, so I only needed one pass through the array. HW2_2 ...

This first week was a solid refresher. I started by watching the video on Euclid's algorithm for GCD. It was insightful to compare it against the basic consecutive integer checking method because it proved that brute force is not always the best answer. Sometimes a simple mathematical insight saves more time than a faster computer ever could. I also worked on Homework 1 this week. The assignment asked us to check for palindromes while ignoring symbols and case. I chose to create a new filtered string with only alphanumeric characters first. It was a good exercise, but it made me think back to the Algorithm Analysis Framework videos. Since I created a new string, I effectively used extra memory space. This connects directly to the space and time tradeoffs mentioned in the syllabus. I also spent some time reviewing the Graph representations and Trees videos. I realized I need to be careful about choosing between adjacency matrices and lists depending on whether the graph is weighted ...

This class has provided a clear view of the transition from writing code to engineering systems. Below are the five most important things I learned in the course and the reasons why I believe they are vital for my development as a software engineer. 1. The Difference Between Programming and Engineering I used to think these terms were interchangeable, but I now understand that software engineering is "programming integrated over time". Programming is about the immediate task of solving a problem, whereas engineering is about making sure that solution can survive changes in teams, technology, and requirements over several years. This shift in perspective is important because it changes how I prioritize code quality and documentation. 2. The Power of the Testing Pyramid Before this class, I viewed testing as a final check rather than a continuous process. Learning about the "Testing Pyramid" taught me to build a foundation of many small, fast unit tests rather than re...

This week’s module was a distinct shift from the Agile methodologies we have been focusing on for most of the course. It was interesting to dive into the "Plan and Document" process, often called Waterfall, and see how it contrasts with the iterative approach we are used to. The most obvious difference is the structure itself. The lecture described this process as a series of phases- requirements, design, implementation, and verification, that flow downward like water. In our Agile labs, we are used to doing a little bit of design, coding, and testing all at the same time within a sprint. However, with the Plan and Document approach, there is a strict rule that you generally need to finish the current phase and produce a specific document, like the System Design Document, before you can move on to the next stage . One of the biggest takeaways for me was understanding why someone would choose this rigid structure over Agile. I used to think Waterfall was just "old fashion...