аксіологічна

світоглядна

критична

виховна

They both use the Linux kernel

They both use a virtual machine to run apps to maximize device compatibility

They are layered OS with different frameworks for developers

They are optimized for energy consumption to run on mobile devices

TCP Sockets, because they establish a persistent, reliable stream that guarantees no point-cloud data is lost or corrupted in transit between processes.

Signals, because they act as asynchronous hardware-level interrupts that can instantly pass the complex point cloud variables to Process B with zero latency.

POSIX Shared Memory, because it allows both processes to map the same physical memory pages into their own address spaces, enabling direct exchange of large amounts of information.

POSIX Shared Memory, because it provides built-in, automatic synchronization mechanisms that effectively manage the speed gap between the real-time producer and consumer.

It intercepts Windows API requests (using recreated DLLs) and translates them on the fly into native Linux system calls, without simulating a physical motherboard or processor.

It dynamically recompiles the Windows executable (.exe) into a native Linux binary (ELF format) prior to launch, eliminating runtime overhead.

It passes the application's x86 processor instructions directly to the GPU for parallel calculation, bypassing the main Linux scheduler entirely.

It establishes a lightweight virtual machine that boots a localized Windows kernel alongside the Linux kernel to process instructions directly.

The order of all three messages is completely unpredictable due to the concurrent nature of operating systems.

The "Parent starting" message will print first, followed by Child 1, and then Child 2, because they are spawned in that exact order in the code.

The "Parent starting" message will always print first, but the order of Child 1 and Child 2's messages is unpredictable.

The "Parent starting" message will print first, followed by Child 2, and then Child 1, because the parent explicitly calls waitpid on Child 2 first.

It configures the semaphore as a mutual exclusion lock (mutex). Process A will immediately acquire the lock, decrement the value to -1, and read the memory.

It instructs the operating system to ignore any previous instances of the /data_ready semaphore and overwrite them with a zeroed-out memory block to prevent previous instances of the semaphore from causing unexpected behavior.

It initializes the semaphore in an inherently "locked" state. Process A will immediately block at sem_wait and suspend execution until Process B calls sem_post to increment the counter.

It specifies the maximum number of child processes allowed to attach to this semaphore. Setting it to 0 enforces a strictly single-process environment.

The parent process would hang infinitely at the wait() call because Child 1 never officially terminates, causing a deadlock in the execution.

The program would result in 4 processes in total because Child 1 would continue executing and spawn its own child process.

The program would result in 3 total processes because Child 1 would just exit normally at the end of the main() function after printing.

The program would crash because a child process cannot execute a fork() system call.

The parent would wait for both Child 1 and Child 2 simultaneously and store both of their exit codes in the status variable.

The parent would suspend until any child terminates, potentially reaping Child 1 first and incorrectly reporting its exit code as Child 2's.

The parent would ignore all child processes and immediately continue executing the rest of the code because of the -1 argument to waitpid.

The waitpid call would fail and return an error because -1 is not a valid Process ID.

It replaced the highly inefficient translation of DirectX calls to OpenGL with a direct translation to Vulkan, a modern, low-level API that maps much more efficiently to the hardware.

It separated the graphical rendering pipeline from the main process, running the game's DirectX instructions inside a hardware-accelerated virtual machine.

It bypassed the Linux kernel's graphics stack entirely, allowing users to install and run proprietary Microsoft DirectX drivers natively on Linux.

It implemented an automated translation layer that converts all proprietary DirectX code into AMD's legacy Mantle API, forcing universal hardware compatibility.