Demerzel

Concepts imported from YouTube curation: https://youtube.com/playlist?list=PLjvTuBcskqZE1oL2CBb-DQTWb5r1fSV2m&si=pDOQtngbYoY9IVNg

Concepts imported from YouTube curation: https://www.youtube.com/playlist?list=PL_D1rGgPr31PRnmMQtxPkNVhMJBU8XYRS

Concepts imported from YouTube curation: https://www.youtube.com/playlist?list=PL-60inPtTWS6nZ8row50vMkpQS3W1Qejj

Concepts imported from YouTube curation: https://www.youtube.com/playlist?list=PL-uRhZ_p-BM4ajpQvdU_AVUxYL3m6RvkU

Concepts imported from YouTube curation: https://youtube.com/playlist?list=PLv2BtOtLblH24tRyATJ0KA9ivJ-WDNPei&si=-P_lXa5U9R0V6X3C

Concepts imported from YouTube curation: https://youtube.com/playlist?list=PLv2BtOtLblH0mJdMpyqCW5WthBAXVW0HC&si=TzMjFKh7fPqSXPq_

Concepts imported from YouTube curation: https://www.youtube.com/playlist?list=PL-uRhZ_p-BM52EbMG1NR1ZfG9tEvcxE4u

Concepts imported from YouTube curation: https://www.youtube.com/playlist?list=PL040D2F9406691BE6

Concepts imported from YouTube curation: https://youtube.com/playlist?list=PLexa_cotS5sGJ9IcomQQ03T9GGKCNWHPY&si=0INe6Q2RZhz7sko1

How to connect real-world sensors to a microcontroller and trust what they tell you. You will read analog sensors through the ADC with a properly chosen reference voltage, calibrate and linearize their output, talk to digital sensors over I2C, SPI, and 1-Wire, and handle the electrical realities of pull-ups, level shifting, and noise. You will also structure firmware around interrupts, timers, and non-blocking loops, and budget power for battery operation.

How Lambda actually runs your code: the handler contract, the three invocation paths and their retry semantics, the execution-environment lifecycle behind cold starts, and the levers (memory, concurrency, provisioned capacity, SnapStart) that control latency and cost. Students finish able to design idempotent, least-privilege functions, package and observe them properly, and — just as important — recognize the workloads where Lambda is the wrong tool.

You will be able to build a Bayesian model end to end: encode belief as a prior, combine it with a likelihood into a posterior, and use the evidence for model comparison with Bayes factors. You will work conjugate models (beta-binomial, normal-normal) by hand, choose weakly informative priors deliberately, summarize uncertainty with credible intervals and posterior predictive checks, and pool grouped data with hierarchical models. Finally you will understand why the normalizing constant makes most real posteriors intractable, and how MCMC and variational inference answer that problem from two different directions.

How open networks of mutually distrusting machines agree on a single transaction history. You will be able to explain why Proof of Work plus the longest-chain rule solves permissionless consensus, quantify why its finality is only probabilistic, analyze the economics of a 51% attack, and trace how Proof of Stake systems like Ethereum's Gasper bolt a BFT finality gadget (Casper FFG) onto a fork-choice rule (LMD-GHOST) with slashing as the enforcement mechanism. You will finish able to evaluate the tradeoffs among Nakamoto, delegated, and nominated designs.

How distributed systems reach agreement when some participants can lie, equivocate, or behave arbitrarily. You will be able to state why 3f+1 replicas are required, explain what FLP forbids and how partial synchrony escapes it, walk through PBFT's three-phase commit and view change, and compare modern BFT protocols (Tendermint, HotStuff) with crash-fault-tolerant consensus like Raft and Paxos.

How history-based CAD actually works: constraining 2D sketches until they have zero degrees of freedom, growing solids with extrudes, revolves, sweeps, and lofts, and structuring the feature tree so edits regenerate cleanly. A student who finishes can build a fully parametric part driven by named equations and configurations, mate parts into an assembly, explain why a careless edit breaks downstream features (the topological naming problem), and judge when direct modeling is the better tool.

You will learn why a pinhole conjugate to the focal plane rejects out-of-focus light, and how that single trick turns a fluorescence microscope into an optical sectioning instrument. You will be able to choose between point-scanning and spinning-disk architectures, set pinhole size in Airy units, pick filters or spectral detection, and tune detector gain and offset for the photon budget you actually have. You will acquire Nyquist-sampled z-stacks, reconstruct them in 3D, and control photobleaching and phototoxicity in live cells. Finally you will separate overlapping dyes by linear unmixing, quantify colocalization defensibly, and place confocal correctly next to widefield deconvolution and super-resolution methods.

