College of Information Technology Zagreb Entrance Exam Set

The core concept being tested here is the understanding of how different architectural patterns impact the maintainability and scalability of software systems, particularly in the context of a university’s IT infrastructure. A monolithic architecture, while simpler to develop initially, often leads to tightly coupled components. This coupling makes it difficult to update or replace individual parts without affecting the entire system, increasing the risk of introducing bugs and slowing down development cycles. For a large institution like the College of Information Technology Zagreb, which requires agility in adapting to new technologies and student needs, this can be a significant bottleneck. Microservices, on the other hand, break down an application into smaller, independent services that communicate with each other. This modularity allows teams to develop, deploy, and scale services independently. If a particular service, such as the student registration portal, experiences high demand, only that service needs to be scaled, rather than the entire application. This also means that if a new programming language or framework is better suited for a specific function, it can be adopted for that particular microservice without requiring a complete rewrite of the system. This independence fosters faster innovation, easier maintenance, and improved resilience, making it a more suitable choice for a dynamic academic environment. Event-driven architectures, while also promoting decoupling, focus on the flow of events. While beneficial for certain types of applications, a purely event-driven approach might introduce complexity in managing state and ensuring transactional integrity across multiple independent services, especially for core administrative functions. A hybrid approach often leverages microservices as the primary architectural style, with event-driven patterns used for inter-service communication where appropriate. Therefore, a microservices architecture offers the most direct advantages in terms of independent development, deployment, and scaling, which are crucial for the College of Information Technology Zagreb to adapt to evolving technological landscapes and user demands efficiently.

The scenario describes a distributed system where nodes communicate using a publish-subscribe messaging pattern. Node A publishes a message to topic ‘sensor_data’. Node B and Node C are subscribed to this topic. Node B receives the message and processes it, then publishes a derived status update to topic ‘system_alerts’. Node D is subscribed to ‘system_alerts’. The question asks about the direct communication path for the status update. The status update originates from Node B and is published to ‘system_alerts’. Node D is subscribed to ‘system_alerts’. Therefore, the direct communication path for the status update is from Node B to Node D, facilitated by the ‘system_alerts’ topic. This demonstrates an understanding of message brokering, topic subscriptions, and the flow of information in a decoupled messaging architecture, which is foundational for many IT systems and services taught at the College of Information Technology Zagreb. The initial message from A to B and C is a separate event. The key is to trace the *status update*, which is a new message published by B.

The scenario describes a distributed system where nodes communicate using a publish-subscribe model. The core issue is ensuring that a critical message, intended for all active subscribers, is delivered reliably even if some subscribers temporarily disconnect and then reconnect. The system uses a message queue for each subscriber. When a subscriber disconnects, its queue is marked as inactive. Upon reconnection, the system needs to determine which messages were published while the subscriber was offline. The question asks about the most robust mechanism for ensuring that a subscriber receives all messages published during its downtime. Let’s analyze the options: 1. **Persistent Queues with Replay Capability:** This approach involves storing published messages persistently on the broker. When a subscriber reconnects, it can request a replay of messages from a specific point in time (e.g., the last known successful delivery or a timestamp). This directly addresses the problem of missed messages during downtime. The broker maintains the message history, and the subscriber can retrieve it. This is a fundamental concept in reliable messaging systems, often implemented with technologies like Kafka, RabbitMQ with durable queues, or JMS with persistent delivery. 2. **In-Memory Buffering on Subscriber:** If subscribers buffer messages in memory, they are vulnerable to crashes or restarts. If the subscriber’s memory is lost, so are the missed messages. This is not a robust solution for distributed systems where node availability can be intermittent. 3. **Client-Side Acknowledgement and Re-request:** While client-side acknowledgements are crucial for confirming delivery, a simple re-request mechanism without server-side persistence of the missed messages would be inefficient and potentially incomplete. The server would need to retain messages for a period, which essentially leads back to persistent queues. Furthermore, determining the exact point to re-request from can be complex without a clear historical record. 4. **Broadcasting to All Active Subscribers Only:** This approach inherently fails to address the problem of subscribers who are temporarily inactive. Messages published while a subscriber is offline would simply be lost to that subscriber, violating the requirement for reliable delivery during downtime. Therefore, the most effective and robust solution for ensuring delivery of messages published during a subscriber’s disconnection is a system that supports persistent message storage and allows subscribers to retrieve missed messages upon reconnection. This is achieved through persistent queues with replay capabilities.

The core concept being tested here is the understanding of how different software development methodologies address the inherent uncertainty and evolving requirements in complex projects, particularly within the context of a forward-thinking institution like the College of Information Technology Zagreb. Agile methodologies, such as Scrum, are designed to embrace change and deliver value iteratively. They prioritize collaboration, customer feedback, and rapid adaptation. In contrast, traditional Waterfall models are more rigid, emphasizing upfront planning and sequential execution, which can be detrimental when requirements are not fully understood or are expected to change. The scenario describes a project at the College of Information Technology Zagreb aiming to develop a novel educational platform. Such projects are characterized by a high degree of innovation, potential for unforeseen technical challenges, and the need to incorporate feedback from diverse stakeholders (students, faculty, administration) throughout the development lifecycle. A methodology that allows for frequent inspection and adaptation is crucial. Scrum, with its iterative sprints, daily stand-ups, sprint reviews, and retrospectives, provides a framework for continuous feedback and adjustment. This allows the development team to pivot based on new insights or changing priorities, ensuring the final product aligns with the evolving needs of the College. Extreme Programming (XP) also shares many agile principles, focusing on technical excellence and frequent releases, making it a strong contender. Kanban, while agile, is more focused on workflow visualization and limiting work-in-progress, which might be less suited for managing the dynamic nature of a research-driven educational platform development where feature discovery is a significant part of the process. The V-model, a variation of Waterfall, is even more rigid in its testing phases and less adaptable to change. Therefore, a methodology that inherently supports adaptability and iterative refinement, like Scrum or XP, would be most effective. Given the options, Scrum’s structured approach to iterative development and feedback loops makes it the most suitable choice for a project at the College of Information Technology Zagreb that is likely to encounter evolving requirements and a need for continuous stakeholder input.

