CSUMB Learning Journal 2025

This was the first week of CST383 and we focused on building a strong foundation in Python for data science, especially working with NumPy and basic scripting tools. I practiced creating and manipulating arrays, including slicing, fancy indexing, and boolean masking. I also learned how vectorized operations allow computations to be performed efficiently across entire arrays without using loops. Working with both 1D and 2D arrays helped me better understand how to access specific rows and columns, as well as how to compute statistics like mean and median along different axes. In addition, I explored filtering data using conditions and using those filters to extract subsets of interest. One concept that I found a bit confusing at first was how boolean masks need to match the shape of the array they are indexing. For example, trying to index an array with a mask of a different length results in an error, which made me realize how important array dimensions are in NumPy. This made me ask: ...

     One thing that went well during our service-learning project was our ability to build meaningful full-stack functionality that contributed to a real application rather than just completing isolated assignments. As a team, we developed useful features such as availability scheduling, time entry reporting, and backend APIs to support booking functionality. Collaboration improved over time as we became more comfortable using Git, resolving merge conflicts, and coordinating contributions through pull requests. A major success was moving portions of the project away from hardcoded or mock data toward real frontend-backend integration. We also made significant progress through debugging, identifying issues involving authentication, CORS, and data persistence that led to real improvements in the application.      One area I would improve is communication and coordination earlier in the development process. There were times when better communication about bran...

 This week in CST370 introduced several advanced algorithm techniques for optimization and graph problems. We began with non-comparison sorting , such as counting sort or radix sort, which sort data without directly comparing elements. These algorithms can achieve linear time under certain conditions, making them faster than traditional comparison-based sorts. We then studied dynamic programming , a method that solves complex problems by breaking them into overlapping subproblems and storing solutions to avoid repeated work. This approach is powerful for optimization problems like shortest paths or resource allocation. Next, we covered Warshall’s algorithm , which computes the transitive closure of a graph. It determines which vertices are reachable from others, helping analyze connectivity. Related to this, Floyd’s algorithm finds the shortest paths between all pairs of vertices in a weighted graph, improving efficiency compared to running single-source algorithms repeatedly. ...

 This week in CST370, we focused on advanced data structures designed to improve efficiency. We started with AVL Trees , which are self-balancing binary search trees. I learned how rotations help maintain balance after insertions and deletions, ensuring operations like search, insert, and delete stay at  O ( log ⁡ n ) O(\log n) O ( log n ) . Next, we studied 2-3 Trees , another balanced search tree structure. Unlike binary trees, nodes can store one or two keys, which helps keep the tree perfectly balanced. This guarantees efficient operations and deepened my understanding of how balancing improves performance. We then covered Heaps and Heapsort . A heap is a complete binary tree that satisfies the heap property (max-heap or min-heap). I learned how heaps are useful for priority queues and how Heapsort uses the heap structure to sort elements in O ( n log ⁡ n ) O(n \log n) O ( n log n ) time without needing extra space like merge sort. Finally, we explored Hashing , which ...

 This week in CST370, we explored several new algorithm design techniques and data structure concepts. We started with quick sort , a divide and conquer sorting algorithm that selects a pivot and partitions elements into smaller and larger groups. I learned how its average time complexity of  O ( n log ⁡ n ) O(n \log n) O ( n log n ) makes it very efficient in practice, even though poor pivot choices can slow it down. We also studied binary tree traversal and height . Traversals like preorder, inorder, and postorder help process tree nodes in different orders depending on the problem. Understanding tree height showed how it affects performance, since deeper trees can increase search and traversal time. Next, we discussed decrease and conquer , which solves problems by reducing them into smaller instances of the same problem. This strategy feels more incremental than divide and conquer and is useful for algorithms like insertion sort or binary search. Finally, we learned ab...

 This week in CST370, we focused on merge sort and completed our midterm, which reviewed many of the algorithm concepts we’ve covered so far. Learning merge sort helped me better understand the divide and conquer strategy. The algorithm works by splitting a list into smaller halves, recursively sorting each half, and then merging them back together in order. I found it interesting how breaking a problem into smaller pieces can lead to a much more efficient solution, with a time complexity of  O ( n log ⁡ n ) O(n \log n) O ( n log n ) , compared to simpler sorting methods. We also took the midterm, which tested topics like asymptotic notation, brute force methods, recursion, and graph search algorithms such as BFS and DFS. Reviewing these concepts helped reinforce how different techniques are suited for different problems and how important it is to analyze efficiency before choosing an approach. Overall, this week strengthened my understanding of sorting algorithms and gave ...