Trace CRISPR from a bacterial adaptive-immune system to the clinical genome editors used today. You will learn how Cas9 finds a target through PAM recognition and guide-RNA base pairing, what the cell actually does with the resulting break (NHEJ indels versus HDR knock-in), and why off-target editing drove the shift to high-fidelity nucleases and break-free editors. The path finishes with base editing, prime editing, LNP and AAV delivery, and the approved therapies that have shipped.

From the ndarray up through DataFrames, the modern columnar stack (Arrow, Polars, DuckDB, FireDucks), and visualization that survives 100 million points, to scikit-learn modeling discipline, PyTorch training, and graph analytics with large-graph rendering. A student who finishes can load, clean, explore, and model real datasets, explain why each tool in the 2026 stack is fast, and avoid the classic evaluation traps: leakage, overfitting, and misleading metrics.

Master ordinary differential equations from first principles: classify equations, solve first-order equations by separation, integrating factors, and exactness, then conquer second-order linear equations, damping, resonance, and Laplace-transform methods. Finish with systems of ODEs via eigenvalues, phase-plane stability analysis, numerical solvers and their stiffness limits, and the separation-of-variables bridge to partial differential equations.

Build production-grade HTTP APIs with Django REST framework. You will master the serializer layer (declaration, model introspection, validation), the view stack from APIView through generics, ViewSets, and routers, and the policy layer of authentication, permissions, and throttling. You finish able to paginate, filter, version, and render responses correctly, eliminate N+1 query patterns with select_related and prefetch_related, and prove it all with APIClient tests.

How Docker actually wires containers together: network namespaces and veth pairs, the bridge drivers and their embedded DNS, the iptables/NAT machinery behind published ports, and the host, none, macvlan, and VXLAN-based overlay modes. Finishers can predict which containers can reach which, explain why a port is reachable (or not) from the host, and debug real connectivity and MTU problems with nsenter and tcpdump.

You will learn to measure an enzyme's initial rate correctly, derive the Michaelis-Menten equation from the steady-state assumption, and read Km, Vmax, kcat and kcat/Km as physically meaningful quantities rather than curve-fit outputs. You will diagnose competitive, uncompetitive and mixed inhibition from how each constant shifts, handle irreversible inactivation, and describe cooperative allosteric enzymes with the Hill equation. You will also learn why Lineweaver-Burk survives only as a teaching and diagnostic device while parameters are fit by nonlinear regression, and how to design a pH-, temperature- and detection-controlled assay whose numbers are trustworthy.

You will learn to read a flow cytometry dot plot the way an immunologist does: what forward and side scatter physically measure, how to exclude debris, doublets, and dead cells before any marker is interpreted, and how to build a defensible hierarchical gating strategy. You will understand why spillover exists, how compensation and modern spectral unmixing correct it, and which control (unstained, single-stain, isotype, FMO) is actually allowed to set a gate boundary. You will finish able to justify every gate on a plot, validate it by backgating, judge whether a rare-event frequency is statistically real, and design a panel that keeps spillover spreading error off your dimmest marker.

Build Gaussian mixture models from first principles: the latent-variable view of a weighted sum of Gaussians, responsibilities as Bayesian posteriors, and the EM algorithm that fits the parameters with a proof of why each iteration can only improve the likelihood. You will know how covariance constraints (full, diagonal, tied, spherical) trade flexibility for parameter count, how to seed EM with k-means and defend against local optima and covariance collapse, how BIC/AIC choose the number of components, and where GMMs earn their keep — density estimation, soft clustering, and speaker/background modeling.

Design GraphQL schemas that survive contact with real clients: model a domain with object, scalar, enum, and input types; treat nullability as a deliberate contract; wire resolvers that avoid the N+1 trap with DataLoader; paginate with the connection spec; and evolve, secure, and federate the schema without ever shipping a v2.

You will learn how a piece of tissue becomes an interpretable stained slide: how formalin cross-links proteins and masks epitopes, how heat or enzyme retrieval reverses that masking, how blocking suppresses endogenous enzyme and nonspecific binding, and how antibody and detection chemistry convert a binding event into visible signal. You will be able to choose and titrate a primary antibody, pick a detection system and chromogen, design the control set that makes a stain interpretable, and read a multiplexed or fluorescent panel without being fooled by spectral bleed-through. You will finish able to score staining reproducibly (H-score, digital image analysis) and to diagnose weak, absent, or high-background results from the protocol step that caused them.

