Posts

Week 29: CST 334 - Operating Systems

  WK05: Weekly Learning Reflection This week we covered four main topics: Concurrency, Thread API, Locks, and Lock-based Data Structures. Concurrency introduced the idea that multiple tasks can overlap in time, even if only one runs at a time on a single CPU. I learned how unpredictable a program can become when threads share data without proper control, and how race conditions appear when two threads access the same data at the same time. The Thread API section helped me understand how threads are created, joined, and managed in code. I liked seeing how these functions make it possible for a single process to do many things at once, as long as we handle synchronization carefully. Locks were one of the most interesting topics. A lock prevents multiple threads from entering the same critical section at the same time, which helps avoid corrupted data. However, it also made me realize that using locks correctly is not always simple. We must think about fairness, performance, and what ...
Post a Comment
Read more

Week 28: CST 334 - Operating Systems

WK04: Weekly Learning Reflection This week's material covered four major topics in memory management: Free Space Management, Translation Lookaside Buffers (TLBs), Multi-level Paging, and Swapping. Each of these concepts plays an important role in how operating systems efficiently manage memory, and together they form a larger picture of how virtual memory systems function. Free Space Management was the most straightforward topic for me. The core ideas- how memory allocators track free blocks, split them, merge them, and choose which space to reuse- felt familiar and intuitive. Concepts like first-fit, best-fit, and worst-fit echo topics from previous programming courses and even some of the work I've done in C. TLBs also made sense because they resemble other caches in computer architecture. It helps to think of a TLB as a small, specialized 'shortcut' the CPU uses to speed up address translation. Because I already understood how caches work, this topic did not feel ove...
Post a Comment
Read more

Week 27: CST 334 - Operating Systems

WK03:  Weekly Learning Reflection This week we covered several chapters from OSTEP: Address Spaces, the C Memory API, Address Translation with Base-and-Bounds, Segmentation, and Paging. All of these topics focused on how operating systems virtualize memory and how the hardware supports that process. Address spaces made a lot of sense to me. The idea that each process gets its own 'private' view of memory, even though they all share the same physical RAM, was clear and understandable. I especially liked how the book explained time-sharing and virtualization - how the OS switches between processes so quickly that it feels like they are running at the same time. The C Memory API was also straightforward. We reviewed malloc, calloc, and the importance of free. I feel comfortable with the basics, especially how these functions interact with the heap. The main takeaway is simple: when you allocate memory, you must remember to free it. Address translation and the MMU concepts also mad...
Post a Comment
Read more

Week 26: CST 334 - Operating Systems

WK02: Processes, Scheduling, and CPU Management This week's topics deepened my understanding of how operating systems handle processes and CPU scheduling. We covered OSTEP chapters 4–8, focusing on Processes, the C Process API, Limited Direct Execution, CPU Scheduling, and Multilevel Feedback Queues (MLFQ). Starting with Processes, I learned that a process is more than just a running program - it's an isolated execution environment with its own address space, registers, and program counter. This made me appreciate how the OS provides both protection and controlled sharing among processes. The C Process API helped bridge theory and practice by introducing system calls like fork(), exec(), and wait(). These calls illustrate how new processes are created and managed. Seeing how fork() duplicates the current process and exec() replaces it with a new program clarified how shells and multitasking work under the hood. The idea of Limited Direct Execution was harder to grasp at first. ...
Post a Comment
Read more

Week 25: CST 334 - Operating Systems

WK01: First Week of Operating Systems This week introduced several foundational topics in operating systems and computer architecture. The main topics covered were: installation of Docker, introduction to operating systems, computer architecture review, Linux and the shell, programming in C, command line introduction, and a math addendum about binary and hexadecimal conversions. Starting with Introduction to Operating Systems, I learned what an OS is and how it manages hardware and software resources, providing a bridge between users and machines. This topic was fairly easy to grasp because it dealt with general concepts and functions like process management and memory control. The Computer Architecture Review helped connect how components like the CPU, buses, and memory hierarchy work together. Although interesting, it required memorization - especially understanding RAM layout and how data flows between components. The Linux and the Shell section felt intuitive and enjoyable, esp...
Post a Comment
Read more

Week 24: CST 363 - Introduction to Database Systems

WK08: Final Reflections on Databases With both group projects finished and my final exam turned in, it's a good moment to pause and reflect. This journal captures the three most important lessons I'm taking from the course. Course outcome In this course I learned to design reliable databases by translating messy real-world rules into normalized schemas with clear keys, foreign keys, and constraints. I strengthened my SQL by writing efficient JOINs and aggregations and by using execution plans and indexing to turn slow queries into fast, scalable ones. Finally, I learned how ACID transactions and isolation levels protect correctness under concurrency and failures, and when to use compensating transactions. Together, these skills - good modeling, performance-aware querying, and transactional thinking - give me the confidence to build data features that are both accurate and efficient.
Post a Comment
Read more

Week 23: CST 363 - Introduction to Database Systems

WK07: Document Databases in Practice This week we shifted gears to a completely different kind of database: document-oriented storage. We spent a lot of time hands-on with the most popular example - MongoDB. I'll be honest: I was nervous at first. It's brand-new for me and we had two labs to complete. I wasn't sure I'd have enough time. But it turned out simpler than I expected. Our group project that used Java to write to MongoDB felt lighter than the SQL version - no hand-writing SQL statements, no fiddly parameter assignments; you build a Java object/document and persist it. That mental model made CRUD feel very straightforward. MongoDB vs. MySQL MongoDB and MySQL have a lot in common: both let you create, read, update, and delete data; both use indexes (including unique ones) to speed things up; both have solid drivers and tools. The big difference is how they model data and how that feels in code. MySQL is relational: tables with fixed schemas, foreign keys, and jo...
Post a Comment
Read more