localhost lab

platform vs os.uname Inventory: Localhost Lab

Hands-on platform.platform vs os.uname host inventory lab: real ops/s plus cache notes, measured on Linux localhost today in this hands-on lab for SREs.

uuid.uuid4 vs uuid.uuid1: Localhost Lab

Hands-on uuid.uuid4 vs uuid.uuid1 ID generation lab: real ops/s plus version/node checks, measured on Linux localhost today in this hands-on lab for SREs.

signal vs threading.Event Wakeup: Localhost Lab

Hands-on signal SIGUSR1 vs threading.Event wakeup lab: real p50 latency in microseconds, measured on Linux localhost today in this hands-on lab for SREs.

cmath vs math.hypot Magnitudes: Localhost Lab

Hands-on cmath vs math.hypot magnitude ops lab: real ops/s for abs, polar, and phase, measured on Linux localhost today in this hands-on lab for SREs.

tracemalloc Snapshot Cost: Localhost Lab

dataclasses.asdict vs vars: Localhost Lab

logging.Formatter vs f-string: Localhost Lab

xml.etree vs json Nested Records: Localhost Lab

random.choices vs sample vs choice: Localhost Lab

statistics.quantiles vs Manual Percentile: Localhost Lab

Path.glob vs listdir+fnmatch: Localhost Lab

Hands-on Path.glob vs os.listdir+fnmatch.filter one-dir lab: real matches/s on *.py files, measured on Linux localhost today in this hands-on lab for SREs.

tomllib vs JSON Config Load: Localhost Lab

Hands-on tomllib vs json.load nested config lab: real loads/s (stdlib TOML read-only), measured on Linux localhost today in this hands-on lab for SREs.

zoneinfo vs Fixed UTC Offset: Localhost Lab

Hands-on zoneinfo.ZoneInfo vs fixed UTC offset conversions: real conv/s on many datetimes, measured on Linux localhost today in this hands-on lab for SREs.

dataclasses.replace vs Manual Copy: Localhost Lab

Hands-on dataclasses.replace vs manual copy/new-instance lab: real ops/s updating one field, measured on Linux localhost in this hands-on lab for SREs.

islice vs list Slice Windows: Localhost Lab

Hands-on itertools.islice vs list slice window lab: real ops/s taking ranges from sequences, measured on Linux localhost in this hands-on lab for SREs.

heapq.merge vs sorted(chain): Localhost Lab

Hands-on heapq.merge vs sorted(chain) multi-way merge: real records/s on pre-sorted lists, measured on Linux localhost today in this hands-on lab for SREs.

mmap Write vs pwrite Region: Localhost Lab

Hands-on mmap MAP_SHARED write+msync vs pwrite region update: real MB/s with durability labels, measured on Linux localhost in this hands-on lab for SREs.

os.stat vs Path.stat vs lstat: Localhost Lab

Hands-on os.stat vs pathlib.Path.stat vs os.lstat: real metadata stats/s on many regular files, measured on Linux localhost in this hands-on lab for SREs.

html.escape vs Manual Replace: Localhost Lab

A hands-on localhost lab comparing html.escape with chained str.replace for safe HTML escaping.

configparser vs JSON Config Load: Localhost Lab

A hands-on localhost lab comparing configparser and json.load for nested application configuration.

difflib vs set Ops Similarity: Localhost Lab

Hands-on difflib.SequenceMatcher vs set Jaccard token similarity: real ops/s on token lists, measured on Linux localhost in this hands-on lab for SREs.

zlib vs gzip.compress Same Level: Localhost Lab

Hands-on zlib.compress vs gzip.compress same-level (6) stdlib bake-off: real MB/s and sizes, measured on Linux localhost in this hands-on lab for SREs.

methodcaller vs getattr Call: Localhost Lab

Hands-on operator.methodcaller vs getattr vs direct: real calls/s invoking methods on many objects, measured on Linux localhost today in this lab for SREs.

