D792 Operating Systems: shortest clear video per topic

Method: searched YouTube with yt-dlp (2-3 phrasings per topic), pulled auto-captions, read the transcripts of the top candidates. Durations are from yt-dlp metadata. &t= links jump to where the key explanation starts.

Quick table

1. Kernel vs shell/GUI; what the OS does

• Winner: “Kernel vs Shell in Operating System | Difference Between Kernel and Shell Explained”, Coding theory, 6:38. https://www.youtube.com/watch?v=RN4gwf1_Ggg&t=20s
• Why: restaurant analogy (kernel = chef, shell = waiter), says shell can be CLI or GUI, bash/PowerShell examples, kernel talks to hardware.
• Covers: kernel vs shell/GUI, kernel manages CPU/memory/devices. Misses: a broader “what the OS does” list; the tail is padded repetition.
• Shorter option: “Kernel vs Shell in Linux”, Learning Platform, 1:28. https://www.youtube.com/watch?v=J5SAmsCNO2M . Accurate bullet contrast, no analogy.
• For “what an OS does” (resource, process, memory, file, I/O mgmt; kernel + shell): “What Is an Operating System: Kernel, Shell & More”, WhiteboardDoodles, 9:02, relevant part t=20 to 184 (about 3 min). https://www.youtube.com/watch?v=weiR3_TRdSs&t=20s

2. Process vs thread

• Winner: “Process vs Thread | Simply Explained”, TechPrep, 2:49. https://www.youtube.com/watch?v=1myWEH8IGt4&t=24s
• Why: defines program, process, thread cleanly; each process has its own memory address space; threads in one process share code/data/heap but have own stack/registers; notes the tradeoff (fast communication, one bad thread can corrupt the process).
• Covers all listed points. No analogy. Runner-up with analogy: Georgia Tech/Udacity “Difference Between Process and Thread” https://www.youtube.com/watch?v=O3EyzlZxx3g (3:29, newspaper analogy; does not state “shared memory” as crisply).

3. Virtual memory / paging

• Winner: “What is Virtual Memory? What Does it Do?”, Eye on Tech, 1:55. https://www.youtube.com/watch?v=qeOBEOBJREs&t=6s
• Why: shortest accurate one. RAM is finite; virtual memory moves unused pages to disk (swap file) so you can run programs larger than RAM; names paging vs segmentation; notes the slowdown.
• Covers: bigger-than-RAM, paging, swap file, speed cost. Misses: page tables / page faults (probably not needed at this level). Deeper runner-up if needed: BitLemon “Virtual Memory Explained (including Paging)” https://www.youtube.com/watch?v=fGP6VHxqkIM (7:54, not read in full).

4. Device drivers + interrupts

No single short video covers both well. Two short ones: - Drivers: “Drivers: Talking to Hardware”, The Software Mentor, 1:32. https://www.youtube.com/watch?v=gWXah3BmV5M . Driver = translator between general OS commands and a device’s own commands; one per device; missing or buggy driver breaks the device. Runner-up: Tech Index “What is a driver? (Software)” 3:16 https://www.youtube.com/watch?v=rRdwqCTqA1o (also covers outdated or corrupt drivers, ties to Roll Back Driver). - Interrupts: “Computer Interrupts Explained”, GCSE GURU, 2:50. https://www.youtube.com/watch?v=O0mRZeUjEhk . Interrupt = signal from hardware or software that makes the OS pause and run the interrupt handler; examples (printer jam, key press); handler queues by priority; explains the multitasking illusion. Runner-up with chef analogy and polling contrast: Chantal Cox “Polling/Interrupt/DMA differences” 3:00 https://www.youtube.com/watch?v=LNPBr3WvuNg . - Gap: neither video links driver to interrupt handler (the driver provides the handler). That is one sentence to remember.

5. CPU scheduling: FCFS, SJF, Round Robin

• Winner: “CPU Scheduling Explained: FCFS, SJF & Round Robin (Simple Visual Guide)”, Compute Clarity, 7:14. https://www.youtube.com/watch?v=1BGD9GFC4Bo&t=130s
• Why: only video found that covers all three in order with one running analogy (coffee shop). FCFS = line order, convoy effect. SJF = express lane, needs burst time known, starvation. Round Robin = fixed time quantum, then back of the queue; too small a slice wastes time on context switches. Also preemptive vs non-preemptive.
• Misses: no worked average-wait-time calculation. Runner-up for that: ouchouchbaby “Round Robin Algorithm Tutorial” 4:23 https://www.youtube.com/watch?v=aWlQYllBZDs (worked example, time quantum 3). Alternative all-in-one: CS Flatmates, 7:07 https://www.youtube.com/watch?v=XD-p2inmBow (doctor analogy, adds priority scheduling).
• Caveat: no short video found that is both all three algorithms and under 5 min.

