Fault vs Failure

LangChain and LangGraph are complementary frameworks in the LangChain ecosystem: LangChain offers fast, linear pipeline composition via LCEL, while LangGraph provides a graph‑based runtime with persistent state, loops, branching, and human‑in‑the‑loop capabilities.

• LangChain’s modular components (models, prompts, memory, tools) are combined with the pipe operator | to build simple to moderate linear workflows such as retrieve‑summarize‑answer.
• LangGraph introduces three primitives—State, Nodes, and Edges—enabling cycles, conditional branches, multi‑agent coordination, and checkpoint‑driven fault tolerance.
• State management differs: LangChain relies on chain‑scoped Memory; LangGraph uses a global State object with checkpointers that support time‑travel debugging and rollback.
• Decision guidance: choose LangChain for straightforward RAG or Q&A bots; adopt LangGraph when you need loops, branching, persistent state, or production‑grade resilience.

$\text{State}_{t+1} = \text{merge}\big(\text{State}_t,\ \bigcup_{n \in \text{Nodes}_t} f_n(\text{State}_t)\big)$

In $R(A,B,C)$ with functional dependencies $A\rightarrow B$ and $B\rightarrow A$, neither single attribute determines all three attributes, so $A$ and $B$ are not keys; the minimal candidate keys are $\{A,C\}$ and $\{B,C\}$.

• $A^{+}= \{A,B\}$ and $B^{+}= \{A,B\}$, both missing $C$ → not superkeys.
• Adding $C$ yields $(AC)^{+}= (BC)^{+}= \{A,B,C\}$, making $AC$ and $BC$ candidate keys.
• Mutual determination ($A\leftrightarrow B$) does not imply key status without covering the whole schema.
• A common exam trap is assuming $A$ or $B$ are keys because they determine each other.
• Heuristic: any attribute not derivable from others (here $C$) must appear in every candidate key.

User-level threads vs kernel-level threads differ mainly in who manages/schedules them and how they behave when a thread blocks or runs on multiple CPUs.

• User-level threads are scheduled by a runtime library, so creation and switching are cheap, but the kernel only sees the whole process.
• Kernel-level threads are scheduled by the OS, incurring more overhead but allowing each thread to block independently and run on separate CPUs.
• Prefer user-level threads for many short, non‑blocking tasks; prefer kernel-level threads for I/O‑bound or multicore workloads needing true parallelism.