groupby vs Manual Group: Localhost Lab

Hands-on itertools.groupby vs manual dict-of-lists: real records/s grouping pre-sorted key runs, measured on Linux localhost today in this lab for SREs.

argparse vs sys.argv: Localhost Lab

Hands-on argparse vs manual sys.argv parse lab: real parses/s for small CLI flag sets on fixed argv, measured on Linux localhost in this lab for SREs.

hmac.compare_digest vs ==: Localhost Lab

Hands-on hmac.compare_digest vs bytes == verify lab: real ops/s plus HMAC-SHA256 construct costs, measured on Linux localhost in this eng lab for SREs.

subprocess.run vs Popen: Localhost Lab

A measured Linux localhost lab comparing subprocess.run with Popen and communicate for tiny process spawns and captured stdout.

fnmatch vs re Name Filter: Localhost Lab

Hands-on fnmatch.filter vs re.compile name-list filtering measured on Linux localhost.

as_completed vs wait: Futures Localhost Lab

Hands-on concurrent.futures as_completed vs wait lab with measured completion timing on Linux localhost.

tarfile vs zipfile Create+Extract: Localhost Lab

Hands-on tarfile vs zipfile create+extract lab: real MB/s on a mixed small-file fixture (uncompressed tar vs zip), measured on Linux localhost for SREs.

scandir vs listdir vs iterdir: Localhost Lab

Hands-on os.scandir vs listdir vs Path.iterdir lab: real entries/s for names and is_file on a synthetic tree, measured on Linux localhost (lab) for SREs.

textwrap.fill vs Manual Wrap: Localhost Lab

secrets vs urandom vs getrandbits: Localhost Lab

BytesIO vs SpooledTemporaryFile: Localhost Lab

BytesIO vs SpooledTemporaryFile growth throughput across the spool threshold, compared with NamedTemporaryFile on Linux localhost.

WeakValueDictionary vs dict Cache: Localhost Lab

WeakValueDictionary vs strong dict cache: insert and lookup throughput, plus GC-driven drop on Linux localhost.

Decimal vs float Sum: Localhost Lab

Hands-on Decimal vs float cumulative sum lab: real ops/s plus a simple accuracy note (not financial advice), measured on Linux localhost (lab) for SREs.

threading.local vs tid-dict: Localhost Lab

Hands-on threading.local vs tid-keyed dict vs module-global lab: real ops/s for per-thread state access patterns, measured on Linux localhost for SREs.

Event vs Condition vs Barrier: Localhost Lab

asyncio.gather vs TaskGroup: Localhost Lab

mmap vs read Byte-Sum Scan: Localhost Lab

Hands-on mmap vs read vs chunked sequential byte-sum scan lab: real MB/s on a generated fixture (not page-touch), measured on Linux localhost for SREs.

ProcessPool vs Sequential CPU: Localhost Lab

Hands-on ProcessPoolExecutor vs sequential CPU lab: real wall time and worker sweep on pure-Python sum-of-squares, measured on Linux localhost for SREs.

pickle vs json: Round-trip Lab

Hands-on pickle vs json local round-trip lab: real throughput and size for modest dict/list payloads (trusted data), measured on Linux localhost (lab).

csv.reader vs split: Parse Lab

Hands-on csv.reader vs str.split vs DictReader lab: real rows/s on a quoted-field CSV fixture (pandas-free parse), measured on Linux localhost for SREs.

hashlib md5 vs blake2b: Checksum Lab

Hands-on hashlib md5 vs blake2b vs sha1/sha256 lab: real MB/s checksum throughput for content-integrity hashing, measured on Linux localhost for SREs.

glob vs rglob vs os.walk: Listing Lab

Hands-on glob.glob vs Path.rglob vs os.walk lab: real files/s for recursive file listing on a modest fixture tree, measured on Linux localhost for SREs.

json.dumps Compact vs Indent Lab

