Paging & Segmentation

This is probably the easiest lesson among the ones taught to us by sir Justin. I find it interesting that it's alsmot just like doing matching type and fill in the blanks simultaneously. It's a fresh experience and probably something I'd rather do since it's very easy to answer. It's even to the point that Kenneth sorta gets how it works and isn't having as much a hard time as like the other lessons.

Memory Management MFT MVT

It was interesting to learn about memory management and I agree that Process Scheduling was needed to be learnt before this one. It's very similar to process scheduling and because we learned it first, this lesson was that much easier to understand and execute once the lesson was taught. Worst fit is still a big hassle to do though since it's like you're deliberately making things worse for yourself.

MVT without compaction is also hard to do but most of the time, worst fit is still more of a hassle to do for me. Given a choice, I'd rather do MVT without compaction over worst fit.

Process Scheduling Round Robin HRRN

The topic I'm talking about this time is what I think is the hardest algorithm for process scheduling and the most time-consuming algorithm which are Highest Response Ratio Next(HRRN) and Round Robin(RR)
I  say HRRN is the hardest and probably the most hassle algorithm to do because it's the only one where you actually have to compute something to determine what process executes. All the other algorithms doesn't require any calculation at all, Round Robin is the most time consuming because of all the ticks that you need to do and on top of that keeping track of the ready queue and the burst time of all the processes. It's especially much more time consuming when the time per tick in Round Robin is low. Making a careless mistake in Round Robin can change what should be a correct answer into a wrong one so sometimes it's best to be careful and keep proper track than regret it afterwards.

Process Scheduling First Come First Served & Shortest Job First

So, late posts and hopefully this and all the posts afterwards will still count towards my grade in OPESYS1 since I've obviously overshot the deadline for it but yeah, if not, I'll just post it anyway.

One of the topics we discussed in OPESYS1 this term is process scheduling following different algorithms. First algorithms we discussed and were taught were First Come First Served(FCFS) which, you can garner from its name is pretty straightforward, and Shortest Job First. Shortest Job First(SJF) is actually pretty interesting if you think about it and it's further divided into non-preemptive and preemptive. I say SJF is pretty interesting in that it's actually impossible to implement realistically since as was told multiple times to us by sir Justin, it's a theoretical algorithm and is impossible to happen from a realistic point-of-view since you wouldn't know how long you plan to use a specific process from the start. From what I observed from my classmates and my group-mates, the preemptive version of the SJF is one of the harder algorithms to get the gist of and understand. I think the name is pretty self explanatory though and that sir Justin did a good job of explaining and teaching it. I guess it's just that each person has different learning curves for different things.

If I recall correctly, Davvid was absent for the SJF preemptive lesson so when group-work came, aside from working on our group's paper, I was teaching and explaining bit by bit while working to both him and Kenneth. Well, due to that though I got decent practice for multi-tasking and solving these types of problems as fast and as efficient as I possibly can. I don't blame Kenneth since I understand that there are really just times where you have a hard time understanding a particular subject, as for Davvid, he does what he can and him asking questions and asking to be taught is a good way to better the knowledge that I already know by teaching it to someone else.