The scenario describes a distributed system where nodes communicate using a publish-subscribe messaging pattern. The core challenge is ensuring that a critical update message, intended for all active subscribers, is delivered reliably even in the presence of transient network partitions or node failures. The system uses a consensus mechanism to agree on the order of messages. When a partition occurs, nodes on one side of the partition cannot communicate with nodes on the other. If a node that is part of the consensus group fails or becomes unreachable, the remaining nodes must still be able to reach a consensus to continue operating. The question asks about the most robust approach to guarantee delivery of the critical update under these conditions. Consider a system with \(N\) nodes in the consensus group. For a consensus protocol to tolerate \(f\) failures (e.g., crash failures or network partitions affecting communication), it typically requires \(N > 2f\). This inequality ensures that even if \(f\) nodes fail, a majority (\(N-f\)) of the remaining nodes can still outvote the failed nodes and reach agreement. In this scenario, the critical update needs to be delivered to all *active* subscribers. The publish-subscribe model, when combined with a fault-tolerant consensus mechanism, aims to achieve this. If the consensus protocol can tolerate \(f\) failures, it means that a quorum of \(N-f\) nodes can still operate. For the critical update to be guaranteed, it must be committed by this quorum. Let’s analyze the options in the context of fault tolerance and distributed consensus: * **Option 1 (Focus on individual node acknowledgment):** Relying on individual node acknowledgments without a consensus layer is susceptible to failures. If a node fails before acknowledging, the sender might not know if the message was processed. This doesn’t guarantee delivery to all *active* subscribers in a fault-tolerant manner. * **Option 2 (Leader-based replication with majority commit):** This is a common and robust pattern. A leader is elected, and it proposes the critical update. The update is considered committed once a majority of the nodes (a quorum) have acknowledged receiving and persisting it. If the leader fails, a new leader can be elected from the remaining operational nodes, and the committed state (including the critical update) is preserved. This approach directly leverages the \(N > 2f\) principle for fault tolerance. If \(f\) nodes are down, the remaining \(N-f\) nodes form a majority, allowing consensus on the update. * **Option 3 (Unordered broadcast without consensus):** An unordered broadcast is inherently unreliable in a distributed system with potential failures. Messages can be lost, duplicated, or arrive out of order, making it impossible to guarantee delivery of a critical update, especially when partitions occur. * **Option 4 (Synchronous communication with all nodes):** While synchronous communication can simplify reasoning, it often leads to poor availability. If even one node is slow or unreachable, the entire system can stall, failing to deliver the critical update. This is the opposite of fault tolerance. Therefore, a system employing a leader-based replication strategy where the critical update is committed only after a majority of nodes have acknowledged it provides the highest level of assurance for delivery in the face of network partitions and node failures, aligning with the principles of distributed consensus required at institutions like the College of Information Technology Zagreb. This ensures that even if some nodes are temporarily unavailable, the update is reliably processed by the operational majority, maintaining system integrity and the ability to serve active subscribers.

The scenario describes a distributed system where nodes communicate using a publish-subscribe messaging pattern. The core challenge is ensuring that a message published by one node is reliably delivered to all subscribed nodes, even in the presence of network partitions or node failures. The question probes the understanding of different distributed consensus and messaging protocols. Consider a scenario where a publisher node, ‘Alpha’, sends a critical status update to a topic, ‘SystemHealth’. Several subscriber nodes, including ‘Beta’, ‘Gamma’, and ‘Delta’, are subscribed to this topic. The College of Information Technology Zagreb Entrance Exam emphasizes robust distributed systems design. If ‘Beta’ and ‘Gamma’ are on one network segment, and ‘Delta’ is on another, and a temporary network partition occurs between these segments, a protocol that relies on immediate, synchronous acknowledgment from all subscribers before confirming publication would fail to deliver the message to ‘Delta’ during the partition. Protocols like Paxos or Raft are designed for achieving consensus on a shared state, which is relevant for distributed databases or leader election, but not directly for the asynchronous, many-to-many delivery of messages in a pub-sub system. While they ensure agreement, they are typically synchronous and require a majority of nodes to be available. A protocol that prioritizes eventual consistency and decouples the publisher from the subscribers, allowing for offline delivery or delayed acknowledgments, is more suitable. This often involves a message broker that persists messages and delivers them when subscribers reconnect. Among common messaging patterns, a robust pub-sub implementation would typically employ a mechanism that ensures durability and at-least-once or exactly-once delivery semantics. If the goal is to ensure that ‘Delta’ eventually receives the message even after the partition heals, and the system aims for high availability and fault tolerance in its messaging, then a protocol that allows for message persistence and asynchronous delivery is key. This aligns with the principles of eventual consistency and fault-tolerant messaging systems often studied at the College of Information Technology Zagreb Entrance Exam. The most appropriate approach for ensuring eventual delivery in a partitioned network scenario, while maintaining the publish-subscribe paradigm, is a protocol that uses a persistent message queue managed by a broker. This broker can buffer messages and deliver them to subscribers once they become available, effectively handling temporary network disruptions. This ensures that the publisher doesn’t need to wait for all subscribers to be online simultaneously, promoting decoupling and resilience.

The scenario describes a distributed system where nodes communicate using a publish-subscribe model. The core issue is ensuring that a message published by a producer reaches all intended subscribers, even in the presence of network partitions or node failures. This relates directly to the concept of message delivery guarantees in distributed systems. A “fire-and-forget” approach, where a publisher sends a message and assumes it’s delivered without confirmation, offers the lowest guarantee. This is susceptible to message loss if a subscriber is offline or a network link fails. “At-least-once” delivery guarantees that a message will be delivered one or more times. This is typically achieved through acknowledgments and retries. If a publisher doesn’t receive an acknowledgment from the broker (or intermediary), it will re-send the message. This can lead to duplicate messages, which subscribers must be able to handle. “At-most-once” delivery guarantees that a message will be delivered at most once. This is often achieved by a publisher sending a message and not retrying if it doesn’t receive an acknowledgment. If the initial delivery fails, the message is lost. This prioritizes avoiding duplicates over ensuring delivery. “Exactly-once” delivery guarantees that a message is delivered precisely one time, no more and no less. This is the most complex to achieve in distributed systems and often involves a combination of transactional mechanisms, idempotency, and sophisticated state management at both the publisher and subscriber ends, or within the messaging middleware itself. Given the description of potential network issues and the need for reliability without explicit mention of duplicate handling or transactional integrity, the most appropriate guarantee that balances reliability with the inherent complexities of distributed messaging is “at-least-once” delivery. This ensures that messages are not lost due to transient failures, even if it means occasional duplication, which is a common trade-off for robustness in such systems. The College of Information Technology Zagreb Entrance Exam often emphasizes understanding these trade-offs in distributed computing.

