In ORMs, the timing of loading related data is what sets eager loading apart from lazy loading. Eager loading fetches the related data upfront as part of the initial query, so you have everything you need in one go and avoid additional database trips when you access those relationships. Lazy loading, on the other hand, waits until you actually access the related property, at which point it issues separate queries to fetch that data, which can lead to many small round-trips if you loop over items with relationships. That contrast—data being fetched upfront versus on demand—is what makes the statement correct. The idea that eager loading happens after the first query, or that lazy loading caches results, isn’t accurate by definition. Also, memory usage and performance aren’t fixed rules: eager loading can use more memory by loading extra data, while lazy loading can incur more queries and potential latency if you access many relationships. And the two strategies do not always share the same performance characteristics.

The idea being tested is how people progress in using media to seek information and build understanding. Emerging describes that early, developing phase where someone begins to engage with media to find information, ask questions, and start forming knowledge. It signals growth and movement toward more advanced information skills. The other terms don’t capture this developmental angle: cognitive is about mental processes in general, format is about how information is arranged, and new media points to the technologies themselves rather than a stage of development in information seeking. So, emerging best matches the notion of a developing stage in seeking information, knowledge, and understanding through media.

Dynamic programming and greedy algorithms differ in how they build solutions. Dynamic programming tackles a problem by breaking it into subproblems, solving each subproblem, and storing those results so they can be reused. This lets it consider many possible combinations and guarantees an optimal overall solution when the problem has overlapping subproblems and optimal substructure. Greedy approaches, on the other hand, pick the best local option at each step and never revisit those decisions, hoping the local choices add up to a global optimum. That can work for some problems but not for all. A classic example where greedy can fail is the 0/1 knapsack problem. If you choose items based on the highest value-to-weight ratio, you might fill the capacity with items that seem best individually but prevent picking a different combination of smaller items that would yield a larger total value. Dynamic programming avoids this pitfall by evaluating all feasible combinations up to the capacity, ensuring the best total value is found. Note that in fractional knapsack, greedy is optimal because you can take fractions of items, aligning local choices with the global optimum. Here, the issue arises specifically in the 0/1 version, where you must either take an item or leave it.

The main idea here is how eviction decisions use recency versus frequency to decide what to throw away. LRU (least recently used) evicts the item that hasn’t been used for the longest time. The logic is that if something was accessed recently, it’s likely to be accessed again soon because workloads often show temporal locality—recently used items tend to come back into use. LFU (least frequently used) evicts the item with the lowest access count. The idea is that items that have been accessed often are likely to be accessed again, so keeping those “hot” items around is beneficial when the workload has stable, long-term popularity. Thus, LRU shines when the workload exhibits temporal locality and patterns change over time; it adapts to recent behavior. LFU shines when there are a few consistently popular items and access patterns are stable enough that frequency is a good predictor of future use. Real systems sometimes blend these ideas or add aging to prevent old, frequently-used-but-no-long-used data from crowding the cache. The correct choice reflects these points: LRU evicts least recently used; LFU evicts least frequently used; LRU is good for temporal locality; LFU for stable access patterns. The other statements mischaracterize how the policies work or overgeneralize their applicability.