6. Deadlock + 4 conditions (needs a simple analogy)

• Winner: “Deadlock in Operating System in 2 Minutes | 4 Conditions of Deadlock”, Oneshot Rank, 2:01. https://www.youtube.com/watch?v=fMrtygDGOho
• Why: person with a pen who needs a book vs person with the book who needs the pen. Then each condition animated on that example: mutual exclusion (one user at a time), hold and wait (keeps R1 while asking for R2), no preemption (OS cannot take it away), circular wait (follow the arrows back to the start). Ends with prevention: break any one condition, e.g. request in a fixed order.
• Covers all 4 conditions, prevention. Misses: only one analogy, the rest are P1/P2/R1/R2 arrows.
• Runner-up for an analogy per condition: TechPrep “Deadlock - Operating Systems | Simply Explained”, 5:06. https://www.youtube.com/watch?v=y7DOHyBTWps&t=39s . One-lane bridge (mutual exclusion), fork-and-knife dinner (hold and wait), library book rule (no preemption). Circular wait has no new analogy. Then prevention and Banker’s algorithm.
• Easy memory hook: “A pen and a book, both people holding one, neither lets go, each waiting for the other.”

7. Windows 11 management tools

• Device Manager Roll Back Driver: “How To Roll Back A Recently Updated Device Driver In Windows 10/11”, MDTechVideos, 2:12. https://www.youtube.com/watch?v=wp6ootRHTLg . Steps: Device Manager, device, Driver tab, Roll Back Driver. Shows why to use it (a bad driver update).
• System Restore: “Windows System Restore EXPLAINED!”, BTNHD, 3:31. https://www.youtube.com/watch?v=zeS_Xi3DkpQ&t=35s . Restore points are snapshots of system config, drivers and installed software; it reverts to an earlier state; does not touch personal files; does not remove malware. Intro is padded, start at 35s.
• Task Manager, Event Viewer, Disk Cleanup (also Device Manager rollback in one line): “CompTIA A+ Core 2 (220-1202) Objective 1.4: Windows Tools (Full Lesson)”, SecPlusMastery, 7:20. https://www.youtube.com/watch?v=uLWZnUJjeio&t=26s . Task Manager t=26 (slow right now, end frozen apps, startup apps), Event Viewer t=109 (history/crash evidence), Device Manager t=169 (roll back driver after a bad update), Disk Cleanup t=312 (reclaim temp files / recycle bin space). Exam-style “which tool for which job” framing. Misses System Restore. Heavy on tools outside your list, so watch just those segments.
• No single short video covers all five; this is the shortest combination that covers them accurately.

8. Linux process and permission commands

• ps, top, kill: “Linux Processes Explained: ps, top, kill Tutorial”, TechTooniya, 3:58. https://www.youtube.com/watch?v=WHUR4keF87M . Process, PID, background with &, ps aux, top, kill -15 (SIGTERM, graceful) vs kill -9 (SIGKILL, forced).
• chmod, chown: “Linux File Permissions Explained: chmod, chown, & Octal Tutorial”, TechTooniya, 4:19. https://www.youtube.com/watch?v=mq33BHj08vQ . Owner/group/others, r=4 w=2 x=1, 755 and 640, chmod changes permissions, chown changes owner/group, ties it to least privilege.
• Both are narrated screen-capture style, slightly flat. Runner-up for permissions: Travis Media “Linux File Permissions in 5 Minutes” 6:03 https://www.youtube.com/watch?v=LnKoncbQBsM (more popular, not read in full).

9. OS security

