Notebook Lm with 300 sources. I'm adding sources every time I make a new episode. The tech talk is getting denser too, which is what i want! 

PROMPT:

```
## 015: Text is Weird - Display, Input, and Rich Text
004: UI Rosetta Stone 04: 
• Display Text vs Editable Text Primitives
• The Label Mnemonic and Password Security
• Taming Rich Text: FlowDocuments, Decorators, and Markdown

# Summary
This is Episode 004 of the mini-series “UI Rosetta Stone”.
Focus: Text display + text input controls, and rich text across WPF/XAML (and Noesis), Unreal UMG, and React/web.
Audience: Senior UI engineers.
Episode length: 12–18 minutes spoken.

## Must cover:
This is the key information to be presented this episode, and MUST be covered!
- **Display vs Input (WPF/Noesis):** Contrast the lightweight `TextBlock` (which inherits from `FrameworkElement` and is highly performant) with the heavier `TextBox` (for user input and selection). Briefly cover the `Label` (`ContentControl`): explain that it exists specifically to handle access keys/mnemonics and link focus to an input `Target`, rather than just displaying static text.
- **Display vs Input (UMG):** Standard `TextBlock` for display. Contrast `EditableText` (the lightweight, raw text base) versus `EditableTextBox` (which adds a border, background styling, and interaction states like hover/focus). 
- **Display vs Input (Web/React):** The `` and `` elements, conceptually covering controlled components (React state drives value) versus uncontrolled components (DOM holds value).
- **Rich Text (WPF):** Explain the `RichTextBox` as a host for a `FlowDocument` (Paragraphs, Runs). Mention that it requires interacting with `TextRange` and `TextPointer` objects rather than simple string properties. 
- **Rich Text (UMG):** The `RichTextBlock` concept. Explain that it relies on a Data Table Asset (`RichTextStyleRow`) for styling and how it uses `URichTextBlockDecorator` classes to map markup tags (like ``) directly to custom Slate widgets.
- **Rich Text (Web):** HTML markup, Markdown rendering pipelines, and a brief nod to why `contentEditable` is a uniquely chaotic beast.
- **Password Input (brief):** The `PasswordBox` concept. Explain the security/UX gotchas (e.g., in WPF, `PasswordBox` is a sealed, separate control rather than just a TextBox property to prevent memory interception and UI tree snooping).
- **Debugging text issues:** Binding vs state bugs, layout clipping vs font fallback, and practical approaches per stack.
- **Best Practices vs Traps:** 
- *Trap:* Formatting text via property bindings that fire every single frame (specifically CPU-heavy in UMG; advocate for event-driven updates).
- *Trap:* Mixing layout logic into text generation.
- *Trap:* Overusing rich text when a composed widget/component is better, or vice versa.

## Topics already covered:
This is information already covered in previous episodes or coming up in future episodes, and you cannot cover it again. For reference, I have provided the episodes where it was spoken of, and you may ask listeners to go back.
- 00: WPF Runtime and dispatcher
- 00: Unreal runtime and what slate is
- 00: Web runtime and browser DOM + Javascript engine + Node Server
- 00: Dev environments, Visual studio vs unreal vs visual studio code
- 00: Source control, Git, perforce etc…
- 01: Definition of a control, user control, component etc…
- 01: Button element\control and Textbox\label controls
- 01: MVVM and importance of separation of concerns
- 02: Layout controls that are not "panels" including overlay, canvas
- 012: One-Dimensional vs Two-Dimensional Layouts (StackPanels, Flexbox, Grids)
- 012: Fluid Design and Responsive Spaces
- 012: Pixel Density, DPI Scaling, and Screen Adaptation
- 013: Non-stacking layout primitives: overlays/layers, canvas/absolute positioning, and decorator-style wrappers.

## Output format:
Generate the podcast script using the following exact structure:
1) Title
2) Episode description (podcast listing)
3) Segment outline + timestamps
4) Script (no code)
5) Crosswalk table: display text vs editable text vs rich text (per stack)
6) “Do / Don’t” list (max 12 bullets)

Rules:
- Keep it pragmatic: focus on decision-making and maintainability.
- Keep it controls-level, not engine internals.
- Don’t deep dive into IME internals, but acknowledge it exists and affects control choice.
- Keep examples conceptual.

```

