Part 1 1. The heuristic implemented in the first option is none other than FIFO (First In First Out). In other words, this means that the buffer is organized as a very straightforward queue. In this queue, the new pieces of information are placed at the end, thus ensuring them at least some lifetime. However, eventually that item of information will move up the queue and will inevitably be disposed of in order to make space for a new piece of information. 2. Such an approach would prove highly inefficient if the algorithm is dealing with a particular piece of information over and over again. Actually, this is the case with the example provided in the assignment post; FIFO is not good for dealing with something like all those fives. 3. On the other hand, FIFO heuristic would be of acceptable efficiency if what we are looking for is the ability to keep up with a steady pace of data that comes in a roughly sequential order (Shaffer, 2011). However, I fail to imagine this being a commonplace circumstance. The only probable exception actually being read-ahead, which was hinted at in the assignment post. I guess in this case, it would make sense to try and foresee what piece of data is going to be needed and prepare it beforehand. Part 2 1. The heuristic used in menu option 2 is LRU (Least Recently Used). The name of this heuristic is rather self-explanatory - whatever the data item in a buffer is accessed, it is then put to the very front of the data structure. When there is a need to insert a new piece of data, it replaces the item that was used the least number of times and as a result is in the very end of the data structure. Thus, with LRU the items of data that are the most frequently used are guaranteed to stay readily available in the pool. 2. This approach can be the desirable one if the current priority is to constantly have direct access to information that is also used the most frequently. In the case proposed in the assignment post, the value that is used the most frequently is 5. Hence, 5 is what the buffer keeps for the longest of time. Part 3 1. The heuristic used in menu option 3 is LFU (Least Frequently Used). The idea behind this one is rather straightforward - the algorithm tracks the amount of times each buffer in the pool was accessed. Once there is a need to reuse a buffer, the buffer with the smallest use count is considered the least useful and thus, replaced. 2. In case the pool has not repeating inputs, in my limited understanding, the algorithm works as a FIFO type structure. I have already described how those function previously. 3. If a particular value is put into the buffer on multiple occasions, its position in the pool gets reinforced. The first example from the assignment post for