Hands-on json.dumps separators vs indent lab: real time and byte-size tradeoffs for compact vs pretty JSON encoding, measured on Linux localhost (lab).

shutil.copyfile vs Manual Copy Lab

Hands-on shutil.copyfile vs manual file copy lab: real MB/s versus open/read/write and Path.read_bytes on local disk, measured on Linux localhost (lab).

str.translate vs replace: Scrub Lab

Hands-on str.translate vs replace vs re.sub lab: real ops/s for character delete and map scrubbing on mid-size strings, measured on Linux localhost (lab).

setdefault vs defaultdict: Insert Lab

Hands-on setdefault vs if-not-in vs defaultdict lab: real ops/s for list-append and counter default insert patterns, measured on Linux localhost (lab).

zip vs Index Pairing: Loop Lab

functools.partial vs lambda: Call Lab

statistics vs Manual mean: Stdlib Lab

Hands-on statistics vs manual mean/median/stdev lab: real ops/s for fmean, sum/len, and sorted mid versus the stdlib, measured on Linux localhost (lab).

bisect vs Linear vs set: Lookup Lab

Hands-on bisect.insort vs linear vs set lab: real ops/s for mixed sorted-list insert and membership lookup workloads, measured on Linux localhost (lab).

itertools.chain vs Flatten Lab

nlargest vs sorted[:k]: Top-k Lab

attrgetter vs getattr: Hot Loop Lab

Hands-on operator.attrgetter vs builtin getattr lab: real ops/s for extract and sort by attribute versus direct access, measured on Linux localhost only.

Counter vs dict: Tally Lab

Hands-on collections.Counter vs dict tally lab: real ops/s for Counter.update, dict get-add, and defaultdict(int) token counting on Linux localhost (lab).

bytes vs bytearray: Mutate/Copy Lab

Hands-on bytes vs bytearray lab: real ops/s for append/extend/slice/copy and when copy dominates over mutate, benchmarked on Linux localhost for SREs.

frozenset vs set: Membership Lab

Hands-on frozenset vs set vs list membership lab: real ops/s for build-once lookup-heavy paths and dict keys, benchmarked on Linux localhost for SREs.

Enum vs Constants: Access Cost Lab

contextlib vs try/finally: Cleanup Lab

itemgetter vs lambda: Sort Key Lab

Hands-on operator.itemgetter vs lambda sort-key lab: real ops/s for extract and list.sort on tuples, dicts, and objects, measured on Linux localhost (lab).

ThreadPoolExecutor vs Sequential: I/O Lab

Hands-on ThreadPoolExecutor vs sequential lab: real wall-time speedup for I/O sleep workloads plus GIL CPU contrast, measured on Linux localhost (lab).

perf_counter vs time vs monotonic Lab

A hands-on Linux localhost lab measuring Python clock-call overhead, observed resolution, and safe choices for elapsed-time measurements.

array.array vs list[int] vs bytes Lab

A hands-on Linux localhost lab comparing memory density and numeric throughput for list[int], array.array('i'), bytearray, and memoryview.

itertools vs Python loops Lab

Hands-on itertools vs pure Python loops lab: chain, islice, and accumulate vs equivalent for-loops with real ops/s, measured on Linux localhost (lab).

deque vs list: Queue FIFO Lab

Hands-on collections.deque vs list queue lab: real FIFO ops/s for append/popleft vs list.pop(0) at several prefill sizes on Linux localhost (eng lab).

struct.pack vs to_bytes vs memoryview Lab

Benchmarking fixed-record packing with struct.pack, Struct.pack_into, int.to_bytes, and memoryview on Linux localhost.

lru_cache hit vs miss: Cache Cost Lab

Real Linux localhost timings for functools.lru_cache hits, miss-and-insert calls, maxsize choices, and an uncached baseline.

logging vs print: Throughput Lab

Hands-on logging vs print throughput lab: real lines/s for StreamHandler, StringIO, and a disabled logger, measured on Linux localhost only (eng lab).