The scenario describes a distributed system where nodes communicate using a publish-subscribe model. The core issue is ensuring that a newly added subscriber, “Node Gamma,” receives all messages published *before* its subscription, a concept known as “catch-up” or “historical message delivery.” In a typical publish-subscribe system, a subscriber only receives messages published after it has established its connection and subscribed to a topic. To address this, the system needs a mechanism to store past messages and deliver them to late-joining subscribers. The provided options represent different approaches to handling this: * **Option A:** This describes a persistent message queue for each topic. When Node Gamma subscribes, it can retrieve messages from this queue that were published prior to its subscription. This is a standard and effective method for achieving historical message delivery. The “retention policy” ensures messages are available for a defined period. * **Option B:** This suggests that Node Gamma must poll the publisher directly. This is inefficient, bypasses the publish-subscribe pattern, and doesn’t guarantee delivery of all messages if Node Gamma polls too late or if the publisher doesn’t maintain a history. It also creates tight coupling between subscriber and publisher. * **Option C:** This proposes that Node Gamma must re-subscribe to all previously published messages. This is logically impossible within the publish-subscribe paradigm as messages are transient unless explicitly stored. It implies a misunderstanding of how message brokers and subscriptions work. * **Option D:** This suggests that Node Gamma should request a “snapshot” of the system state. While snapshots are useful for recovery, they are not the direct mechanism for delivering a stream of historical messages in a publish-subscribe system. A snapshot is a point-in-time copy, not a log of events. Therefore, the most robust and standard solution for Node Gamma to receive past messages is through a persistent message queue with an appropriate retention policy, as described in Option A. This aligns with principles of reliable messaging and decoupled architectures, crucial for distributed systems studied at the College of Information Technology Zagreb.

The scenario describes a distributed system where multiple nodes are attempting to reach consensus on a shared state. The core challenge is to ensure that all participating nodes agree on the same value, even in the presence of network delays or node failures. The Byzantine Fault Tolerance (BFT) model is a theoretical framework that addresses consensus in systems where some nodes may exhibit arbitrary (malicious or faulty) behavior. In a BFT system, consensus can be achieved as long as the number of faulty nodes is less than one-third of the total number of nodes. This is because, in such a system, a majority of \(n\) nodes can be convinced of a particular state if at least \(2f + 1\) nodes are honest, where \(f\) is the maximum number of faulty nodes. If \(n\) is the total number of nodes and \(f\) is the maximum number of faulty nodes, then \(n > 3f\). In this case, if \(n = 7\), the maximum number of faulty nodes \(f\) for consensus to be guaranteed is \(f < \frac{7}{3}\), which means \(f\) can be at most 2. Therefore, with 7 nodes, a maximum of 2 nodes can be faulty, and consensus can still be reached. The question asks about the minimum number of nodes required to tolerate a certain number of faulty nodes. To tolerate \(f\) faulty nodes, a BFT system typically requires a minimum of \(3f + 1\) nodes. If we want to tolerate 3 faulty nodes, we need \(3 \times 3 + 1 = 10\) nodes. This ensures that even if 3 nodes are malicious, the remaining \(10 - 3 = 7\) nodes, which form a supermajority (\(> 2/3\)), can still reach consensus. The other options are incorrect because they do not satisfy the \(3f + 1\) requirement for tolerating \(f\) Byzantine faults. For instance, 7 nodes can tolerate at most 2 faulty nodes (\(3 \times 2 + 1 = 7\)). 8 nodes can tolerate at most 2 faulty nodes (\(3 \times 2 + 1 = 7\), so \(f=2\)). 9 nodes can tolerate at most 2 faulty nodes (\(3 \times 2 + 1 = 7\), so \(f=2\)). Thus, to guarantee consensus with up to 3 faulty nodes, a minimum of 10 nodes is necessary.

The scenario describes a distributed system where nodes communicate using a publish-subscribe messaging pattern. The core issue is ensuring that a critical update message, intended for all subscribed nodes, is processed reliably even if some nodes experience temporary network partitions or failures. The question asks about the most appropriate mechanism to guarantee delivery and processing order in such a context, considering the College of Information Technology Zagreb’s emphasis on robust distributed systems design. In a publish-subscribe model, a message broker typically handles message distribution. To ensure reliable delivery, especially in the face of network issues, the broker must provide guarantees. A common approach is to use persistent message queues. When a publisher sends a message, it is stored in the broker’s persistent storage. Subscribers then retrieve messages from these queues. The challenge here is not just delivery, but also ensuring that if a subscriber is offline, it receives the message upon reconnection, and that messages are processed in a predictable order. This points towards a need for acknowledged delivery and ordered queuing. Let’s analyze the options in the context of distributed systems principles relevant to the College of Information Technology Zagreb: * **Guaranteed Delivery with Acknowledgement and Ordered Queuing:** This mechanism ensures that messages are not lost. The publisher sends a message, the broker stores it persistently. Subscribers receive the message and must acknowledge its processing. If an acknowledgement isn’t received within a timeout, the broker can re-deliver. Furthermore, maintaining a strict order of messages within a subscriber’s queue ensures that updates are applied sequentially, preventing inconsistencies. This aligns with the need for fault tolerance and data integrity in distributed applications. * **Best-Effort Delivery without Acknowledgement:** This is the simplest but least reliable. Messages might be lost if a subscriber is offline or if the broker fails before delivery. It does not guarantee that all subscribed nodes will receive the update. * **At-Least-Once Delivery with Duplicate Detection:** While this guarantees delivery at least once, it doesn’t inherently guarantee order. Subscribers would need to implement logic to detect and discard duplicate messages, adding complexity and potential for error if not handled perfectly. This is a step towards reliability but doesn’t fully address the ordering requirement. * **Exactly-Once Delivery with Transactional Guarantees:** This is the most robust, ensuring each message is delivered and processed precisely once, and in order. However, implementing true exactly-once semantics in a distributed system is notoriously complex and can introduce significant overhead and latency. While ideal, it might be overkill or impractical for many scenarios, and the question asks for the *most appropriate* mechanism, implying a balance of reliability and practicality. Considering the need for reliable delivery of a critical update and the inherent challenges of distributed systems, the combination of guaranteed delivery (ensuring it arrives), acknowledgement (confirming processing), and ordered queuing (maintaining logical sequence) provides the necessary robustness without the extreme complexity of full exactly-once semantics. This approach is a cornerstone of building resilient distributed applications, a key area of study at the College of Information Technology Zagreb. The scenario emphasizes the need for a system that can withstand transient failures and maintain data consistency, which this combination directly addresses.

The scenario describes a distributed system where nodes communicate using a publish-subscribe model. The core issue is ensuring that a message published by a producer is reliably delivered to all intended subscribers, even in the presence of network partitions or node failures. The question probes the understanding of different message delivery guarantees in such systems. A “best-effort” delivery (often associated with UDP) means messages might be lost, duplicated, or arrive out of order. This is insufficient for critical data. “At-most-once” delivery guarantees that a message will be delivered at most one time, but it might not be delivered at all if a failure occurs before acknowledgment. “Exactly-once” delivery guarantees that a message is delivered precisely one time, even if failures occur. This is the most robust guarantee but is often complex and resource-intensive to implement in distributed systems, typically requiring mechanisms like transactional messaging or idempotent receivers. “At-least-once” delivery guarantees that a message will be delivered one or more times. While it prevents message loss, it can lead to duplicate messages, which the subscriber must be able to handle (e.g., through idempotency). Given the requirement for reliable delivery and the potential for network issues, a system aiming for high reliability would need to go beyond best-effort. While exactly-once is the ideal, it’s often prohibitively complex. At-least-once delivery, coupled with a mechanism for the subscriber to detect and discard duplicates (idempotency), provides a strong balance of reliability and implementability in many distributed scenarios, aligning with the robust data handling expected in IT disciplines at the College of Information Technology Zagreb. This approach ensures that no data is lost, and the system can tolerate transient failures without compromising the integrity of the information flow, a key consideration for building resilient applications.

