The core principles of Object-Oriented Programming (OOP) in Java are encapsulation, inheritance, polymorphism, and abstraction. Encapsulation hides the internal state of objects and requires all interactions to occur through an object's methods, enhancing modularity and maintenance. Inheritance allows the creation of new classes based on existing ones, promoting code reusability. Polymorphism enables objects to be processed differently based on their data type or class, facilitating flexibility and integration. Abstraction simplifies complex systems by modeling classes based on essential attributes and behaviors, allowing developers to focus on high-level functionality .

Normalization techniques in DBMS reduce data redundancy by organizing data into tables where each is dedicated to a specific topic and related data is stored together. In 1NF, data redundancy is minimized by ensuring that each column contains atomic values and each record is unique. In 2NF, it eliminates partial dependency on a composite key by ensuring that non-key attributes are fully functionally dependent on the primary key. 3NF removes transitive dependency, meaning non-key attributes are only dependent on the key. These steps progressively eliminate redundancy and ensure data integrity in the database .

Paging and segmentation are two methods of memory management in operating systems. Paging divides memory into fixed-size blocks called pages, which facilitates efficient and easy memory allocation without external fragmentation but may lead to internal fragmentation. It simplifies memory allocation by eliminating the need for contiguous memory blocks. Segmentation, on the other hand, divides memory into variable-size segments based on logical divisions like code, data, and stack, making it easier to enforce protection and sharing policies but susceptible to external fragmentation. While paging is generally more efficient, segmentation aligns better with user perspectives and logical program structures .

Dynamic Programming is an algorithmic technique used to efficiently solve problems with overlapping subproblems and optimal substructure properties. By using memoization, dynamic programming stores the results of expensive function calls and reuses them when the same inputs occur again. In the case of computing Fibonacci numbers, each number in the sequence is the sum of the two preceding ones. Without memoization, recursive computation would involve redundant calculations. Dynamic programming stores previously computed Fibonacci values to avoid recalculating them, significantly reducing time complexity from exponential to linear .

ACID properties are critical for ensuring transaction reliability in databases. Atomicity guarantees that a transaction is all-or-nothing, preventing partial updates that could lead to inconsistencies. Consistency ensures that a transaction brings the database from one valid state to another, maintaining integrity constraints. Isolation ensures that concurrent transactions produce the same outcome as if they were executed sequentially, preventing interference. Durability guarantees that once a transaction is committed, it remains permanent even in the event of a failure. Together, these properties ensure robustness, data integrity, and reliability in database transactions .

Deadlock in an operating system occurs when two or more processes are unable to proceed because each is waiting for a resource held by another, creating a cycle of dependence that halts all involved processes. One effective strategy to prevent deadlock is lock ordering, where a strict order is defined for acquiring locks on resources. Processes are required to acquire locks in this pre-determined order, which prevents cyclic dependencies. By ensuring that processes do not hold an outstanding request while waiting for additional locks, deadlock can be systematically avoided .

The OSI (Open Systems Interconnection) model facilitates network communication by dividing the process into seven distinct layers, each responsible for specific tasks that contribute to the overall process. The Physical layer transmits raw bits over a communication channel. The Data Link layer handles error detection and correction from the physical layer. The Network layer manages device addressing and routing of packets. The Transport layer ensures reliable data transfer with error checking. The Session layer controls dialogues between computers. The Presentation layer translates data formats for interoperability. Lastly, the Application layer provides network services to the user's software applications. This structured approach allows for standardized communication protocols and interfaces .

TCP (Transmission Control Protocol) and UDP (User Datagram Protocol) serve different purposes based on their design characteristics. TCP is a connection-oriented protocol that ensures reliable communication through error checking and acknowledgment of packets, making it suitable for applications where data integrity is critical, like file transfers and web browsing. However, this reliability comes at the cost of speed due to the overhead of establishing a connection and managing packet delivery. Conversely, UDP is a connectionless protocol that offers fast delivery by sending packets without acknowledgment. It is better suited for applications like video streaming and online gaming, where speed is prioritized over reliable packet delivery .

Kadane's Algorithm efficiently solves the maximum subarray sum problem by maintaining a running maximum sum of subarrays while iterating through the array. At each element, it decides whether to include the current element in the existing subarray or start a new subarray from the current element, based on which option has the larger sum. This decision is computed as max(current element, current element + max subarray sum ending at the previous element). The algorithm runs in O(n) time complexity, thus providing an efficient solution to the problem .

Decorators in Python are used to modify or enhance functions without changing their core structure, thereby increasing flexibility and reusability. By wrapping a function, decorators allow behavior modification before and after the core function executes. This can be used for tasks such as logging, access control, and performance measurement. Because decorators can be applied to any function that follows the specific input-output interface, developers can reuse them across different parts of an application without rewriting code, adhering to the DRY (Don't Repeat Yourself) principle .