How Kubernetes turns declared desired state into running systems. You will understand the reconciliation model end to end: what a Pod actually is on a Linux host, how Deployments and StatefulSets manage workloads, how Services, Ingress, and the Gateway API route traffic, how the scheduler places Pods using requests and limits, and how RBAC, probes, autoscaling, and the CRD/operator pattern extend the cluster into a platform.

Master how LSTMs keep gradients alive across long sequences: the cell state and constant error carousel, the three gates that regulate it, and why plain RNNs fail under backpropagation through time. Build up to GRUs, bidirectional and stacked variants, sequence-to-sequence models with attention, and a clear-eyed picture of where recurrent models still beat transformers in 2026 — streaming, low-latency, and long-context regimes where linear-time recurrence matters.

How to draw samples from a probability distribution you can only evaluate up to a constant — the workhorse of Bayesian computation. You will understand why a Markov chain with the right stationary distribution turns into a sampler, derive the Metropolis-Hastings acceptance rule from detailed balance, tune proposals and diagnose mixing, run Gibbs updates from full conditionals, judge convergence with trace plots, effective sample size and R-hat, and understand why Hamiltonian Monte Carlo and NUTS dominate modern practice, including what divergences tell you about difficult posterior geometry.

How to split a system into independently deployable services and keep it correct when the network fails. You will be able to decompose a domain into bounded contexts, choose between synchronous and asynchronous communication, maintain data consistency without distributed transactions using sagas and the outbox pattern, contain failures with circuit breakers and bulkheads, trace requests across services, and argue honestly for a monolith when that is the better answer.

How Next.js's App Router renders React on the server by default and what that changes about data fetching, caching, and interactivity. You will be able to draw the server/client boundary deliberately, explain what the RSC payload is and how it streams, reason about the caching layers and when to revalidate them, and mutate data with Server Actions instead of hand-rolled API endpoints.

Learn to read NMR spectra the way a practicing chemist does: from the physics of nuclear spin and the pulsed FT experiment, through chemical shift, integration, and coupling patterns in 1H spectra, to 13C, DEPT, and the 2D experiments (COSY, HSQC, HMBC). By the end you can take a molecular formula plus a set of spectra and assemble a full structure, justifying every assignment.

You will learn to design oligonucleotide primers that amplify one intended locus and nothing else. Starting from base pairing and duplex thermodynamics, you will predict melting temperature with the nearest-neighbor model, balance GC content, length and 3' anchoring, and eliminate hairpins, self-dimers and primer-dimers before ordering. You will then check specificity computationally against a reference genome, place amplicons deliberately (including across exon junctions for RT-qPCR), validate amplification efficiency with a standard curve, and append tails and adapters for cloning and sequencing workflows.

You will learn how a peptide is built one residue at a time on an insoluble support, why Fmoc/tBu displaced Boc/Bzl as the default strategy, and how resin, linker, coupling reagent and protecting-group set are chosen together as an orthogonal system. You will be able to diagnose failed couplings, aggregation and epimerization, design a cleavage cocktail with the right scavengers for a given side-chain set, and purify and confirm the product by RP-HPLC and mass spectrometry. You will finish able to plan a route to peptides longer than stepwise SPPS can reach using native chemical ligation.

How to make a feedback loop behave: what each PID term actually does to the response, how to read a step test, and how to pick gains with Ziegler-Nichols, relay auto-tuning, or manual loop-shaping. Finishes with the production-hardening details that separate textbook PID from a controller you can ship: anti-windup, setpoint weighting, derivative filtering, discrete implementation, feedforward, and cascade control.

A ground-up path to mastering PETG on any FDM printer. You will understand why PETG behaves the way it does — its copolymer chemistry, hygroscopicity, and sticky melt — and turn that into a fully calibrated profile: temperatures, retraction, first layer, cooling, flow, and pressure advance. You finish able to diagnose stringing, over-adhesion, warping, and weak layers from first principles, and to handle fiber-filled variants and annealing safely.