The scenario describes a distributed system where a consensus protocol is being used to ensure data consistency across multiple nodes. The core challenge is to understand how the protocol handles potential failures and network partitions. In this specific case, a majority of nodes (4 out of 7) are still able to communicate, forming a quorum. The protocol’s design dictates that a decision can only be made if a supermajority (typically \( \lceil \frac{N}{2} \rceil + 1 \), where \(N\) is the total number of nodes) agrees. With 7 nodes, a supermajority is \( \lceil \frac{7}{2} \rceil + 1 = 3 + 1 = 4 \) nodes. Since 4 nodes are communicating and can reach agreement, they constitute a valid quorum. The remaining 3 nodes are isolated due to a network partition. The consensus protocol, by design, allows the connected majority to proceed with operations, ensuring consistency within that partition. This prevents the minority partition from making conflicting decisions. Therefore, the system will continue to operate correctly for the connected nodes, and the isolated nodes will eventually rejoin and synchronize once the partition is resolved. The key principle being tested here is the fault tolerance and availability of distributed consensus mechanisms, particularly how they maintain consistency in the face of network failures by adhering to quorum requirements. This is fundamental to understanding the robustness of systems like those developed and studied at the College of Information Technology Zagreb.

The core concept being tested here is the understanding of how different software development methodologies impact project timelines and resource allocation, particularly in the context of evolving requirements. Agile methodologies, like Scrum, are designed to be flexible and iterative, allowing for changes throughout the development cycle. This flexibility, however, can lead to a more dynamic and potentially longer overall development period if not managed effectively, as new features or modifications are incorporated. Waterfall, conversely, follows a linear, sequential approach where requirements are fixed upfront. While this can lead to predictable timelines if requirements remain stable, it is less adaptable to change. In the scenario presented, the client’s continuous introduction of new features and modifications directly challenges the rigid structure of a Waterfall model, necessitating frequent rework and delaying progress. An Agile approach, by its nature, would accommodate these changes more readily through its sprint-based development and regular feedback loops. Therefore, the project’s delay is a direct consequence of attempting to implement a rigid, sequential process in an environment characterized by fluid requirements, making the Agile approach a more suitable, albeit potentially longer, alternative for managing such dynamic projects at institutions like the College of Information Technology Zagreb. The explanation focuses on the inherent trade-offs between adaptability and predictability in software development lifecycles, a crucial consideration for IT professionals.

The scenario describes a distributed system where a consensus algorithm is being used to ensure data consistency across multiple nodes. The core problem is to determine the minimum number of nodes that must be operational for a specific consensus protocol to guarantee agreement, even in the presence of failures. For many common Byzantine Fault Tolerant (BFT) consensus algorithms, such as Practical Byzantine Fault Tolerance (PBFT), the system can tolerate up to \(f\) faulty nodes if there are at least \(3f + 1\) total nodes. This is because a supermajority of \(2f + 1\) nodes is required to reach consensus, and this supermajority must be able to outvote the \(f\) faulty nodes and the remaining \(f\) correct nodes that might be temporarily unavailable or disagreeing. Therefore, if the system can tolerate \(f=1\) faulty node, the total number of nodes \(N\) must be at least \(3(1) + 1 = 4\). This ensures that even if one node fails, the remaining \(N-1 = 3\) nodes can still form a supermajority of \(2f+1 = 3\) to reach consensus. The question asks for the minimum number of nodes required to tolerate at least one faulty node, which directly corresponds to the \(N \ge 3f + 1\) formula with \(f=1\). Thus, the minimum number of nodes is \(3(1) + 1 = 4\).

The scenario describes a distributed system where nodes communicate using a publish-subscribe messaging pattern. The core challenge is ensuring that a message published by a producer is reliably delivered to all intended subscribers, even in the presence of network partitions or node failures. Consider a scenario where a producer node \(P\) publishes a message \(M\) to a topic \(T\). There are three subscriber nodes: \(S_1\), \(S_2\), and \(S_3\). The messaging system uses a broker architecture. If the system guarantees “at-least-once” delivery, it means that each subscriber will receive the message \(M\) either once or multiple times. This is typically achieved through acknowledgments and retries. When a subscriber receives a message, it sends an acknowledgment back to the broker. If the broker doesn’t receive an acknowledgment within a certain timeout, it re-sends the message. This can lead to duplicate deliveries. “At-most-once” delivery guarantees that a message is delivered at most once. If a message is lost due to a network failure before it reaches the subscriber or before the acknowledgment is received, it is not re-sent. This prioritizes efficiency over guaranteed delivery. “Exactly-once” delivery is the most stringent. It guarantees that each message is delivered precisely one time, even in the face of failures. Achieving true exactly-once delivery in a distributed system is complex and often involves techniques like idempotent message processing on the subscriber side, transaction logs, or distributed consensus mechanisms. In the given scenario, the system aims to ensure that if a subscriber is available and connected, it will receive the message. This implies a need for reliability beyond just “at-most-once.” However, the question doesn’t explicitly state that duplicates are unacceptable or that the system must prevent them. The emphasis is on ensuring delivery if the subscriber is reachable. Let’s analyze the options in the context of reliable messaging in distributed systems, particularly relevant to the principles taught at the College of Information Technology Zagreb. Option 1: “At-least-once delivery, with mechanisms to handle potential duplicates on the subscriber side.” This aligns with a common and practical approach to distributed messaging. It ensures that messages are not lost if a subscriber is temporarily unavailable, and the burden of deduplication is placed on the consumer, which is a standard pattern. Option 2: “At-most-once delivery, prioritizing message throughput over guaranteed reception.” This would mean messages could be lost, which contradicts the goal of ensuring delivery if the subscriber is available. Option 3: “Exactly-once delivery, requiring complex coordination and transaction management between producer, broker, and subscribers.” While ideal, “exactly-once” is significantly more complex to implement and often has performance implications. The scenario doesn’t necessitate this level of complexity unless explicitly stated that duplicates are strictly forbidden. Option 4: “Best-effort delivery, relying solely on the network’s inherent reliability.” This is the weakest guarantee and would likely result in message loss, failing the requirement of ensuring delivery when possible. The most appropriate and commonly implemented guarantee that ensures delivery when a subscriber is available, while acknowledging the practical challenges of distributed systems, is “at-least-once” delivery coupled with a strategy for handling potential duplicates. This reflects the trade-offs often discussed in distributed systems design, a key area of study at the College of Information Technology Zagreb. The system ensures that the message *attempts* to reach the subscriber, and if it arrives multiple times, the subscriber can manage it. This is a robust approach for many applications.