This episode includes AI-generated content.

NotebookLM again. I had to generate it a second time, because if you ask the chat to make the audio overview, it feeds it a 2 liner description and the episode wanders off course.

PROMPT:


## 013: Not Stack Panels - Overlays, Canvas & Absolute Positioning
013: UI Rosetta Stone 03: 
• Overlays, Layers, and Z-Order
• Canvas and Absolute Positioning (and why to avoid "Coordinate Soup")
• Decorator-Style Wrappers

# Summary
This is special Episode 003 of the mini-series “UI Rosetta Stone” (Overall EP013).
Focus: Non-stacking layout primitives: overlays/layers, canvas/absolute positioning, and decorator-style wrapping (brief).
Audience: Senior UI engineers, 2D art and design specialists working in editors.

## Must cover:
This is the key information to be presented this episode, and MUST be covered!
- **UMG Overlay:** The layering mental model, z-order, and typical uses (tooltips, highlights, modal layers). Mention that while Overlays stack elements, they also increment Layer IDs (draw calls), so they should be used intentionally [1].
- **WPF Canvas & UMG CanvasPanel:** Absolute coordinates (e.g., `Canvas.Left` and `Canvas.Top` in WPF) [2, 3]. Contrast when it’s useful (drawing, painting, or root HUDs) vs. when it becomes tech debt [4, 5].
- **Absolute Positioning on the Web:** `position: absolute/relative/fixed/sticky` (conceptual), and managing `z-index` layering based on containing blocks [6, 7].
- **XAML Decorators (brief):** The concept of the `Decorator` base class (which only accepts a single `Child` element) to add a behavior or visual layer (like `Border` or `Viewbox`) [8, 9]. Map this to UMG wrappers (like `SizeBox`, `ScaleBox`, or `RetainerBox`) and Web `div` wrappers [10, 11].
- **Coordinate Systems:** UMG anchors/pivots conceptually (using 0.0 to 1.0 normalized coordinates) [12, 13], WPF alignment origins, and web layout boxes/containing blocks.
- **Best Practices vs Traps:** 
- *“Canvas everywhere” anti-pattern:* Specifically call out that in Unreal, excessive Canvas Panels ruin performance by incrementing child Layer IDs and exploding draw calls [14, 15].
- *Layering & hit-testing pitfalls:* Contrast WPF's invisible hit-testing (where a `null` background lets clicks pass through, but a `Transparent` background captures them) [16, 17] with UMG's visibility settings (`Hit Test Invisible` vs `Self Hit Test Invisible`) [18]. Mention Web's `pointer-events: none`.
- *Debugging layouts:* High-level tools and approaches per stack (e.g., WPF Snoop/Visual Studio live tree, Unreal Widget Reflector [19], Chrome DevTools).

## Topics already covered:
This is information already covered in previous episodes or coming up in future episodes, and you cannot cover it again. For reference, I have provided the episodes where it was spoken of, and you may ask listeners to go back.
- 00: WPF Runtime and dispatcher
- 00: Unreal runtime and what slate is
- 00: Web runtime and browser DOM + Javascript engine + Node Server
- 00: Dev environments, Visual studio vs unreal vs visual studio code
- 00: Source control, Git, perforce etc…
- 01: Definition of a control, user control, component etc…
- 01: Button element\control and Textbox\label controls
- 01: MVVM and importance of separation of concerns
- 02: Layout controls that are not "panels" including overlay, canvas
- 012: One-Dimensional vs Two-Dimensional Layouts (StackPanels, Flexbox, Grids)
- 012: Fluid Design and Responsive Spaces
- 012: Pixel Density, DPI Scaling, and Screen Adaptation

