Agents & Tool Calling
What an agent adds on top of a model, how to write tool contracts it cannot misread, and where the loop must stop.
What an agent adds on top of a model, how to write tool contracts it cannot misread, and where the loop must stop.
ARP and NDP neighbour resolution, proxy and gratuitous ARP, 802.1Q access and trunk ports, and where inter-VLAN routing happens.
OAuth 2.1, OIDC, RBAC and ABAC: proving identity and deciding what it may do.
Regular and context-free languages: the machines that recognise them and the limits of each.
RTT, bandwidth, BDP, jitter, loss and tail latency: the arithmetic that explains why a fast link still feels slow.
GraphQL and REST backends for frontends: shaping one API per client without leaking it into the domain.
Technology selection and the architect path: the scope, trade-offs and communication the next role expects.
X.509 fields, SAN matching, chain building and trust stores: proving that a public key belongs to a name.
ACME, private CAs, rotation and inventory: issuing and replacing certificates without an outage.
How much work an algorithm does as its input grows, and how that estimate picks the implementation before you measure.
Turing machines and the halting problem: what no program can decide, and why.
P, NP and NP-hard: what a problem class says about the algorithm you can expect.
cwnd, slow start, AIMD, CUBIC, BBR, ECN and bufferbloat: how a sender guesses a network it cannot see.
Raft and Paxos: how replicas agree on one order, and the failures each protocol tolerates.
Strategic and tactical design: bounded contexts, aggregates and the model that survives a rewrite.
Turning a notebook into a parameterized and testable script: arguments and config, logging and exit codes, atomic writes, idempotent runs, validation and scheduling.
Header bytes per layer, the 1500-byte budget, MSS derivation, fragmentation and PMTUD under tunnel overhead.
Playwright and Cypress: driving a real browser, and the flakiness that comes with it.
GDPR and privacy engineering: the data minimisation and retention rules a system has to encode.
Ethernet framing, MAC learning, flooding, STP, link aggregation and duplex: how a switch moves frames inside one broadcast domain.
CQRS and event sourcing: the read/write split, the event log and the consistency it buys.
A symptom catalogue that maps each network failure to its layer, decisive evidence and first action.
Ext4, ZFS and journaling: how a file survives a crash and what fsync actually promises.
Shortest paths and minimum spanning trees: which algorithm fits which graph, and where the complexity moves.
Adjacency matrices, adjacency lists, topological sort and union-find: how a graph is stored decides which algorithm is cheap.
CPU instruction sets, the storage hierarchy and network hardware: the latency numbers every design inherits.
How HTTP semantics stay stable while framing, multiplexing and the wire move from HTTP/1.1 to h2 and h3.
epoll, io_uring and zero-copy: the readiness and completion models behind a network server.
Read ICMP error and probe traffic, diagnose PMTUD black holes, and reason about NAT mappings, conntrack timeouts and hairpin paths.
B+ tree indexes and execution plans: why a query is slow and which index changes it.
Testcontainers and API mocks: testing the seam between your code and a real dependency.
Read any CIDR, derive subnet boundaries, and allocate non-overlapping IPv4 and IPv6 prefixes for sites, VLANs and containers.
MVC, clean architecture and hexagonal architecture: the dependency rule and where each boundary pays off.
Arrays, linked lists, stacks, queues and hash tables: the storage trade-offs behind every collection API.
Virtual memory, paging and segmentation: the address space, the page table and the cost of a miss.
Service discovery, configuration and API gateways: the operational cost of splitting a system.
MIT, Apache 2.0 and GPL: what each licence permits, requires and forbids.
The seven-layer and four-layer models as a diagnostic tool: PDU names, encapsulation order and the layer that owns a failure.
Splitting RTT hop by hop, separating queueing from loss, spotting asymmetry, and probing the path MTU.
k6 and JMeter: load models, thresholds and the difference between a benchmark and a capacity test.
AES, RSA, hashes, MACs and KDFs: the primitives and the parameters that keep them sound.
Scheduling and context switching: what the OS shares between execution units and what it does not.
Streams, TLS 1.3 integration, 0-RTT, connection IDs and loss recovery: reliability moved into user space over UDP.
TF-IDF and BM25: the scoring functions behind a search result order.
WebSocket, SSE and long polling: upgrade, frames, heartbeats, reconnect, backpressure and the proxy timeouts that break them.
CRL, OCSP, stapling and CT logs: proving a certificate is still trustworthy after it was issued.
Read a routing table, choose between static, OSPF and BGP, and debug prefix propagation and route selection across autonomous systems.
When to model a call as a remote procedure, and how protobuf contracts, deadlines, trailers and streaming stay safe under retry.
Quicksort, merge sort and binary search: the comparison model, stability, and when the input shape changes the right answer.
SBOM, Sigstore, Snyk and Dependabot: knowing what a build contains and whether it can be trusted.
Handshake, the eleven-state machine, byte sequencing, retransmission, flow control and the TIME_WAIT tail of a close.
TLS 1.3 handshake, record layer, resumption and 0-RTT: the session a client and server agree on.
ACID, MVCC and isolation levels: what a transaction guarantees and what it costs.
Binary trees, red-black trees, B-trees, B+ trees and heaps: the balance and fan-out choices behind ordered data.
A layer-by-layer decision tree that turns refused, timeout, reset and slow into falsifiable hypotheses with the cheapest evidence.
Choose an encapsulation and key exchange, budget the MTU cost, and tell a handshake failure apart from a routing or policy failure.
Datagram semantics, the eight-byte header, checksum coverage and the amplification risk of a connectionless protocol.
What a unit test isolates, the assertion libraries that express it, and where Vitest/Jest fits.
OWASP Top 10, XSS, CSRF and WAF: the browser threat model and the controls that reduce it.
802.11 framing, CSMA/CA, channels and bands, roaming, WPA2/WPA3 and interference: why wireless throughput is a shared-medium budget.