The core concept tested here is the understanding of how different architectural patterns influence the maintainability and scalability of software systems, particularly in the context of a modern IT curriculum like that at the College of Information Technology Zagreb. A monolithic architecture, while simpler to develop initially, often leads to tightly coupled components. This coupling makes it difficult to isolate and update specific functionalities without impacting other parts of the system. Consequently, introducing new features or fixing bugs becomes a more time-consuming and error-prone process. The lack of independent deployability for individual services also hinders rapid iteration and experimentation, which are crucial for staying competitive. In contrast, a microservices architecture, by breaking down an application into small, independent, and loosely coupled services, addresses these challenges. Each service can be developed, deployed, and scaled independently. This modularity significantly improves maintainability because changes within one service have minimal impact on others. Furthermore, it allows teams to use different technology stacks for different services, fostering innovation and enabling the adoption of best-of-breed solutions for specific problems. The ability to scale individual services based on demand also leads to more efficient resource utilization and better overall system performance. Therefore, for an institution like the College of Information Technology Zagreb, which emphasizes modern software development practices and robust system design, understanding the benefits of microservices for long-term maintainability and agility is paramount.

The scenario describes a distributed system where nodes communicate using a publish-subscribe (pub-sub) messaging model. The core challenge is ensuring that messages published by a sender are reliably delivered to all intended subscribers, even in the presence of network partitions or node failures. The system aims for eventual consistency, meaning that if no new updates are made, all nodes will eventually converge to the same state. Consider a scenario where a publisher sends a message to a topic. In a robust pub-sub system designed for high availability and fault tolerance, the message is typically replicated across multiple brokers or nodes. Subscribers then receive this message. If a subscriber node is temporarily disconnected due to a network partition, it should not lose the message. Upon re-establishing connectivity, the subscriber should receive any messages it missed during the outage. This is achieved through mechanisms like persistent message queues or durable subscriptions. The question asks about the fundamental principle that guarantees message delivery in such a system, even after temporary disruptions. This principle is not about immediate, synchronous delivery, but rather about the eventual arrival of messages once the system recovers from a failure or partition. Let’s analyze the options in the context of distributed systems and messaging: * **Eventual Consistency:** This is a property of distributed systems where, if no new updates are made to a given data item, eventually all accesses to that item will return the last updated value. While related to distributed systems, it’s a broader concept about data state convergence, not specifically the guarantee of message delivery after a disruption. * **Idempotency:** This refers to an operation that can be applied multiple times without changing the result beyond the initial application. It’s crucial for preventing duplicate processing of messages but doesn’t guarantee delivery in the first place after a failure. * **At-least-once delivery:** This is a quality of service in messaging systems that guarantees a message will be delivered to its recipient at least one time. It allows for duplicate messages in the event of failures and retries, but ensures no messages are lost. This directly addresses the scenario of a subscriber being offline and then reconnecting. * **Exactly-once delivery:** This is the ideal but often difficult-to-achieve guarantee that a message is delivered precisely one time. While desirable, achieving true exactly-once delivery in a distributed system is complex and often involves trade-offs with performance and availability. The scenario described, with temporary disconnections and eventual delivery, aligns more closely with at-least-once delivery as the foundational guarantee that prevents message loss. The scenario emphasizes that the subscriber *will* receive the message after re-establishing connectivity, implying that the system retains the message and delivers it. This is the core promise of at-least-once delivery. The system ensures that the message isn’t dropped permanently due to the subscriber’s temporary unavailability. Therefore, the most fitting principle that guarantees message delivery in this context, even after a temporary disconnection, is at-least-once delivery.

The core concept tested here is the understanding of how different architectural patterns impact the maintainability and scalability of software systems, particularly in the context of a university’s IT infrastructure. A monolithic architecture, while simpler to develop initially, often leads to tightly coupled components. This coupling makes it difficult to update, test, or scale individual parts of the system without affecting others. For the College of Information Technology Zagreb, which likely manages diverse student information systems, research databases, and online learning platforms, a monolithic approach would hinder rapid deployment of new features or bug fixes for specific services. For instance, updating the student enrollment module in a monolith might inadvertently break the library system if they share dependencies. Conversely, a microservices architecture breaks down the application into smaller, independent services that communicate with each other. This allows for independent development, deployment, and scaling of each service. If the College of Information Technology Zagreb needs to enhance its online examination system, it can do so without impacting the faculty management system. This independence is crucial for agility and resilience. A hybrid approach, combining elements of both, might offer some benefits but can also introduce complexity in managing the integration points. A client-server model is a broader architectural concept and doesn’t specifically address the internal decomposition of the server-side application in the way monolithic vs. microservices does. Therefore, while client-server is fundamental, it doesn’t offer the granular benefits for system evolution that microservices do when compared to a monolith. The question asks which architectural style would *best* support the College of Information Technology Zagreb’s need for rapid iteration and independent component updates, making microservices the most suitable choice due to its inherent modularity and decoupling.

The scenario describes a distributed system where nodes communicate using a publish-subscribe (pub-sub) messaging pattern. The core challenge is ensuring that a message published by a producer is reliably delivered to all interested consumers, even in the presence of network partitions or node failures. Consider a scenario where a producer publishes a message to a topic. In a typical pub-sub system, this message is sent to a broker or a set of brokers. Consumers subscribe to topics of interest. The brokers are responsible for routing messages from producers to subscribers. The question asks about the most robust mechanism for ensuring delivery in a distributed setting, specifically addressing potential failures. Let’s analyze the options in the context of distributed systems principles and common messaging patterns: * **Guaranteed Delivery with Acknowledgement:** This implies that the system will make multiple attempts to deliver the message and will only consider the delivery successful once an acknowledgement is received from the consumer (or its representative). This is a fundamental concept for reliable messaging. In distributed systems, this often involves mechanisms like persistent queues on the broker, retry logic, and potentially dead-letter queues for messages that cannot be delivered after a certain number of attempts. This directly addresses the reliability requirement. * **Best-Effort Delivery without Acknowledgement:** This is the opposite of reliable delivery. Messages might be lost if a consumer is offline or if there are network issues. This is not suitable for scenarios requiring guaranteed delivery. * **At-Least-Once Delivery with Idempotent Consumers:** At-least-once delivery means a message might be delivered more than once. To handle this, consumers must be designed to be idempotent, meaning processing the same message multiple times has the same effect as processing it once. While this is a common pattern for achieving reliability, it relies on the consumer’s implementation. The question asks for the *mechanism* ensuring delivery, and while idempotency is a *consumer-side* solution to a delivery problem, guaranteed delivery with acknowledgment is a more direct *system-level* mechanism for ensuring the message *reaches* the consumer reliably. * **Exactly-Once Delivery:** This is the most stringent guarantee, ensuring a message is delivered and processed precisely one time. Achieving true exactly-once delivery in a distributed system is notoriously complex and often involves a combination of at-least-once delivery, idempotency, and transaction management. While desirable, it’s often overkill or prohibitively difficult to implement compared to guaranteed delivery with acknowledgements, which focuses on the delivery aspect itself. Given the context of a distributed system and the need for reliability in a pub-sub model, the most fundamental and broadly applicable mechanism to ensure a message is *delivered* (even if it might require re-processing by the consumer if it’s at-least-once) is a system that actively tracks delivery and requires confirmation. Guaranteed delivery with acknowledgement directly addresses the problem of ensuring the message *reaches* the intended recipient, handling transient failures through retries and confirmation. This aligns with the core principles of building resilient distributed messaging systems, a key area of study within information technology. The College of Information Technology Zagreb Entrance Exam would expect candidates to understand these fundamental reliability patterns in distributed systems.