## Output format:
Generate the podcast script using the following exact structure:
1) Title
2) Episode description (podcast listing)
3) Segment outline + timestamps
4) Script (no code)
5) “When to use it / when not to” table for Overlay vs Canvas/Absolute
6) Checklist: diagnosing a broken layout (per stack)

Rules:
- Keep it pragmatic: focus on decision-making and maintainability.
- Keep it controls-level, not engine internals.
- Give concrete mental models, not buzzwords.


This episode includes AI-generated content.

NotebookLM again. 64 sources. I spent some time building the structure of the episode, but asked the notebook lm chat to trigger generating the episode for me. It gave a two liner description. Rubbish!

---

Prompt:
```
OpenClaw native Windows 11 setup, top skills, security best practices to prevent rogue actions, and memory management
```

This episode includes AI-generated content.

NotebookLM again. 63 sources. I spent some time building the structure of the episode, but asked the notebook lm chat to trigger generating the episode for me. It gave a two liner description. Rubbish!


Prompt:
```
Setting up a production-ready web hosting server on Windows using Vite and IIS or Caddy for a local network.
```

This episode includes AI-generated content.

Another NotebookLM job. Bit of a rush, only 73 sources.
Had a request to get a WPF tool working on a Mac. Not important, but a chance to grow my skillz. So Here's the second of two covering it.

Notebook LM Prompt:

```
This is Episode 11 of News Re-Download, a podcast talking about software engineering. We're going over how to get dot net app running on Mac using **Mac Catalyst**. Because we are distributing outside the Mac App Store, you must navigate Apple's strict security model. 
Here is the concise implementation guide:
### 1. Prerequisites
*   **Hardware:** You cannot build a Mac deployment package from a Windows machine. You must use a physical Mac with Xcode installed.
*   **Apple Developer Account:** You need a paid account to generate the certificates required to bypass macOS Gatekeeper.
### 2. Certificates & Provisioning
*   **Generate Certificates:** Use Keychain Access on the Mac to create a Certificate Signing Request (CSR). In your Apple Developer portal, generate a **Developer ID Application** certificate (to sign the app) and a **Developer ID Installer** certificate (to sign the `.pkg`). Install both into your Mac's Keychain.
*   **Provisioning Profile:** Create an App ID matching your app's Bundle Identifier, then generate a Distribution Provisioning Profile specifically for Mac Catalyst. Download this profile via Xcode.
### 3. Application Configuration
*   **Native Mac Look:** By default, Mac Catalyst apps scale like iPad apps. Update your `Info.plist` and set the `UIDeviceFamily` key to `6` (Mac idiom) instead of `2` (iPad idiom) for a traditional desktop feel.
*   **Entitlements:** Create an `Entitlements.plist` in `Platforms/MacCatalyst/` to enable App Sandbox (`com.apple.security.app-sandbox`) and Network Client access (`com.apple.security.network.client`) so your app can securely reach the Jira REST API.
*   **Fix Build Errors:** To avoid a known `_CodesignVerify` build error when publishing outside the App Store, you must add an MSBuild `` to your `.csproj` to explicitly disable code signature verification.
### 4. Build and Publish
On the Mac, open a terminal in your project directory and use the .NET CLI to compile and sign the package:
```bash
dotnet publish -f net8.0-maccatalyst -c Release -p:CreatePackage=true -p:EnableCodeSigning=true -p:EnablePackageSigning=true -p:CodesignKey="Developer ID Application: Your Name" -p:PackageSigningKey="Developer ID Installer: Your Name"
```
This generates a signed `.pkg` installer file in your output directory.
### 5. Notarize and Staple (Bypassing Gatekeeper)
*   **Notarize:** Upload the signed `.pkg` to Apple's servers using the command line `notarytool`. If you skip this step, macOS Gatekeeper will block the installation.
*   **Staple:** Once Apple approves the app, run `xcrun stapler staple your_app.pkg`. This staples the approval ticket directly to the installer, allowing your producer to install it safely even if offline.
### 6. Auto-Updates (Sparkle)
For auto-updates on macOS, the Windows AppInstaller won't work. Instead, integrate the **Sparkle** framework.
*   Add Sparkle to your project.
*   Host an "Appcast" RSS/XML feed on your server to track new versions.
*   Sign your updates using EdDSA (ed25519) signatures so Sparkle can securely download and replace the app bundle in the background.

```