A complete path from hydraulic braking physics to a finished, safely torqued and bedded-in brake job on a Gen 4 (2016-2022) Toyota Prius. You will understand why a hybrid's Electronically Controlled Brake system changes the service procedure — actuator shutdown, high-voltage precautions, scan-tool bleeding — and be able to measure rotors, retract pistons, replace pads and rotors front and rear, and bed the new friction material in correctly.

You will learn how an atomic model of a protein is produced from a purified sample: how crystals are grown through controlled supersaturation, how a crystal lattice diffracts X-rays according to Bragg's law, and how diffraction intensities relate to the electron density through the Fourier transform. You will understand why the phase problem exists and how molecular replacement, anomalous dispersion, and isomorphous replacement solve it. You will finish able to read a structure critically — resolution, R-free, B-factors, Ramachandran and clash outliers — and to judge when single-particle cryo-EM is the better experiment.

Learn to turn raw real-time PCR fluorescence traces into quantitative results you can defend. You will set baselines and thresholds correctly, read Cq values, build standard curves and derive amplification efficiency from the slope, choose between absolute and relative quantification, and apply the 2^-ddCt and Pfaffl models knowing exactly which efficiency assumption each one makes. You will also validate reference genes, use melt curves and control reactions to prove specificity and rule out genomic DNA, place variance in the right replicate layer, and report the whole experiment to MIQE standards.

A rigorous path through entanglement as real physics: you will build two-qubit state space from tensor products, learn the separability criterion and the Bell states, follow the EPR argument to Bell's inequality and the loophole-free experiments that settled it, and understand why none of it permits signaling. You finish with the working protocols entanglement enables today: teleportation, superdense coding, quantum key distribution, and entangling gates in quantum computers.

You will learn why a tiny fraction of scattered photons come back shifted in energy, and how that shift encodes a molecule's vibrational fingerprint. You will be able to predict which vibrations are Raman-active from polarizability and symmetry, read a Raman spectrum in wavenumbers, and explain every part of a real spectrometer from laser to notch filter to CCD. You will also understand the practical enemy of the technique, fluorescence background, and the modern enhancement strategies that beat Raman's intrinsic weakness: resonance Raman, SERS, TERS, CARS and stimulated Raman microscopy.

How React function components actually run: the render/commit split, how useState queues and batches updates, why hook call order is a hard rule, and how effects, refs, and memoization hook into the lifecycle. Finishes with the modern concurrency surface — StrictMode double-invocation, useTransition, useSyncExternalStore, and the Server/Client Component boundary — so you can reason about React 19-era behavior, not just recite the API.

You will learn to take a raw mass spectrum and work it back to a molecule. Starting from what the x-axis actually measures, you will identify the molecular ion, count carbons and halogens from isotope patterns, apply the nitrogen rule and rings-plus-double-bonds to constrain formulas, and rationalize fragments through alpha cleavage, McLafferty rearrangement, and characteristic neutral losses. You will then interpret accurate-mass data to assign a molecular formula, read multiply charged electrospray envelopes and deconvolute them, and interpret MS/MS product-ion spectra from GC-MS and LC-MS runs where retention time is a second dimension of evidence.

Master Redux as it is practiced today: a single store driven by pure reducers and immutable updates, written with Redux Toolkit's createSlice and configureStore rather than hand-rolled boilerplate. You will understand the dispatch pipeline deeply enough to write middleware, handle async work with createAsyncThunk, manage server state with RTK Query, debug with time travel, and — just as importantly — recognize the many apps where Redux is the wrong tool.

How Rust guarantees memory safety without a garbage collector. A student who finishes can explain ownership and move semantics, apply the aliasing-XOR-mutability rule, read and write lifetime annotations, choose the right smart pointer (Box, Rc, Arc, Weak), reach for interior mutability and Send/Sync correctly in concurrent code, and state the invariant contract that governs unsafe blocks.

You will learn to treat a sourdough starter as a controlled microbial ecosystem rather than a recipe ingredient. You will understand how wild yeasts and lactic acid bacteria establish a stable symbiosis, how competitive exclusion and falling pH select the final community, and how hydration, feeding ratio, flour choice, and temperature act as the levers that shift yeast-to-LAB balance and flavor. You will be able to read readiness signals quantitatively, store and revive a culture safely, and diagnose hooch, sluggishness, off-aromas, and genuine mold contamination from mechanism rather than folklore.

Learn to read what the database actually does with your query and to change it deliberately. You will interpret EXPLAIN and EXPLAIN ANALYZE output, understand how the cost-based optimizer uses statistics to pick scans, join algorithms, and join order, design indexes (composite, covering, partial, expression) that the planner will actually use, keep predicates sargable, and diagnose the classic performance killers: cardinality misestimates, N+1 query storms, and unprunable partitions.