The scenario describes a distributed system where nodes communicate using a publish-subscribe model. The core challenge is ensuring that a message published by a producer is reliably delivered to all interested subscribers, even in the presence of network partitions or node failures. The concept of “at-least-once delivery” guarantees that a message will be delivered to a subscriber at least one time. However, it does not prevent duplicate deliveries if a subscriber acknowledges a message but the acknowledgment is lost, causing the publisher to retransmit. “Exactly-once delivery” is the ideal but often complex to achieve in distributed systems, requiring sophisticated mechanisms like idempotent receivers or distributed transactions. “At-most-once delivery” would mean a message might be lost entirely if a failure occurs before delivery. Given the requirement for reliability and the inherent possibility of retransmissions in a robust pub-sub system aiming for high availability, the most fitting guarantee, balancing reliability with practical implementation in a distributed context, is at-least-once delivery. This is because the system prioritizes not losing messages, even if it means occasional duplicates that the subscriber must handle. The College of Information Technology Zagreb Entrance Exam often emphasizes understanding the trade-offs in distributed systems design, and at-least-once delivery is a fundamental concept in achieving fault tolerance without the extreme complexity of true exactly-once delivery in all scenarios.

The core of this question lies in understanding the principles of data integrity and the role of different database constraints in enforcing it. When considering the scenario of a student information system at the College of Information Technology Zagreb, maintaining accurate and consistent data is paramount. A `UNIQUE` constraint ensures that all values in a column, or a set of columns, are distinct. This is crucial for identifiers like student IDs or email addresses, preventing duplicate entries. A `PRIMARY KEY` constraint is a special type of `UNIQUE` constraint that also enforces `NOT NULL`. It uniquely identifies each record in a table and serves as the main identifier for rows. A `FOREIGN KEY` constraint establishes a link between two tables. It ensures that a value in one table’s column (the referencing column) must match a value in another table’s column (the referenced column), typically the primary key of the referenced table. This maintains referential integrity, meaning that relationships between tables remain valid. A `CHECK` constraint enforces a condition on the values entered into a column. For example, it could ensure that a grade is within a valid range or that a date is in the past. In the context of the College of Information Technology Zagreb’s student enrollment process, where students register for courses, the `FOREIGN KEY` constraint is the most critical for ensuring referential integrity between the `Students` table and the `Enrollments` table. Specifically, the `StudentID` in the `Enrollments` table must reference a valid `StudentID` in the `Students` table. If a `FOREIGN KEY` constraint is violated (e.g., an attempt to enroll a non-existent student), the database system will prevent the operation, thereby safeguarding the integrity of the enrollment data and preventing orphaned records. While `UNIQUE` and `PRIMARY KEY` are vital for identifying students, and `CHECK` constraints can validate specific data points, the `FOREIGN KEY` is the mechanism that directly links student records to their course enrollments, ensuring that every enrollment is associated with a legitimate student.

The scenario describes a distributed system where nodes communicate using a publish-subscribe (pub-sub) messaging pattern. The core challenge is ensuring that messages published by a sender are reliably delivered to all intended subscribers, even in the presence of network partitions or node failures. The question probes the understanding of mechanisms that guarantee message delivery in such a distributed environment. In a pub-sub system, publishers send messages to a topic, and subscribers express interest in specific topics. A message broker typically manages the distribution. To ensure reliable delivery, especially in a distributed setting like the one described for the College of Information Technology Zagreb Entrance Exam context, several strategies can be employed. Consider a scenario where a publisher sends a message to a topic, and there are multiple subscribers connected through different network paths. If a network partition occurs, some subscribers might become temporarily unreachable. To guarantee eventual delivery, the system needs to maintain a persistent record of messages and re-attempt delivery when connectivity is restored. This is often achieved through mechanisms like message queues with acknowledgments and durable subscriptions. Durable subscriptions are crucial here. They ensure that the broker retains messages for a subscriber even if the subscriber is offline. When the subscriber reconnects, it can retrieve the missed messages. Furthermore, the broker itself needs to be resilient. If the broker fails, the system should ideally recover without losing messages. This can involve techniques like replication or distributed consensus protocols for the broker’s state. The question asks about the most effective approach to guarantee delivery in this distributed pub-sub system. Let’s analyze the options: * **Guaranteed message delivery with durable subscriptions and broker-level persistence:** This approach directly addresses the core requirements. Durable subscriptions ensure that messages are held for offline subscribers, and broker-level persistence (e.g., writing messages to disk before acknowledging receipt to the publisher) prevents message loss if the broker itself crashes. Re-delivery attempts with acknowledgments from subscribers further strengthen reliability. This is the most comprehensive solution for ensuring that messages are not lost and are eventually delivered to all active subscribers, even during temporary disruptions. * **Best-effort delivery with ephemeral subscriptions:** This would mean messages are delivered only if subscribers are online at the moment of publication. It offers no guarantee of delivery if subscribers are offline or if network issues arise, making it unsuitable for the stated requirement. * **Publisher-side message caching and manual retransmission:** While a publisher might cache messages, relying on manual retransmission by the publisher to individual subscribers is inefficient, complex to manage in a large distributed system, and doesn’t inherently solve the problem of knowing *which* subscribers missed a message due to a partition. It also doesn’t address broker failures. * **Client-side acknowledgment without broker persistence:** If the broker doesn’t persist messages, and a subscriber acknowledges a message but the broker crashes before the subscriber is marked as delivered, the message could be lost. Client-side acknowledgments are important for confirming receipt, but without broker persistence, they don’t guarantee end-to-end delivery in the face of broker failures. Therefore, the combination of durable subscriptions and broker-level persistence is the most robust solution for guaranteeing message delivery in the described distributed pub-sub system, aligning with the rigorous standards expected in information technology education at institutions like the College of Information Technology Zagreb. This approach ensures that the system can withstand transient failures and network partitions, a critical consideration for reliable communication in modern distributed applications.