No single short video covers every item. Three that together do: - Authentication vs authorization, MFA, least privilege: “Authentication vs Authorization: What’s the Difference?”, Infosec Simplified, 2:51. https://www.youtube.com/watch?v=B0kB8IxL8Kw . Airport analogy (passport = authentication, boarding pass = authorization); MFA = something you know / have / are; least privilege under authorization. - UAC, BitLocker, firewall, standard vs admin accounts, Defender: “CompTIA A+ 1202 Windows Security Settings Rapid Review (Obj 2.2)”, Techvault Academy, 4:40. https://www.youtube.com/watch?v=4i7Vu4nfrAo . UAC = security guard asking for admin credentials; BitLocker = full-disk encryption, unreadable if stolen; Windows firewall controls ports/apps; use a standard account and elevate only when needed. Last 1 min covers Active Directory and Group Policy (skip). Shorter UAC + BitLocker only: Admin365 2:32 https://www.youtube.com/watch?v=9VboMJWiYuQ . - Patching + MFA: “Security Maintenance Through Patching, Hardening, And MFA”, Full IT Operations Courses, 1:45. https://www.youtube.com/watch?v=7BPNSMddrFg&t=16s . Patches close known holes, turn off unneeded services, MFA adds a second check. Dry narration, but accurate and short.

Honest gaps

• Topic 4, 7, 8, 9 need 2-3 videos each. No short single video covers them.
• Several winners are small channels (under 1,000 views) and some captions look AI-narrated. Content matched textbook definitions, but none are polished.
• Winners and runner-ups were read in transcript form, except BitLemon virtual memory (fGP6VHxqkIM) and Travis Media permissions (LnKoncbQBsM), which were not read and are listed only as unverified options.
• Search first hit a YouTube bot-check on the mini; transcripts were pulled locally using Chrome cookies via yt-dlp.

D792A Algorithm Efficiency: shortest clear video per topic

Method: searched via yt-dlp on the mini (the Mac fails with SSL errors), pulled auto-captions, read transcripts of 2-4 candidates per topic. Caveat: YouTube started returning HTTP 429 mid-run. These were NOT transcript-read: Techdose linear-vs-binary (sSYQ1H9-Vks), Segmentation fault bubble-vs-selection (tM-emzdOlX4), udiprod insertion-vs-bubble (TZRWRjq2CAg), Aaron Jack data structures (sVxBVvlnJsM), Kantan Coding log n / n log n (wjDY5RbILno, K3NluEdHkao). Judged by title only, so not chosen.

Per topic

1. Big-O basics: Bro Code XMUe3zFhM5c (6:25)