The concepts inside today's frontier AI systems, from the transformer and its modern refinements (RoPE, mixture-of-experts, FlashAttention, KV caching) through training science (scaling laws, RLHF, DPO, LoRA, quantization) to inference and frontier directions: speculative decoding, RAG, reasoning models, diffusion, state-space models, and CLIP. Finish this curation and you can read a modern model card and know what every line means.

Master the mathematics and practice of frequency-domain analysis: build up from Fourier series to the continuous and discrete transforms, understand why the FFT made spectral analysis cheap, and learn the sampling, aliasing, leakage, and windowing pitfalls that corrupt real measurements. Finish by seeing the same machinery at work in audio equalization, JPEG compression, MRI image reconstruction, and infrared spectroscopy.

Master the mood French uses when a clause reports will, emotion, doubt, or judgment rather than plain fact. You will form the present subjunctive for regular, two-stem, and irregular verbs, recognize every major trigger class (verbs of will/emotion/doubt, impersonal expressions, conjunctions like bien que and avant que), decide correctly between indicative and subjunctive after opinion verbs, handle the past subjunctive, and know when an infinitive construction lets you avoid the subjunctive entirely.

Follow a byte from an Ethernet frame on your local link all the way to an encrypted TLS session. You will be able to read a routing table, subnet a network in CIDR notation, explain why NAT exists, trace a TCP connection from SYN to FIN, and describe how modern congestion control (CUBIC, BBR) decides how fast to send.

You will learn how a cell's RNA is converted into sequencing libraries, how those reads become a quantified expression matrix, and how that matrix is turned into biological claims. Starting from library preparation and spliced alignment, you move through count normalization, negative-binomial differential expression and pathway enrichment, then into single-cell droplet barcoding, quality control, graph-based clustering, cell-type annotation and dataset integration. The path finishes with dynamic and positional views of the transcriptome: pseudotime trajectories, RNA velocity, spatially resolved transcriptomics, and long-read isoform sequencing. By the end you can read a transcriptomics methods section critically and know which artifact each step introduces.

How TypeScript's generic system actually works: declaring and inferring type parameters, constraining them with extends, and composing keyof, indexed access, conditional, mapped, and template literal types into reusable type-level programs. Finishes with variance and assignability rules and the ability to read and rebuild every built-in utility type (Partial, Pick, ReturnType, ...) from first principles.

How Vue 3's Composition API actually works: the Proxy-based reactivity system underneath ref, reactive, and computed; how dependency tracking decides what re-runs; watchers and their timing; the script setup component model with defineProps and defineEmits; and composables as the unit of logic reuse. A student finishing this can build components that never silently lose reactivity and can explain why each API behaves the way it does.

How WebAssembly actually executes in the browser and how to make it fast. You will understand the stack machine and binary format, why linear memory and the JS boundary dominate real-world cost, how engines tier-compile and stream modules, and how to shrink and speed up modules with wasm-opt, SIMD, bulk memory, and threads. You finish able to profile a Wasm module in devtools and judge when Wasm genuinely beats JavaScript.

Master the programmable GPU pipeline as exposed by WebGL 2: write vertex and fragment shaders in GLSL ES 3.0, feed them geometry through vertex buffers, carry positions through the model-view-projection chain into clip space, and control what rasterization produces per pixel. You will finish able to sample and filter textures, render to offscreen framebuffers, reason about depth testing and blending, implement Blinn-Phong lighting with normal mapping, and diagnose the performance cost of branching, precision, and overdraw.

You will learn how to take a biological sample from lysis through separation, transfer, immunodetection, and quantification without producing an uninterpretable blot. You will be able to choose a lysis buffer and inhibitor set for your target, load equal protein by a validated assay, pick a gel percentage and transfer method matched to your protein's mass, and verify transfer before you spend antibody. You will also be able to titrate antibodies, distinguish chemiluminescent from fluorescent detection and their dynamic-range limits, normalize to total protein rather than a single housekeeping band, and diagnose the common failure modes from the appearance of the blot.

Concepts imported from YouTube curation: https://www.youtube.com/playlist?list=PL13FD5F00C21BBC0B

Concepts imported from YouTube curation: https://www.youtube.com/playlist?list=PL221E2BBF13BECF6C