copy vs deepcopy vs manual: Shallow Copy Lab

Hands-on copy.copy vs deepcopy vs manual shallow lab: real ops/s on nested dicts and lists of several sizes, measured on Linux localhost only (eng lab).

string concat vs join vs StringIO: Build Lab

A hands-on localhost lab comparing +=, list+join, preallocated join, and StringIO for building strings at real sizes.

set vs frozenset vs list: Membership Lookup Lab

A hands-on localhost lab measuring set, frozenset, list, and dict-key membership across N, with the real crossover point.

pathlib vs os.path vs str: Path Ops Lab

A hands-on Linux localhost benchmark of pathlib and os.path for joins, filesystem checks, stats, and recursive scans.

sorted vs heapq vs bisect: Ordered Insert Lab

A hands-on Linux localhost benchmark comparing batch sorting, bisect.insort, and heapq as ordered data arrives.

TemporaryFile vs NamedTemporaryFile Delete Modes Lab

Hands-on tempfile modes lab: TemporaryFile vs NamedTemporaryFile delete True/False vs mkstemp unlink patterns with real measured ops/s on localhost box.

dataclass vs slots vs dict: Python Object Lab

Hands-on Python dataclass vs slots vs dict lab: instantiation and attribute ops/s plus RSS for classic, slots, dataclass, namedtuple, dict on localhost.

getaddrinfo DNS Resolve Cost Localhost Lab

Hands-on getaddrinfo cost lab: localhost vs numeric IP vs AI_NUMERICHOST, plus hosts/stub names with real p50/p95 µs. DNS sinkhole labeled honestly here.

Atomic Rename vs Overwrite: Config Write Lab

Hands-on atomic rename vs overwrite lab: tempfile+os.replace vs truncate-write with/without fsync. Real ops/s on localhost; crash-safety limits labeled.

uuid4 vs secrets Token Generation Rate Lab

Hands-on uuid.uuid4 vs secrets.token_hex/urlsafe vs os.urandom ops/s on localhost. Throughput only; uniqueness and collisions not measured in this lab.

base64 vs hex Encode/Decode Throughput Lab

Hands-on base64 vs hex encode/decode lab on 32MiB buffers with real MB/s measurements in both directions on localhost.

Python re vs str Methods: Text Scan Throughput Lab

Hands-on Python re vs str methods lab on a 32MiB localhost corpus: count, find, line prefix, case-insensitive, and email scans with real measured MB/s.

posix_fadvise SEQUENTIAL vs RANDOM: Read Hint Lab

Hands-on posix_fadvise SEQUENTIAL vs RANDOM vs NORMAL lab on localhost: cold and warm 256MiB reads after drop_caches with real measured p50 MB/s and RPS.

fork COW RSS vs spawn: Python Multiprocessing Lab

Hands-on fork COW vs multiprocessing spawn lab: PSS/Private_Dirty after fork and page dirtying, plus spawn start latency. Real numbers on the lab box.

json vs orjson vs msgpack: Python Serializer Lab

Hands-on Python json vs orjson vs msgpack lab: encode/decode MB/s on records, nested, and unicode payloads. Real p50 numbers measured on localhost box.

SHA-256 vs BLAKE2b vs xxHash: Hash Throughput Lab

Hands-on SHA-256 vs BLAKE2b vs xxHash hash throughput on 64MiB buffers (SHA-1/SHA3 labeled). Real MB/s with OpenSSL and xxHash versions on the lab box.

SQLite WAL vs DELETE Journal: Write Throughput Lab

Hands-on SQLite WAL vs DELETE vs OFF journal_mode lab: insert/update RPS (FULL/NORMAL sync), plus WAL checkpoint cost. Real p50 numbers on localhost box.

zstd vs gzip vs lz4: Compression Throughput Lab

Hands-on zstd vs gzip vs lz4 on 64MiB payloads (real /usr text, mixed, urandom). Measured compress/decompress MB/s and ratio at default levels. No Docker.