Why: only short video I read that names all five classes in the topic list, with a plain-English reason for dropping small terms (“n+1 becomes n”, 3 steps is not O(3), so O(1)). The linear-vs-quadratic comparison (n=1000 gives 1,000 vs 1,000,000 steps) is at 277s. Misses: no explicit “nested loop = n^2” rule (only says insertion/selection/bubble sort are n^2). Calls the 5 in “5n” case only implicitly. Runner-up: Fireship g2o22C3CRfU (1:40, https://www.youtube.com/watch?v=g2o22C3CRfU). Accurate and has “loop within a loop = quadratic”, binary search = log, index lookup = O(1). No n log n and no clear “drop constants” (only “simplify to fastest-growing worst case”). Good 100-second primer, not enough alone. Also: Michael Sambol __vX2sjlpXU (5:13) is the best on rules: drop constants, drop low-order terms, sequential statements add, nested loop gives n^2, if/else takes the worst branch. It has no log n or n log n. Pair with Fireship if Bro Code feels slow.

2. Data structures vs complexity (no single video covers it)

• Array: Tech With Tim B2KusJcbVIg from 121s. Index = O(1) “constant time”; insert in the middle/front shifts everything = O(n); remove same. Slow-ish talker; the useful part is 2:00-5:40.
• Hash/dict: Sambol knV86FlSXJ8. “Average search time of O(1), degrades to O(n) in the worst case”; dictionary = key-value map; hash table = implementation. Spends time on collisions/chaining (extra, harmless).
• Stack vs queue: Turing Blackboard ElBl0iDcnQA. Cleanest: LIFO plates, FIFO ticket line, push/pop, enqueue/dequeue. Runner-up CodeLucky Ws5Vk01WzpU (4:26) adds Python code, more than needed.
• Balanced BST search O(log n): NOT FOUND. Sambol’s binary search video (fDKIpRe8GW4 at 171s) draws a binary tree of the array and says height = log n, which is the closest verified material. I did not read a dedicated BST video (Code Fantasy jK1EmCVh7Do, Quest Code GhXiKoXfkDo were title-only candidates).
• Flag: your note says “list insert-at-front O(n)”. That is true for array-backed lists (Python list). Bro Code says inserting at the front of a linked list is O(1), which is also true but sounds contradictory. For the exam, “list” in WGU material means array-backed list, so go with O(n).

3. Linear vs binary search: KnowledgeCatch AhPD3N3vUcM (3:35)

Why: the only one that directly compares them and says when to use each (cheat sheet at 189s: linear for unsorted/small, binary for sorted/large). Says binary only works on sorted data; “1000 contacts = at most 10 checks”, “1M items vs ~20 steps”. Misses: does not show the middle index math. Runner-up for the middle calc: Sambol fDKIpRe8GW4 (4:00): mid = average of left and right index, round down (consistently), worked example, loop code, O(log n) via tree height. Fireship MFhxShGxHWc (2:20) also explains “open in the middle, discard half”, needs sorted array, linear loop vs log time.

4. Insertion sort: Hello Byte JSEk1vr3IAU (3:01)

Why: card-hand analogy, worked example, then best case O(n) (already sorted, n-1 comparisons), worst/average O(n^2), space O(1)/in place. Misses: never says outright “use for small or nearly sorted lists”; the best-case-O(n) line implies it. Coding with Lewis rbbTd-gkajw at 156s says “very small list… great option”. Runner-up: Sambol JU767SDMDvA (2:19). Clear animation, worst case n^2 only, no best case.

5. Merge sort: Sambol 4VqmGXwpLqc (3:03)

Why: divide step, merge into temporary arrays, n log n (n for the merge loop, log n for tree height). Misses: does not say stable or that it needs O(n) extra memory beyond “temporary arrays”. Those two points are covered in topic 8 (gkM-_ldy52I at 466-590s: merge sort is not in place, is stable). udiprod es2T6KY45cA (5:34) is a robot-and-balls animation of merge vs quick sort. The captions are sparse (animation), so I could not verify the middle. It shows merge sort making no random choices and quick sort being lucky/unlucky. Good visual, weak for facts.

6. Quick sort: Sambol Hoixgm4-P4M (4:24)

Why: pivot, partition with left/right swaps in the same array, recursion, pivot choice (median of three), worst case n^2, average n log n. Misses: does not say “in place” or “fastest in practice” in words. Computerphile XE4VP_8Y0BU (3:23) shows why a sorted list with last-element pivot gives n^2 (136-169s) but is messy and the transcript cuts off with unrelated text at the end.

7. Bubble / selection: no single short video

Best combined segment: Coding with Lewis rbbTd-gkajw 0:00-3:08. Bubble: worst n^2, best n if already sorted. Selection: n^2 best and worst, “always beats bubble a bit”. Insertion follows. Captions are garbled (ASR) and the video is 10:48, so stop at 3:08. Accurate but two separate videos: Sambol bubble xli_FI7CuzA (2:10) and selection g-PGLbMth_g (2:43), both n^2 with nested-loop reason. Use these if you want the algorithms shown step by step.

8. Choosing a sort: Jindal gkM-_ldy52I (11:55), watch 5:40-11:20

Why: only read video that tabulates best/worst/average time, extra space, in-place, stable and online for bubble, selection, insertion, merge, quick, heap, and ends with “pick by stability, space, speed”. Content: bubble/selection/insertion n^2 worst; merge n log n always; quick avg n log n, worst n^2 on already-sorted input; bubble and insertion best case n; stable = bubble, insertion, merge; not stable = selection, quick, heap; merge sort uses extra space. Weak: long, accent/ASR-heavy, lecture style. Says quick sort needs O(n) space and lumps it with non-in-place; the exam wants “quick sort is in place” (true, uses only stack space). Do not take that line from it. Runner-up: Coding with Lewis rbbTd-gkajw (10:48). Friendlier, covers more sorts, mentions small-list use for insertion. Its merge-sort complexity wording is garbled and it gives no stable/in-place data. Honest take: nothing short and clean exists in what I could read. A short cheat-sheet fallback: insertion = small/nearly sorted; merge = guaranteed n log n, stable, extra memory; quick = fastest average, in place, n^2 worst; bubble/selection = n^2, teaching only.

WGU D792 - Program Foundations + Data Profiling (Python): shortest clear YouTube video per topic

Method: yt-dlp search (2-3 phrasings per topic), then read the actual caption transcript of each finalist. Durations are exact. Caveat: partway through, YouTube started returning HTTP 429 / “confirm you’re not a bot” to this machine and the mini. Every pick below was transcript-verified. A few extra candidates could not be fetched; they are flagged “Unverified”. No pick is title-only.

URL format: https://www.youtube.com/watch?v=ID&t=SECONDSs jumps to the key part.

Summary table