CST 338 Week 1

Solving the CodingBat challenges required a structured approach: learning the problem first, breaking it down into logical steps, and finally coding up a solution based on Java's in-built functions. Planning was optimal, while blithely firing code at the problem created inefficiencies and unnecessary complexity. Using replaceAll() for list modifications and streams for non-destructive changes improved my solutions and made them more efficient. Edge conditions like empty lists or single-character strings sometimes led to unexpected crashes, requiring multiple attempts to sort out my code. Most issues required 1-2 attempts, but tough ones, like ensuring "xyz" wasn't followed by a period, required 4-5 attempts. This exercise as a whole reminded me of the importance of thinking ahead, using Java's functional programming features, and recognizing patterns in order to debug more efficiently.

Comments

Post a Comment

Popular posts from this blog

CST 334 Week 5

This week in CST 334, Virtual memory rules and the operating system's handling of page replacement under memory strain were the main topics of discussion. When physical memory is full and the OS has to choose which pages to remove to create room for others, I discovered how important these policies are. We focused on four main algorithms: Random, Optimal, FIFO (First-In-First-Out), and LRU (Least Recently Used). These policies are essential for maintaining system responsiveness and preventing excessive disk usage when multitasking with large processes. Because it depends on future information of memory access, the optimal replacement strategy, while ideal, cannot be applied in practical systems. Nonetheless, it provides a useful standard by which to compare actual policies. Because of Belady's Anomaly, which states that expanding memory might actually result in more page errors, I discovered that the FIFO technique was shockingly incorrect. By utilizing the idea of temporal l...
Read more

CST 334 Week 6

We studied semaphores and monitors this week in CST 334, two crucial synchronization primitives for concurrent programming. Particularly intriguing to me were semaphores, both conceptually and practically. Semaphores are shared integer variables that regulate thread-to-thread access to shared resources. The basic POSIX functions acquire () and release () (or wait () and signal() were covered, along with their applications in establishing thread coordination and mutual exclusion (mutex). I liked how the operating system makes sure these actions are atomic, removing busy waiting by stopping inactive processes. The notion became much more robust when semaphores were used to handle issues like the parent-child thread synchronization or the producer-consumer situation.The usage of locks and condition variables in the development of semaphores (such as the "Zemaphore") was also helpful to me in comprehending how lower-level processes contribute to higher-level synchronization tools...
Read more

CST 334 - Week 7 Journal Entry

This week,I learned understanding of how operating systems control file systems and storage devices, beginning with how the system communicates with input and output devices. I now recognize the crucial functions that interruptions and polling play in device communication. Polling may be time-consuming, particularly for slower devices, as it requires the CPU to continuously check if a device is available. In these situations, interrupts are more effective since they let the CPU focus on other tasks and only react when the device indicates that it is finished. I saw how Direct Memory Access (DMA) enables the device to manage data transport directly, lowering CPU involvement and enhancing system efficiency while transferring large volumes of data. Additionally, I discovered that memory-mapped I/O simplifies communication by enabling device registers to be accessed similarly to memory addresses. The structure and optimization of disk storage was another subject that caught my atte...
Read more