fsync vs fdatasync vs none: Durable Write Cost Lab

Hands-on fsync vs fdatasync vs none: per-write and every-N sync on 256B and 4KiB records. Real p50/p95 show about 100-200x durability tax on localhost

nice / ionice Lab: CPU Nice 19 Slowdown and Idle-Class Disk

Hands-on nice/ionice lab: victim nice19 under 6 hogs ~5.7× slower (p95 ~7.4s); ionice idle O_DIRECT read ~6.1× under writers. Real numbers, no Docker.

TCP_QUICKACK Lab: Delayed ACK, Set-Once, and the Reassert Trap

Hands-on TCP_QUICKACK lab: default QA=1 on loopback; WWR set-once ~18 µs; reassert QA=1 under Nagle p95 ~48 ms, OutSegs ~13×. Real numbers, no Docker.

Context-Switch Microbench: Pipe Ping-Pong Process vs Thread

Hands-on ctx-switch lab: process pipe RTT p50 3.2 us (~0.50M sw/s); thread pipe 2.85 us; Event 9.3 us; 6 hogs blow p95 to 19 us. Real numbers, no Docker.

Asyncio vs Threads: I/O Concurrency Lab with Real Numbers

Hands-on asyncio vs ThreadPool lab: sleep 58.7× vs 44×; delayed TCP 13.8× vs serial; fast-echo trap loses; CPU flat. Real localhost numbers, no Docker.

flock Contention Lab: Exclusive, Shared, and LOCK_NB Fail Rates

Hands-on flock lab: uncontended LOCK_EX p50 0.33 us; waiter ~50 ms hold; w8 p50 ~36 ms; LOCK_NB 99% fail; LOCK_SH ~6.7x wall. Real numbers, no Docker.

Stdout Buffering Lab: Line vs Full vs Unbuffered (Real Numbers)

Hands-on stdout buffering lab: full buffering maximizes throughput, while line and unbuffered modes restore live visibility on pipes.

ProcessPool vs ThreadPool: GIL CPU Lab with Real Numbers

Hands-on ProcessPool vs ThreadPool lab: pure-Python threads lose to processes, hashlib threads help, and sleep I/O favors threads.

epoll vs select Toy: Ready-Wait Latency and the FD_SETSIZE Cliff

Hands-on epoll vs select toy: ready-wait flat ~3.5 µs (8→900 FDs); select scales 4.6→16.9 µs then hits fd≥1024 cliff. Python numbers, no Docker.

sendfile vs Userspace Copy: Localhost TCP File Serve Lab

Hands-on sendfile vs read+sendall lab: 256 MiB p50 4.41 vs 2.34 GB/s (~1.9×); copy collapses at 4 KiB. Warm localhost TCP measured, no Docker.

mmap vs read (+ O_DIRECT): Localhost Sequential Scan Lab

Hands-on mmap vs buffered read lab: 256 MiB p50 11.5 vs 5.4 GB/s; O_DIRECT ~0.9 GB/s warm-cache bypass. Fake endpoint-only GB/s disclosed. No Docker.

Nginx Gzip On vs Off: Localhost Wire Size and RPS Lab

Hands-on nginx gzip on/off lab: HTML ~107x smaller at level 1; JSON RPS ~1987 off vs ~1031 l1 vs ~563 l6 on localhost. Measured numbers, no Docker.

Pipe vs Tmpfile IPC: Localhost Throughput and RTT Lab

Hands-on pipe vs tmpfile IPC lab: 5.32 vs 1.51 GB/s bulk (fsync 0.57); 64 B RTT p50 3.3 us vs 70 us vs 289 us. Localhost measured, no Docker.

TCP_NODELAY vs Nagle: Localhost Lab with Real Numbers

Hands-on TCP_NODELAY vs Nagle: 1-byte reuse 124k vs 73k RPS; 32×16B writes favor Nagle (~1.7× fewer OutSegs). Delayed-ACK mean trap on localhost.