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 ...

 This week in CST370 focused on foundational algorithm design strategies and search techniques. We started with brute force string matching and exhaustive search , which involve checking all possible matches or solutions to find a correct answer. Although these approaches are often inefficient, they are simple to understand and serve as a good starting point for problem solving. We then learned about the depth-first search (DFS) algorithm , which explores a structure by going as deep as possible before backtracking. DFS is useful for tasks like path finding and exploring all possible configurations, especially when memory usage needs to be minimized. Next, we studied the breadth-first search (BFS) algorithm , which explores all nodes at one level before moving deeper. BFS is especially effective for finding the shortest path in unweighted graphs, though it typically requires more memory than DFS. Finally, we were introduced to divide and conquer algorithm design , a strategy tha...

       This week in CST370 we focused on understanding how to analyze and reason about algorithm efficiency. We began with asymptotic notations , which provide a way to describe an algorithm’s performance as input size grows. Notations like Big-O help us focus on long-term behavior rather than exact runtimes, making it easier to compare algorithms. We then explored the analysis of nonrecursive algorithms , where we evaluate loops and statements to determine time complexity. This reinforced how simple code structures can still have significant performance impacts depending on how often operations are repeated. Next, we studied the analysis of recursive algorithms , which introduced recurrence relations. Learning how to break a problem into smaller subproblems and analyze how recursive calls contribute to overall complexity helped clarify how recursion affects performance. Finally, we covered brute force algorithm design , which emphasizes solving problems by exhaustiv...

      This journal entry marks the first week completion of my CST370 class. I'm going to be honest, this looks like it will be a tough one. This week we covered a variety of topics in the lectures ranging from and introduction to algorithms, some pseudocode examples, important problem types (sorting and searching, graphs), fundamental data structures, algorithm analysis frameworks, and some puzzle problems. It was a lot to cover in a week one but I believe that it was all necessary for us to learn/review ASAP. I really liked learning about the weighted coin puzzle. It was a basic puzzle but it teaches you how you can narrow down a fake among a group of things, that logic can be applied to many different scenarios.       After learning about the coin puzzle I immediately thought of a similar puzzle with light bulbs and switches where you trying and find out which switch turns on the light in another room(3 switches 1 light bulb). Where you try to find ...

 This was the final week for CST334. I just finished my final exam a little while ago and I can't tell you how happy I was that the time we were given to finish the final was two hours rather than one. My midterm suffered because I could not finish my exam in time, I had to "YOLO" a few questions for partial credit and ended up misreading two questions and putting answers not even related to those questions haha.  CST334 has been an amazing class. My biggest takeaways from CST334 had to of been Address Spaces, Files and Directories, and File Systems(Access and Data). These were honestly some of the things that were easier for me to understand so I feel like I learned the most from these topics. I think the biggest challenge for me in this class was learning to convert hex to decimal and vice versa. I know that seems ridiculous but only at the very end of the class did I get the hang of it and realize how simple it was. Another challenge for me was trying to remember all o...

  This week in CST334 our lectures covered: IO Devices, Hard Drives, Files and Directories, File Systems(Data), and File Systems(Access). In this learning journal I'll write and explanation/what I think to be the most important bits of each subject.  1. I/O Devices I/O (Input/Output) devices are hardware that allow a computer to communicate with the outside world — keyboards, displays, printers, network cards, sensors, etc. They operate via controllers that communicate with the CPU and memory. Key Takeaways: Two main types: block devices (e.g., disks) and character devices (e.g., keyboards). Managed through device drivers . Performance depends on throughput (data per second) and latency (time per operation). Communication methods: polling , interrupts , DMA (Direct Memory Access). 2. Hard Drives Hard Disk Drives (HDDs) store data magnetically on spinning platters. Data is read/written by a moving read/write head. Key Takeaways: Performance factors...

 This week in CST334 our lectures covered: Bounded Buffer Coding, Semaphores, Synchronization Barriers. In this learning journal I'll write and explanation/what I think to be the most important bits of each subject.  Bounded Buffer Coding (Producer-Consumer Problem) A bounded buffer is a fixed-size storage used in the classic Producer-Consumer problem. Producers add items to the buffer, and consumers remove them. Coordination is required to avoid overfilling or emptying the buffer. Key Takeaways: Solves coordination between multiple producers and consumers. Needs synchronization to prevent buffer overflows (producer) and underflows (consumer). Typically implemented using mutexes (for mutual exclusion) and semaphores (to count available slots/items). Ensures safe access to shared resources in concurrent environments. Semaphores A semaphore is a synchronization primitive used to control access to a shared resource. It uses a counter and two atomic operatio...

    This week in CST334 our lectures covered: Concurrency and Threads, Threads API, Locks, and Lock-based data structure. In this learning journal I'll write and explanation/what I think to be the most important bits of each subject. We also had our midterm this week and I didn't do as good as I wanted to, I definitely need to focus some more on my studies. Concurrency and Threads Concurrency is the ability of a system to handle multiple tasks at the same time. Threads are the smallest units of execution within a process. Concurrency allows threads to run independently, improving efficiency, especially on multi-core processors. Key Takeaways: Concurrency enables better CPU utilization. Threads share the same memory space within a process. Context switching allows threads to appear to run in parallel. Can lead to race conditions if not properly synchronized. Threads API Threads APIs provide the functions and mechanisms to create, manage, and synchronize threads....

   This week in CST334 our lectures covered: Paging, Translation Lookaside Buffers, Multi-Level Paging, and Swapping. In this learning journal I'll write and explanation/what I think to be the most important bits of each subject. Paging Paging is a memory management scheme that eliminates the need for contiguous memory allocation. It divides physical memory into fixed-size blocks called frames and logical memory (processes) into blocks of the same size called pages . Key Takeaways : Avoids external fragmentation. Simplifies memory allocation. Requires a page table to map virtual pages to physical frames. Introduces a level of indirection, so address translation is needed. Translation Lookaside Buffers (TLBs) A TLB is a small, fast, cache used to store recent translations of virtual addresses to physical addresses. Since page table lookups can be slow, the TLB helps speed up the translation process. Key Takeaways : TLB reduces memory access time by caching...

  This week in CST334 our lectures covered: Address Spaces, C Memory API, Address Translation & Base-and-bounds, Segmentation, Free Space Management. We also started working on our first group project this week. In this learning journal I'll write and explanation/what I think to be the most important bits of each subject. 1. Address Spaces An address space is the range of memory addresses that a process can use. Each process has its own virtual address space, isolated from others, managed by the operating system. Key Takeaways: Provides process isolation . Helps with security and stability . Enables virtual memory and memory protection. 2. C Memory API The C memory API includes functions for dynamic memory allocation and deallocation: malloc() , calloc() , realloc() , and free() . Key Takeaways: malloc(size) allocates a block of memory. calloc(n, size) allocates and zero-initializes memory. realloc(ptr, new_size) resizes previously allocated memory. ...

    This week in CST334 our lectures covered: Processes, C Process API, Limited Direct Execution, CPU Scheduling, and MLFQ. In this learning journal I'll write and explanation/what I think to be the most important bits of each subject. Processes A process is a running instance of a program. It includes: Code (instructions) Data (variables, heap) Execution context (registers, stack, program counter) Operating systems manage processes to provide isolation, resource control, and scheduling. C Process API The C Process API refers to system calls and library functions in C for process management. Key functions include: fork() – Creates a new process by duplicating the current one. exec() – Replaces the current process image with a new one. wait() – Waits for a child process to finish. exit() – Terminates the current process. Limited Direct Execution (LDE) Limited Direct Execution is a technique where the OS allows a user program to run directly ...

 This week in CST334 was loaded with information. Some of it review, some of it learning material. The things we covered in class this week include: An intro to the OS, Computer Architecture Review, Linux and the Shell, Programming in C, Command Line Introduction, and a Math Addendum. Half of this was review to me, and the other half was learning material. I'm not too familiar with the command line and Linux so that was a learning experience with me. I enjoyed basically being able to code in C for our assignments and run the tests on the command line. It was a smooth introduction for what is capable with the command line. Also the Math Addendum was a good refresher. I learned about hex and binary a bit in a previous class but never understood it 100%, only enough to answer some basic questions. I know I'll need to study that a bit more because I feel like it's pretty important to be able to read hex/binary. Another new topic or rather a learning experience was the Computer ...

 This journal entry marks the final days of CST363. What an amazing class. I really enjoyed working with MySQL Workbench. Mongo was a bit odd, but I liked the challenge of learning to use new software/get better with the command line. Our final prompt is to list 3 of the most important things we learned in this class. The three things I'll list are going to be Database design, Transaction & Concurrency, and JDBC & Spring Boot.  I'll list the key learning takeaways for these as well as some useful information. 1. Database Design Key Learning Takeaways: Data Modeling: Understand entities , attributes , and relationships . Learn how to design ER diagrams to visualize database schemas. Normalization: Apply 1NF, 2NF, 3NF (and BCNF) to reduce redundancy and improve integrity. Understand denormalization trade-offs for performance. Schema Design: Create well-structured primary and foreign keys . Define constraints (NOT NULL, UNIQUE, CHECK) f...

 This week we installed and used MongoDB. It was super new to me and I haven't really used the command prompt very much so when I was running into errors while trying to load my JavaScript file I got a bit irritated. I got it working eventually after realizing I had to move my file to a different directory and type out the full path when trying to load it. That solved all my issues. I followed the same steps when loading the other two files provided for the lab and it went smoothly. Here are some things I noticed when comparing Mongo DB with MySQL. Similarities Database Management : Both are database management systems used to store, retrieve, and manage data. Cross-Platform : Both are cross-platform and run on Linux, Windows, and macOS. Indexing : Both support indexing for faster queries. Replication : Both support data replication for high availability. Security : Both offer authentication, authorization, and encryption features. Community and Support : Each has...

 This week I learned quite a bit about JDBC, Connectors, and what it takes to work on some Web Applications.  *JDBC is the standard Java API for connecting and executing SQL queries with relational databases. Key Concepts: DriverManager / DataSource : Manages DB connections. Connection : Represents a connection session. PreparedStatement : Safely sends parameterized SQL (prevents SQL injection). ResultSet : Retrieves query results. Some key takeaways: Use PreparedStatement for safe, efficient, and secure database queries. Always close connections (or use try-with-resources). Avoid hardcoding SQL logic — parameterize everything. Use jdbcTemplate.getDataSource().getConnection() in Spring Boot for quick integration. *Spring Boot simplifies JDBC usage by handling connection setup and dependency injection through JdbcTemplate . Key Concepts: @Autowired JdbcTemplate gives access to your DB. Spring Boot reads config from application. Properties...