This episode includes AI-generated content.

Another NotebookLM job. Bit of a rush, only 73 sources.
Had a request to get a WPF tool working on a Mac. Not important, but a chance to grow my skillz. So Here's the first of two covering it.

Notebook LM Prompt:

```
This is Episode 10 of News Re-Download, a podcast talking about software engineering. We're going over how to migrate a dot net 8 WPF app to dot net MAUI without losing the WPF build. We want a project with two front ends so we can explore growing from WPF developers, to XAML developers.
### Concise Guide: .NET MAUI Windows Frontend & Auto-Update Deployment
**1. Architecture & Project Setup**
*   **Create Project:** Add a new .NET MAUI App named `JiraMinion.MAUI` to your solution, targeting Windows. 
*   **Link Shared Logic:** Add a project reference to `JiraMinion.Shared` so you can reuse all ViewModels and business logic.
*   **Dependency Injection:** Register your shared ViewModels and MAUI-specific services in the `MauiProgram.cs` bootstrap class.
**2. Translating the UI (XAML Migration)**
WPF and MAUI XAML cannot be shared directly because MAUI uses the 2009 XAML specification, and its controls derive from `VisualElement` instead of `FrameworkElement`.
*   **Control Mapping:** Translate `Window` to `ContentPage`, `StackPanel` to `VerticalStackLayout` or `HorizontalStackLayout`, `TextBlock` to `Label`, and `TextBox` to `Entry` (single-line) or `Editor` (multi-line).
*   **Layout & Alignment:** Replace `HorizontalAlignment` with `HorizontalOptions` using values like `Start`, `Center`, or `Fill`.
*   **Data Binding:** MAUI uses Compiled Bindings by default for better performance. You must explicitly set `x:DataType` on your data templates. `RelativeSource` bindings (like `FindAncestor`) are much stricter in MAUI; if visual tree boundaries break, use `x:Reference` to target named elements instead.
**3. Platform-Specific Services**
*   **Cross-Platform APIs:** Replace your WPF Win32 service implementations with MAUI's built-in abstractions. Use the `Microsoft.Maui.ApplicationModel.DataTransfer.Clipboard` API for your `IClipboardService` and `Microsoft.Maui.ApplicationModel.Launcher.OpenAsync` for your `IBrowserService`.
*   **Native Windows Code:** If you must use Windows-specific APIs (like the Windows Registry), place that code inside the `Platforms/Windows/` directory or use conditional compilation (`#if WINDOWS`) so it only compiles for the Windows build.
**4. Deployment (ClickOnce Equivalent)**
ClickOnce does not translate to MAUI's multi-platform packaging. The modern equivalent for Windows is **MSIX combined with an AppInstaller file**, which provides the exact same automatic update on launch experience.
*   **Publish the MSIX:** Build and publish your MAUI app as an `.msix` package.
*   **Create the `.appinstaller` File:** Create an XML file hosted on your network share that points to the network URI of the latest MSIX package.
*   **Configure Auto-Updates:** In the AppInstaller XML, include an `` block with ``. This instructs Windows to check the network share for a new version every time the user opens the application, applying updates automatically. Users install the app initially by running this `.appinstaller` file.
```

This episode includes AI-generated content.

We're looking at Stack Panels, Flex Box and the other UI elements to are part of layouts and achieving a fluid UI. Elements like the canvas that do absolute positioning are part of next week's episode.

177 Sources for his episode.

Here's the prompt from Notebook LM. 

---


# Summary
This is episode 009 of the podcast. And this Episode is 02 of a special mini series called “UI Rosetta Stone”.
Focus: Exploring how different UI frameworks handle fluid, responsive element placement using layout panels, and how these layouts dynamically adapt to diverse physical hardware through pixel density and DPI scaling algorithms.
Audience: UI engineers, cross-domain.

## 009: StackPanels & Fluid Layouts
    UI Rosetta Stone 02: 
• One-Dimensional vs Two-Dimensional Layouts (StackPanels, Flexbox, Grids)
• Fluid Design and Responsive Spaces
• Pixel Density, DPI Scaling, and Screen Adaptation


## Must cover:
This is the key information to be presented this episode, and MUST be covered!
- The concept of "Fluid Design": UIs that gracefully handle elements appearing/disappearing and adjust across various monitor environments like 1080p, 1440p, 4K, and ultrawide screens.
- Pixel density and resolution independence: Contrast building for a flagship retina display phone vs. a large, low-resolution industrial/factory monitor. Explain the cross-domain solutions: Device-Independent Pixels (DIPs) in WPF, DPI Scaling Curve rules in Unreal Engine, and `devicePixelRatio` in React/Web.
- One-Dimensional Layouts: Explain the **StackPanel** (WPF), **Flexbox** (`flex-direction: row` or `column` in React), and **Horizontal Box / Vertical Box** (UMG). 
- Controlling space in 1D layouts: Compare UMG's "Auto" (size to content) vs "Fill" (take remaining space) to React's `flex-basis`, `flex-grow`, and `flex-shrink` properties.
- Two-Dimensional Layouts: Contrast the **Grid** in WPF (using Star `*` sizing), **CSS Grid** in React (using `fr` fractional units), and the **Grid Panel / Uniform Grid** in UMG.
- Other specialized panels: Handling content flow using WPF's **WrapPanel** versus React's `flex-wrap`, and pinning elements to container edges using the WPF **DockPanel**.

## Topics already covered:
This is information already covered in previous episodes or coming up in future episodes, and you cannot cover it again. For reference, I have provided the episodes where it was spoken of, and you may ask listeners to go back.
- 00: WPF Runtime and dispatcher
- 00: Unreal runtime and what slate is
- 00: Web runtime and browser DOM + Javascript engine + Node Server
- 00: Dev environments, Visual studio vs unreal vs visual studio code
- 00: Source control, Git, perforce etc…
- 01: Definition of a control, user control, component etc…
- 01: Button element\control and Textbox\label controls
- 01: MVVM and importance of separation of concerns
- 02: Layout controls that are not "panels" including overlay, canvas

## Rules:
- Keep it controls-level, not engine internals.
- Give concrete mental models, not buzzwords. (e.g., Explain Flexbox/StackPanel as "beads on a string" that push against each other, Grids as a "spreadsheet", and DPI scaling as a global "magnifying glass" translating software units to physical monitor pixels).

This episode includes AI-generated content.

We're starting with basic controls. The label and the button to examine the design patterns and architecture behind the implementations in React, WPF and UMG.

177 Sources for his episode.

Here's the prompt from Notebook LM. 

---

This is special Episode 001 of “UI Rosetta Stone”.
Focus: introduce the series using the simplest controls (Button + Label/Text) to explain core patterns.
Audience: UI engineers, cross-domain.
Must cover:
- What a “control” is in each ecosystem (composition vs inheritance, templating/styling model at a high level).
- Button: input/click handling, focus/keyboard/controller considerations (high level), and where logic belongs.
- Label/Text: static text, localization concerns (high level), and render cost awareness.
- WYSIWYG workflows:
  - WPF/XAML designer reality (and when people abandon it)
  - Unreal UMG Designer + preview quirks
  - Web: browser + component preview tooling mindset
- Patterns crosswalk:
  - MVVM in WPF/Noesis: bindings, change notification, commands
  - Unreal MVVM plugin: bindings + FieldNotify conceptually
  - React: props/state, unidirectional flow, “components as functions of state”
- Best practices + common traps when porting habits between stacks (explicit callouts).

Rules:
- Keep it controls-level, not engine internals.
- Give concrete mental models, not buzzwords.


This episode includes AI-generated content.

In this sub-series, I'm normalizing knowledge between WPF, UMG and React UI by going over their concepts together in a head to head to head comparison. 

Again, this is Notebook LM. 101 References on this one. I had to trim the first few minutes with Audacity as my prompt oversteered and produced a bunch of weird repitition and junk. I mispelt my meta-prompt I gave to chatGPT to produce the prompt I gave to Notebook LM.

Here's the prompt:

```
You are writing Podcast Episode 000 for a special mini-series called “UI Rosetta Stone”.
Audience: experienced UI devs coming from WPF/XAML, Unreal UMG/Slate, and React/web.
Goal: explain the *runtime + tooling* model for each stack at a “controls and workflow” level (not deep engine internals).
Tone: direct, practical, engineering-first. Assume middle to senior devs.
Must cover:
- WPF runtime: .NET CLR, Dispatcher/UI thread, layout+render pipeline at a high level, app executable + OS integration.
- Unreal runtime: what Slate is, how UMG sits on top, game loop + frame budget context, PIE vs packaged build.
- Web runtime: browser JS engine (V8/SpiderMonkey/etc), DOM/CSS/layout, React on top, plus Node/server accessed via browser.
- Debugging in each: Visual Studio debugger + WPF inspection tools; Unreal Widget Reflector/Slate tools + logs; browser DevTools + React DevTools.
- Dev environments: Visual Studio vs VS Code vs Unreal Editor tooling, typical iteration loops.
- Source control workflows: git, Perforce, SVN, Mercurial — where each commonly appears and why (big binaries, branching, CI realities).
Output format:
1) Title
2) 2–3 sentence episode synopsis
3) Segment outline with timestamps (rough)
4) Full narration script (spoken-word, no code)
5) “Crosswalk” table: concept → WPF term → Unreal term → Web/React term
6) Show notes: bullets + key terms glossary
Rules:
- Don’t invent specific tool feature claims you’re unsure about. If uncertain, write “(verify)” inline.
- Keep examples conceptual (no code).


