cst383 - week 2

    This week the focus was on working with data using the pandas library, and later an introduction to probability density functions. One of the main topics was pandas series and how flexible they are for working with and visualizing data. We covered indexing, vectorized operations, and how Series differ from standard numpy arrays. While both structures are similar, what stood out to me is how pandas series include labeled indices, which makes the data much easier to interpret and work with. Instead of just relying on positional indexing like arrays, being able to have meaningful labels allows for clearer data manipulation. This seems especially useful when working with large real world datasets where context is just as impotent as the values.

    Pandas dataframes and how they are used to organize data was also covered. This section felt pretty intuitive because it felt like working with tables in a database or spreadsheet. Along with that was an introduction to aggregation and grouping in pandas. Aggregation feels like a very powerful tool seeing how quickly you can summarize and analyze large datasets using it. Being able to group data by a category and then computing averages or totals inherently is an important ability. These tools did a great job of demonstrating how powerful pandas can be for turning raw data into meaningful information with very little work.

    Later we were introduced to probability density functions and culminative distribution functions and how to analyze them. While simple enough in theory, it took me some time to become familiar with reading the graphs in a way that I could extract meaning from the numbers. Particular, understanding how to accurately estimate percentages from the graph took some effort in how you have to carefully consider the area under the curve represents probability, and how that relates to different regions of the graph like peaks and tails. After practicing more problems, and getting more familiar with the concept of a continues variable, I started to feel more comfortable identifying these regions and interpreting what they represent. I still think I need more practice with this so that I can do it at a glance, but I feel more confident than I did at the start.

    Something I found very interesting this week was revisiting concepts like mean, median, and mode. While I was already very familiar with these, the problems we worked on made me think more deeply about when each measure should actually be used. In the past, I tended to treat the average/mean as the default choice without questioning it much. However, I now started to consider why the median can often be more useful, especially in situations where there are outliers or skewed data. Seeing how extreme values can pull the mean in one direction made it clearer why the median can sometimes give a more accurate representation of the “typical” value.

Comments

Post a Comment

Popular posts from this blog

CST334 Week 2

    This week has been a great introduction to how CPU process selection works in operating systems. We covered a range of scheduling algorithms, including FIFO (First In, First Out), LIFO (Last In, First Out), Shortest Job First (SJF), and Round Robin (RR). I learned how each algorithm has its own strategy for picking which process should run next, and how these choices affect system performance and metrics like response times.      I also learned to calculating those performance metrics such as response time, turnaround time, average arrival time, and average turnaround time. For Round Robin scheduling in particular, I learned how to calculate how long a process will stay in the system based on the time slice and the number of other processes in the queue. These exercises helped me understand the mechanics of how schedulers work and why the design choices made are so important.      One of the most interesting parts was comparing the pros and ...
Read more

CST334 Week 5

     This week I focused on concurrency and how it allows processes to run multiple threads in parallel, allowing tasks to be handled in the background while the main application continues. While I’ve previously worked with multithreading in Java, learning how the operating system manages concurrency gave me a better understanding of how multithreading works in the CPU. I learned that threads can share certain resources, such as virtual address space which makes communication between them efficient, but also introduces its own challenges.      One of the key concepts I learned was nondeterminism in multithreaded programs. Even if two threads call the same function, the order in which memory is accessed and modified can change which can lead to different outcomes every time the program runs. This unpredictability can cause bugs that are hard to reproduce and debug.      To address this, we use thread synchronization APIs like locks, or mutexes...
Read more

CST334 Week 6

       This week we continued concurrent programming and synchronization concepts and built on the ideas from last week. One of the first things I learned about was binder buffer coding, which was about how data can be shared and communicated between different parts of a system or between different threads. It's a used when dealing with message passing or structured data flow. Systems with modular or layered designs can make use of this to communicate with other parts of the system.    After  that, I learned about the concept of semaphores. Semaphores are a core component in concurrent programming as they act as signaling mechanisms used to control access to shared resources. The main idea of semaphores are integer variables protected by atomic operations like wait() and signal(). A semaphore can be used to limit the number of threads that access a resource such as a database connection pool or a bounded buffer to ensure that the variables remain safe ...
Read more