Concurrency, Nondeterminism, and Race Conditions

• Explain the difference between the illusion of parallelism (time-slicing) and true parallelism.
• Empirically demonstrate the nondeterministic nature of the OS process scheduler.
• Identify and reproduce a Race Condition in a controlled environment.
• Utilize mutual exclusion mechanisms (pthread_mutex) to protect critical sections.
• Apply dynamic analysis tools (ThreadSanitizer) to detect invisible concurrency bugs.

• Google Sanitizers: https://github.com/google/sanitizers
• pthreads: https://man7.org/linux/man-pages/man7/pthreads.7.html

• GitHub Copilot: https://github.com/copilot (create an account using your @info.uaic.ro email address)
• WSL: https://learn.microsoft.com/en-us/windows/wsl/install or a Linux distribution
• VirtualBox (optional): https://www.virtualbox.org
• Docker / Docker Desktop (optional): https://www.docker.com
• Visual Studio Code: https://code.visualstudio.com/ (or any other IDE; eg. JetBrains)


• To access the internal development server, please follow the instructions here: link (Credits: Computer Networks Course, Conf. Dr. Andrei Panu)

Network Communication & The Client-Server Model

• Implement a basic TCP client–server architecture using the Socket API.
• Differentiate between an iterative (blocking) server and a concurrent (threaded) server.
• Observe head-of-line blocking, where one slow client affects all other clients.
• Apply thread creation techniques (from Lab 1) to handle network connections dynamically.
• Analyze the fundamental trade-off between resource consumption (threads) and responsiveness (latency).
• Implement a thread-safe task queue to support concurrency and handle multiple client/worker connections.
• Design an application-layer protocol over TCP sockets.
• Compare TCP, UDP, and QUIC in terms of reliability, ordering, congestion control, and latency.

• Linux udp(7) man page: https://man7.org/linux/man-pages/man7/udp.7.html
• Linux tcp(7) man page: https://man7.org/linux/man-pages/man7/tcp.7.html
• QUIC Working Group (IETF): https://quicwg.org/
• Cloudflare "The Road to QUIC": https://blog.cloudflare.com/the-road-to-quic/
• quiche (Cloudflare, Rust/C): https://github.com/cloudflare/quiche
• ngtcp2 (C): https://github.com/ngtcp2/ngtcp2
• msquic (Microsoft, C): https://github.com/microsoft/msquic
• aioquic (Python): https://github.com/aiortc/aioquic
• RFC 9000 -- QUIC Transport Protocol: https://www.rfc-editor.org/rfc/rfc9001
• RFC 9001 -- Using TLS to Secure QUIC: https://www.rfc-editor.org/rfc/rfc9001
• RFC 9114 -- HTTP/3 (over QUIC): https://www.rfc-editor.org/rfc/rfc9114
• RFC 768 -- UDP specification (the entire spec is 3 pages): https://www.rfc-editor.org/rfc/rfc768
• RFC 9293 -- TCP specification (2022, replaces RFC 793): https://www.rfc-editor.org/rfc/rfc9293
• Beej's Guide to Network Programming (practical C examples): https://beej.us/guide/bgnet/

Mini-Distributed System – Architecture, Scalability & Security

• Offensive Security (Red Team): Exploit memory vulnerabilities (Buffer Overflow) using Python.
• Defensive Security (Blue Team): Implement secure coding practices, Input Sanitization, and Challenge-Response Authentication.
• Infrastructure: Simulate a real network (you may use VMs, Dockers).
• Extensions: Create additional extensions for your Client-Coordinator-Worker infrastructure.

• Build: Implement the functional (but naive) Coordinator-Worker system.
• Break: The "Red Team" session. Crash the system using exploits.
• Fix: The "Blue Team" session. Hardening, Authentication, and Fault Tolerance.
• Enhance Functionality: Implement extension