The scenario describes a distributed system where nodes communicate using a publish-subscribe messaging pattern. The core issue is ensuring that a newly added subscriber, “Node Gamma,” receives all messages published *after* its subscription, without missing any. This is a fundamental challenge in asynchronous messaging systems. The provided solution, “Implementing a durable subscription mechanism for Node Gamma,” directly addresses this by ensuring that the message broker retains messages intended for Node Gamma even if it was offline during their publication. This persistence allows Node Gamma to retrieve the backlog of messages upon connecting. A durable subscription is a feature in messaging systems where the subscriber’s identity and subscription are registered with the message broker. The broker then guarantees that messages published to the subscribed topic will be stored until the subscriber explicitly acknowledges their receipt. This contrasts with non-durable subscriptions, where messages are lost if the subscriber is not connected when they are published. In the context of the College of Information Technology Zagreb’s curriculum, understanding such mechanisms is crucial for developing robust distributed applications, real-time data processing pipelines, and fault-tolerant systems. The ability to design and implement systems that handle intermittent connectivity and ensure data integrity is a hallmark of advanced IT professionals. This question probes the candidate’s grasp of fundamental distributed systems concepts and their practical implications in message queuing technologies, which are widely used in modern software architectures.

The core concept being tested here is the understanding of how different architectural patterns influence the maintainability and scalability of software systems, particularly in the context of a university’s IT infrastructure. A monolithic architecture, while simpler to develop initially, often leads to tightly coupled components. This coupling makes it difficult to update, test, or scale individual parts of the system without affecting others. For the College of Information Technology Zagreb, which likely manages diverse academic and administrative functions (e.g., student registration, course management, research portals, library systems), a monolithic approach would hinder agility. If a new feature for online course enrollment needs to be deployed, or if the research data repository requires significant scaling, a monolithic system would necessitate redeploying the entire application, increasing risk and downtime. Conversely, a microservices architecture, where the system is broken down into small, independent, and loosely coupled services, offers significant advantages. Each service can be developed, deployed, and scaled independently. This aligns with the College of IT Zagreb’s need for flexibility and resilience. For instance, the student registration service could be updated without impacting the library system. If the research portal experiences a surge in traffic, only that specific service needs to be scaled, optimizing resource utilization and ensuring continuous operation for other services. This independence also facilitates the adoption of different technologies for different services, allowing the College to leverage specialized tools for specific tasks, such as advanced analytics for student performance or robust database solutions for research data. The ability to isolate failures and deploy updates rapidly is crucial for maintaining a high level of service for students, faculty, and researchers. Therefore, a microservices architecture is the most suitable choice for a dynamic and evolving academic institution like the College of Information Technology Zagreb.

The core concept tested here is the understanding of how different programming paradigms influence the design and implementation of software, particularly in the context of object-oriented programming (OOP) and functional programming (FP). The scenario describes a system that requires robust error handling and state management, which are hallmarks of well-structured OOP. Specifically, the need for encapsulating data and behavior within distinct units (objects) that can interact through defined interfaces is crucial for managing complexity and ensuring maintainability. The emphasis on immutability and pure functions, characteristic of FP, while beneficial for certain aspects like concurrency, can introduce complexities in managing stateful operations and side effects, which are inherent in many real-world applications requiring explicit error propagation and state transitions. Therefore, an object-oriented approach, with its focus on encapsulation, inheritance, and polymorphism, provides a more direct and manageable framework for addressing the stated requirements of the College of Information Technology Zagreb’s project. The ability to model real-world entities as objects, each with its own state and methods, allows for a clear separation of concerns and facilitates the development of a system that is both scalable and understandable. This aligns with the foundational principles taught at the College of Information Technology Zagreb, emphasizing structured design and maintainable codebases.

The core concept here is understanding the implications of a distributed ledger’s immutability and consensus mechanisms on data integrity and the potential for unauthorized modification. In a blockchain, once a block is added and validated by the network’s consensus protocol, altering its contents would require recomputing the cryptographic hash of that block and all subsequent blocks, as well as achieving consensus from a majority of the network participants to accept this altered chain. This is computationally infeasible for public, permissionless blockchains due to the sheer scale of distributed computing power. For a private or permissioned blockchain, while the computational barrier might be lower, the inherent design of distributed consensus and cryptographic linking still makes unauthorized modification extremely difficult and detectable by other network participants. Therefore, the fundamental security of a blockchain relies on these properties, ensuring that recorded transactions are tamper-evident and, in practice, tamper-proof. This is crucial for applications requiring high levels of trust and auditability, such as supply chain management, digital identity, and financial transactions, all areas of interest for the College of Information Technology Zagreb. The ability to verify the integrity of historical data without relying on a central authority is a key differentiator of blockchain technology.

The scenario describes a distributed system where nodes communicate using a publish-subscribe (pub-sub) messaging pattern. The core challenge is ensuring that messages published by a producer are reliably delivered to all intended subscribers, even in the presence of network partitions or node failures. In a typical pub-sub system, a broker or intermediary manages the distribution of messages. Subscribers register their interest in specific topics, and when a producer publishes a message to a topic, the broker forwards it to all subscribers of that topic. The question asks about the most effective mechanism for guaranteeing delivery to all subscribers in a distributed environment, considering potential disruptions. Let’s analyze the options: * **Guaranteed delivery with acknowledgments and persistent queues:** This approach involves the broker storing messages in persistent queues until they are successfully acknowledged by subscribers. If a subscriber is temporarily unavailable, the message remains in the queue. This directly addresses the reliability requirement. The “acknowledgment” part ensures that the broker knows when a message has been received and processed by a subscriber. Persistent queues prevent message loss during broker restarts or failures. This is a robust solution for ensuring all subscribers eventually receive messages. * **Best-effort delivery with transient message storage:** This is less reliable. Transient storage means messages are lost if the broker restarts or if a subscriber is offline when the message is published. It does not guarantee delivery. * **At-least-once delivery with deduplication at the subscriber:** While “at-least-once” delivery implies that messages might be delivered more than once, it doesn’t inherently guarantee that *all* subscribers will receive it, especially if they are offline for extended periods or if the broker itself fails before forwarding. Deduplication at the subscriber helps manage duplicate messages but doesn’t solve the fundamental delivery problem. * **Exactly-once delivery with distributed consensus protocols:** While “exactly-once” is the ideal, implementing it in a distributed system is complex and often involves significant overhead. Furthermore, the core requirement here is *delivery to all subscribers*, not necessarily preventing duplicates if a subscriber is temporarily unavailable and the message is re-sent. The most direct and commonly implemented mechanism for reliable delivery in pub-sub, especially when dealing with potential subscriber unavailability, is the combination of persistence and acknowledgments. The question focuses on the *mechanism for delivery guarantee*, and persistent queues with acknowledgments are the most direct answer for ensuring messages aren’t lost and are eventually delivered. The complexity of “exactly-once” might be overkill for the stated problem of ensuring delivery to all, and the other options are clearly less robust. Therefore, the most effective mechanism for guaranteeing delivery to all subscribers in a distributed pub-sub system, considering potential network issues and node failures, is guaranteed delivery with acknowledgments and persistent queues.