```



This episode includes AI-generated content.

Another one from notebook lm. Its 136 sources. Im setting up a RAG servee at work and need to know more about local models due to security restrictions. 

below is my prompt:

---

System Role: Act as an AI Infrastructure Engineer and generate an actionable research report based strictly on Hugging Face data (model cards, discussions, metrics) for local GGUF models running via LM Studio/llama.cpp on Windows.
Target Use Case: Software engineering (C, C++, C#, Lua, Unreal Blueprints, Unity YAML) and local RAG.
Hardware Targets: Tier A (10GB VRAM / RTX 3080), Tier B (24GB VRAM / RTX 3090), Tier C (48GB VRAM / Pro GPU).
Required Deliverables:
Model Taxonomy & Lineage: Define current classes (Generative LLMs, Embeddings, Rerankers, Vision) mapping to LM Studio UI. Detail provenance for major architectures (e.g., Llama, Mistral, Qwen, Phi).
Tiered Model Shortlist: Top coding/generalist models per VRAM tier. Specify exact HF name, parameter count, Q4_K_M/Q5_K_M VRAM footprint, recommended vs. max context windows, and HF download/like metrics (with dates).
Throughput Metrics (Tokens/sec): Provide throughput estimates per GPU tier. Compare Q4 vs Q5 performance. Include test parameters (context length, batch size, prompt vs. gen mix).
Mini-Guides (Code & RAG): For each model, detail: strengths/failure modes, context degradation thresholds (10k+ lines), chunking strategies, and optimal LM Studio sampling configurations (temperature, top_p, min_p, repetition penalty).
Memory & Scaling Architecture: * Clarify LM Studio multi-model placement (CPU vs GPU offloading interactions).
Deploy A: Single GPU optimization.
Deploy B: 48GB Multi-GPU pro server (Compare vLLM vs TensorRT-LLM vs llama.cpp; explain tensor/pipeline parallelism penalties).
Deploy C: 6x8GB commodity rig OS/software strategies.
KPIs & Capabilities: Define capacity metrics (TTFT, concurrency, queue depth). Quantify the throughput penalty vs. quality gain of "reasoning" models. Explain the mechanical reality of file/image attachments (native multimodality vs text conversion).

This episode includes AI-generated content.