The scenario describes a distributed system where nodes communicate using a publish-subscribe (pub-sub) messaging pattern. The core challenge is ensuring that a message published by a producer is reliably delivered to all interested consumers, even in the presence of network partitions or node failures. In a pub-sub system, a broker typically manages subscriptions and message routing. When a producer publishes a message to a topic, the broker is responsible for forwarding that message to all subscribers of that topic. The question asks about the primary mechanism that guarantees delivery to *all* subscribers in such a system, considering the inherent complexities of distributed environments. Option A, “Guaranteed delivery mechanisms within the messaging middleware,” directly addresses this. Modern messaging middleware (like Kafka, RabbitMQ, or ActiveMQ) implements various strategies to ensure message persistence and delivery. These often involve acknowledgments from subscribers, message replication, and retry mechanisms. For instance, a broker might wait for acknowledgments from a quorum of consumers before considering a message “delivered” or store messages persistently until they are acknowledged. This ensures that even if a subscriber is temporarily unavailable, the message is not lost and can be delivered later. Option B, “Client-side deduplication of messages,” is a technique to handle duplicate messages that might arise from retries, but it doesn’t guarantee the initial delivery to all subscribers. It’s a complementary mechanism for robustness, not the primary delivery guarantee. Option C, “Server-side message caching for offline subscribers,” is part of a guaranteed delivery strategy but is not the complete picture. Caching is a component that enables delivery to offline subscribers, but the overall guarantee involves more than just caching; it includes tracking delivery status and potentially re-transmitting. Option D, “End-to-end encryption of all published data,” is crucial for security and privacy but has no direct bearing on the reliability or guaranteed delivery of messages to subscribers. Encryption ensures confidentiality, not delivery assurance. Therefore, the most accurate and comprehensive answer is the underlying mechanisms within the messaging middleware itself that are designed to ensure that published messages reach all registered subscribers, even under adverse conditions. This aligns with the principles of reliable distributed systems and the design goals of robust messaging platforms, which are fundamental concepts for students at the College of Information Technology Zagreb.

The scenario describes a distributed system where nodes communicate using a publish-subscribe (pub-sub) messaging model. The core challenge is ensuring that a message published by a sender is reliably delivered to all intended subscribers, even in the presence of network partitions or node failures. The question probes the understanding of different message delivery guarantees in such a system. Let’s analyze the options in the context of pub-sub: * **At-most-once delivery:** A message might be delivered zero or one time. If a subscriber acknowledges receipt before the message is fully processed, or if a network issue occurs after delivery but before acknowledgment, the message might be lost. This is insufficient for ensuring all subscribers receive the message. * **At-least-once delivery:** A message is guaranteed to be delivered one or more times. This is achieved through mechanisms like retransmissions upon timeout or failure to acknowledge. While it ensures delivery, it can lead to duplicate messages if a sender retransmits a message that was actually received but the acknowledgment was lost. This is closer to the requirement but still has the issue of potential duplicates. * **Exactly-once delivery:** A message is guaranteed to be delivered precisely one time. This is the most robust guarantee, preventing both message loss and duplication. In a distributed pub-sub system, achieving true exactly-once delivery is complex and often involves sophisticated techniques like distributed transactions, idempotency, and careful state management to ensure that even if a message is processed multiple times due to retries, its effect is only applied once. This aligns with the goal of ensuring all intended subscribers receive the message without loss or duplication. * **Best-effort delivery:** This is similar to at-most-once delivery, where there are no guarantees about delivery. Messages can be lost without any notification. This is clearly not suitable for the stated requirement. Therefore, to ensure a message published by a sender is reliably delivered to all intended subscribers without loss or duplication, the system must aim for exactly-once delivery semantics. This is a fundamental concept in building resilient and dependable distributed messaging systems, a key area of study within information technology, particularly relevant for applications requiring high data integrity and consistency, such as financial systems or critical control systems, which are often explored in advanced IT programs at institutions like the College of Information Technology Zagreb.

The scenario describes a distributed system where nodes communicate using a publish-subscribe (pub/sub) messaging pattern. The core challenge is ensuring that messages published by a sender are reliably delivered to all intended subscribers, even in the presence of network partitions or node failures. The College of Information Technology Zagreb Entrance Exam emphasizes understanding of robust distributed system design principles. In this context, a “message broker” acts as an intermediary, receiving messages from publishers and routing them to subscribers based on defined topics. For reliable delivery, especially in a distributed environment, the broker needs to maintain state about which subscribers have received which messages. Consider a scenario where a publisher sends a message to topic ‘A’. The broker receives this message. It has a list of subscribers interested in topic ‘A’. To ensure reliability, the broker must acknowledge receipt of the message from the publisher and then ensure delivery to each subscriber. If a subscriber is temporarily unavailable, the broker might need to buffer the message or implement a retry mechanism. The question asks about the most critical factor for ensuring that *all* subscribers receive a published message in a pub/sub system at the College of Information Technology Zagreb Entrance Exam. Let’s analyze the options: * **Guaranteed delivery to each subscriber:** This directly addresses the core requirement. If a message isn’t guaranteed to reach each individual subscriber, then the overall goal of all subscribers receiving it fails. This involves mechanisms like acknowledgments from subscribers, message persistence by the broker, and retry logic. * **Publisher’s network stability:** While important for the publisher to send the message, it doesn’t guarantee delivery *to* the subscribers once the broker has it. * **Subscriber’s topic subscription accuracy:** If a subscriber has subscribed correctly, it’s a prerequisite, but it doesn’t guarantee the *delivery* of the message itself. A correctly subscribed but offline subscriber won’t receive the message without a reliable delivery mechanism. * **Broker’s message queuing capacity:** High queuing capacity is beneficial for handling bursts, but it doesn’t inherently guarantee that a message, once queued, will eventually reach a subscriber, especially if the subscriber is permanently gone or the broker itself fails without persistence. Therefore, the most fundamental and critical factor for ensuring all subscribers receive a published message in a reliable pub/sub system, as would be assessed at the College of Information Technology Zagreb Entrance Exam, is the underlying mechanism that guarantees delivery to each individual subscriber.