• Building from first principles based on my course on Agentics at Johns Hopkins
• Building using Microsoft’s new Agent Framework

The advantage of the first is that you understand the underlying mechanisms in more depth; the advantage of the second is that a lot of the plumbing is done for you and you become more productive more quickly.

I will do the .NET work in C#, and probably do all the other work in Python. See my blogpost on why Python.

I will, to a degree, be documenting what I learn as I learn it, without infringing on copyright, of course.

Project 1 – Jupyter

The work for Johns Hopkins is done in a Jupyter notebook. These are very convenient files that contain runnable cells. You put your code snippet in a cell and run it, either receiving a result or extensive error information. To get started, open Visual Studio Code and click New File. In the drop down on top, choose Jupyter Notebook:

Choose your Python environment, and put code into the first “cell.” Then click on the knob on the left and the cell runs and the output is displayed:

You can add markdown, you can even tell it to generate code based on your description of what you want. It is possible to have these cells generate a proper Python program and/or generate

Open AI Endpoint

Whether you are working in the Jupyter notebook or in Agent Framework, you will want an OpenAI Endpoint. To do so go to https://platform.openai.com, sign in, go to API Keys, create a new key. Your endpoint is the base url used for API calls.

Or… if you are working in the Microsoft ecosystem, in the Azure Portal search for Azure OpenAI and create a resource. Then go to Resource Management -> Keys and Endpoint. Copy the Endpoint and Key 1 (your API key) Deploy under Resource Management -> Model Deployments. Your endpoint will look like this:

https://<your-resource-name>.openai.azure.com/

Copilot can set all this up for you.

Next up: setting up your environment.

I divided the slide into two parts: good news and bad. The good news is the promise of enormously increased productivity, which may well lead to a higher standard of living across the board. Further, as AI progresses, we may see accelerated breakthroughs in many fields, most notably medicine and genetics.

The bad news is that along with these changes will almost certainly come massive displacement. As a society, we’ve seen this kind of displacement before. The advent of the tractor displaced well over 50% of farm workers, and ultimately mechanization displaced over 95% of agricultural labor!

The key difference, however, is that in the past technology displaced the least skilled workers; AI is set to affect many of the most educated and skilled. I’m not sure that society knows how to handle this. Reskilling has a poor performance history, and sending highly paid college-educated programmers back to two-year training programs in robotics does not seem auspicious.

In the very short term, AI presents some real challenges, not least is the environmental impact of massive energy-consuming data centers. Add to that the potential economic impact when the AI boom goes bust and there is plenty to worry about, but here is one more…

Right now we are learning to adjust to AI, but research continues on AGI (Artificial General Intelligence). The next step after that is Artificial Super Intelligence: when AI becomes meaningfully smarter than humans. No one knows quite what to expect when that happens, but I commend to you the book If Anyone Builds It, Everyone Dies by Eliezer Yudkowsky and Nate Soares. These are not crackpot writers — they are recognized experts in AI and their thesis is chilling.

In coming postings I will divide my attention between two aspects of AI:

• Using AI in developing your application
• Creating applications that incorporate AI

Along the way I will talk about AI in the .NET world (specifically the Azure workflow tools) and outside of .NET (time to brush up on Python).

Next up: Assisted Coding…

MCP (Model, Context, Protocol) is an open standard that lets AI models (read copilot, ChatGPT, etc.) connect to external tools. These tools can be databases, code you write, code you connect to, other AIs, etc. etc. It is the universal API for Agents.

Here’s a link to the code.

After the presentation, I’ll cover a lot of that material here, but to get us started let’s talk about the two ways you’ll care about AI.

1. Using AI to aid you in your coding
2. Creating applications that incorporate AI

By now, you probably are using AI in your coding, although I’m willing to wager that most of us are not using it as well or as extensively as we might. I hope to expand on that as we go.

In a previous post, I talked about creating a copilot-instructions.md file (though you might want a CLAUDE.md file!). You’ll also want to create (at least)

• Memory.md // key facts and decisions you’ve made
• Restart.md // what you were doing when you stopped
• Mistakes.md // mistakes you don’t want copilot to make again

Why? Because Claude and Copilot, etc., have limited short-term memories, and after a while they begin to forget what you’ve already done. You then periodically have copilot read these files (which you assiduously keep updated) and that provides context that helps copilot stay on track (for copilot, read Claude, etc.) I tend to do this every 15 minutes or so, and at the end of each session I’m sure to update all three files so that they are ready for the next session.

For this, and every good idea I have about working well with AI, I’m deeply indebted to a number of smart people, first among them Jeff Blankenburg and his 31 Days of Vibe Coding and Jamie Maguire’s outstanding free course on Microsoft’s Agent Framework. I can also highly recommend the Johns Hopkins 16-week course on Agentics, which I’m enjoying immensely.

If Vibe Coding is what floats your boat, be sure to see my interview with James Montemagno. Start at about 3 minutes in if you’re in a rush.

So much to discuss. In coming posts I’ll cover three main topics:

1. Using AI to enhance and simplify your coding (hey! copilot! what does this mean?)
2. Incorporating AI into your application
3. (really 2a) A working demo. At the moment it is HyperVideo, though I’m stuck on the fact that my video player keeps choking on the audio in my videos making everything freeze up. Any suggestions? Since I have to do some projects for my Agentics course, I may switch over to one or more of those. In any case, I’ll bring you along for the ride.

The next topic, however, is MCP. Stay tuned; I’ll be recording a new, expanded videocast with Lance McCarthy on that very topic. Here’s the first one we did. In the coming one we’ll dive deeper, with real live code and everything!

Much more soon…

Replace the current HTML5 video player implementation with YouTube embedded player to integrate videos from the @JesseLiberty YouTube channel while maintaining all existing interactive learning features.

Proposed Changes

1. Replace HTML5 Video Player with YouTube Embed
   • Implement YouTube IFrame embed in VideoLearning.razor
   • Source videos from https://youtube.com/jesseliberty channel
   • Replace
2. Maintain Existing Functionality
   All current features must remain operational:
   • Pause & Inquire: Pause video and open question panel
   • Interactive Transcript: Clickable, time-synchronized segments
   • Time Tracking: Real-time display of current playback position
   • Seeking: Click transcript to jump to timestamp
   • Search Integration: Wikipedia, Wiktionary, YouTube, Stack Overflow, MDN
3. Use YouTube IFrame Player API
   Implement programmatic video control using YouTube IFrame Player API:
   • pauseVideo() – Pause playback
   • playVideo() – Resume playback
   • getCurrentTime() – Get current timestamp
   • seekTo(seconds) – Jump to specific time
   • getDuration() – Get video length
   • Event listeners: onStateChange, onReady
4. Video Selection & Configuration
   • Video Dropdown: Add UI to select from multiple videos in @JesseLiberty channel
   • Video Catalog: Create a list/configuration of available educational videos with:
   • YouTube video ID
   • Title/description
   • Associated transcript segments
   • State Management: Store selected video ID in component state
   • Configuration Options:
   • Hardcode initial video list in component
   • OR store in appsettings.json
   • OR create a separate service/data file
   Technical Considerations
   JavaScript Interop Changes
   • Load YouTube IFrame API script: https://www.youtube.com/iframe_api
   • Create typed JavaScript interop wrapper for YouTube Player API
   • Replace direct eval() calls with proper YouTube API method invocations
   • Handle async initialization of YouTube player (onYouTubeIframeAPIReady)
   Example JS Interop Pattern:

// VideoLearning.razor.js
export function initializeYouTubePlayer(videoId, dotNetHelper) {
const player = new YT.Player(‘player’, {
videoId: videoId,
events: {
‘onReady’: onPlayerReady,
‘onStateChange’: onPlayerStateChange
}
});
// Store player reference and expose methods
}

export function pauseVideo(player) {
player.pauseVideo();
}

export function getCurrentTime(player) {
return player.getCurrentTime();
}

Transcript Handling
• Option 1: Manually create transcript segments per video (current approach)
• Option 2: Fetch captions using YouTube Data API v3 (requires API key)
• Option 3: Store transcripts in separate JSON files mapped to video IDs
• Consider caption format: YouTube provides .srt or .vtt formats
Render Mode Compatibility
• Ensure YouTube IFrame API works with @rendermode InteractiveServer
• Test SignalR reconnection behavior with YouTube player state
• Verify StateHasChanged() triggers UI updates correctly
Files to Modify

1. VideoLearning.razor
   • Replace
2. Components/Pages/VideoLearning.razor.js (new file)
   • Create typed JS module for YouTube Player API
   • Export functions: initPlayer, pauseVideo, playVideo, seekTo, getCurrentTime
   • Handle player events and callbacks to Blazor
3. Models/VideoInfo.cs (optional, new file)

public record VideoInfo(string VideoId, string Title, List Transcript);

4. appsettings.json (optional)
   • Store video catalog configuration
   Implementation Steps
5. Add YouTube IFrame API script reference to App.razor or VideoLearning.razor
6. Create VideoLearning.razor.js with YouTube Player API wrapper
7. Update VideoLearning.razor markup to use YouTube embed
8. Refactor C# interop calls to use YouTube-specific methods
9. Add video selection UI and catalog
10. Test all interactive features (pause/resume, seeking, transcript sync)
11. Update transcripts for selected YouTube videos from @JesseLiberty channel
    Success Criteria
    • Videos from @JesseLiberty YouTube channel play in the application
    • Users can switch between multiple videos
    • All existing interactive features work identically
    • Pause & Inquire functionality remains intact
    • Interactive transcript synchronization works
    • Time tracking displays correctly
    • Search integration functions as before
    • No degradation in user experience
    Resources
    • YouTube IFrame Player API Reference
    • YouTube Data API v3 – Captions (for transcript retrieval)
    • Blazor JavaScript Interop

Labels: enhancement, feature, blazor, javascript-interop
Priority: High

Those look like a great set of sub-tasks. I’m not sure how to attack them, but breaking them down will greatly simplify matters.

Here’s a first attempt at some of the sub-issues arising out of the work…

You can see that this is far from perfect. Some of these are small and some are huge. It will be necessary to flesh out some and to break others down to smaller tasks, but this is a good start. The trick is not to get overwhelmed. OK, I’m overwhelmed. But my buddy CoPilot and I are ready to tackle this.

The best way to get ahead of this is to create a copilot-instructions.md file in your .github directory (which you may need to create). In this file, you’ll want to put anything that CoPilot should know right from the get-go and for every session.

But how do you know what to put in there?

Here’s the trick… let CoPilot build it for you! I cribbed a set of instructions from the ‘net that tells CoPilot how to create the file based on the existing code in my project. I tweaked it just a bit, as did a buddy (Teja) and all you need to do is copy it into the CoPilot window in Visual Studio, let CoPilot cook, and hey! presto! you have just what you want: a fully developed copilot-instructions.md file in just the right place. Even better, if you already have one, this will merge cleanly.

Here’s the instructions I give CoPilot:

Analyze this codebase to generate or update .github/copilot-instructions.md for guiding AI coding agents. Focus on discovering the essential knowledge that would help an AI agent be immediately productive in this codebase. Consider aspects like: The “big picture” architecture that requires reading multiple files to understand – major components, service boundaries, data flows, and the “why” behind structural decisions Critical developer workflows (builds, tests, debugging) especially commands that aren’t obvious from file inspection alone Project-specific conventions and patterns that differ from common practices Integration points, external dependencies, and cross-component communication patterns Guidelines (read more at https://aka.ms/vscode-instructions-docs):

If .github/copilot-instructions.md exists, merge intelligently – preserve valuable content while updating outdated sections Write concise, actionable instructions (~20-50 lines) using markdown structure Include specific examples from the codebase when describing patterns Avoid generic advice (“write tests”, “handle errors”) – focus on THIS project’s specific approaches Document only discoverable patterns, not aspirational practices Maintaining a history or features listing with a detailed description of all the information of the project into a README.md file whenever there is a new change. Update the file accordingly with a brief summary. Before each task implementation, go through the README.md file, then start implementing, understanding the whole picture of the requirements. Reference key files/directories that exemplify important patterns Update .github/copilot-instructions.md for the user, then ask for feedback on any unclear or incomplete sections to iterate.

When writing unit tests use xunit and moq

And here is the markdown file that CoPilot generated for me (put this into a file and open it in VS to see it displayed nicely):

# GitHub Copilot Instructions for HyperVideo

HyperVideo is an interactive video learning platform built with **.NET 10** and **Blazor Server**. Users can pause videos, ask questions, and search multiple knowledge sources for learning resources.

## Project Structure

```
HyperVideo/
├── Components/
│   ├── App.razor               # Root component (HTML shell, Bootstrap, Blazor script)
│   ├── Routes.razor            # Router with 404 fallback and default layout
│   ├── _Imports.razor          # Global using directives for all components
│   ├── Layout/
│   │   ├── MainLayout.razor    # Two-column layout: sidebar NavMenu + main content area
│   │   ├── NavMenu.razor       # Navigation links (Home, Video Learning, Counter, Weather)
│   │   └── ReconnectModal.razor # SignalR reconnection overlay
│   └── Pages/
│       ├── Home.razor          # Landing page with link to video learning
│       ├── VideoLearning.razor # Core feature: interactive video player with inquiry panel
│       ├── Counter.razor       # Simple stateful counter demo
│       ├── Weather.razor       # Async data fetch demo with streaming render
│       ├── Error.razor         # Error boundary page
│       └── NotFound.razor      # 404 page
├── wwwroot/
│   ├── app.css                 # Global styles
│   └── lib/                   # Bootstrap 5 CSS/JS
├── Program.cs                  # App startup and middleware pipeline
├── appsettings.json
└── HyperVideo.csproj
```

## Technology Stack

- **Runtime**: .NET 10 (`net10.0`)
- **UI**: Blazor Server with Interactive Server rendering (`@rendermode InteractiveServer`)
- **Real-time**: ASP.NET Core SignalR (used implicitly by Blazor Server)
- **CSS**: Bootstrap 5, Bootstrap Icons (`bi-*`), component-scoped CSS files (`.razor.css`)
- **JS Interop**: `IJSRuntime` for controlling the HTML5 `<video>` element
- **Nullable**: enabled; **ImplicitUsings**: enabled

## Coding Conventions

### Blazor Components
- Place all pages under `Components/Pages/` with `@page "/route"` directives.
- Place shared layout under `Components/Layout/`.
- Use `@rendermode InteractiveServer` on pages that need interactivity (event handlers, JS interop).
- Component-scoped CSS goes in a sibling file named `ComponentName.razor.css`.
- Use `@code { }` blocks at the bottom of `.razor` files for C# logic.

### C# Style
- Follow standard C# conventions: PascalCase for types and methods, camelCase for private fields.
- Prefer `record` types for immutable data (e.g., `TranscriptSegment`).
- Use nullable reference types; annotate `string?` where null is expected.
- Use `string.Empty` instead of `""` for empty-string defaults.
- Prefer `async Task` over `async void` for event handlers.

### JavaScript Interop
- Inject `IJSRuntime` with `@inject IJSRuntime JS`.
- Prefer `JS.InvokeVoidAsync` for fire-and-forget calls and `JS.InvokeAsync<T>` when a return value is needed.
- Avoid `eval()` for new interop code; instead, expose named JavaScript functions in `wwwroot/` and call them by name.
- Always wrap JS interop calls in `try/catch` because the circuit may not be ready.

### State Management
- Use private fields and `StateHasChanged()` for local component state.
- Keep models close to where they are used; only extract to a separate file when shared across multiple components.

### Error Handling
- Wrap async event handlers in `try/catch` and log errors with `Console.WriteLine` or an injected `ILogger<T>`.
- Use the `Error.razor` page as the global error boundary (already wired via `<ErrorBoundary>`).

## Key Feature: VideoLearning.razor

`VideoLearning.razor` is the core component. Its responsibilities:

| Concern | Implementation |
|---|---|
| Video playback | HTML5 `<video>` element; JS interop to call `.pause()`, `.play()`, seek |
| Pause & Inquire | Sets `isPaused = true`, shows inquiry panel with timestamp |
| Question search | Builds URL links to Wikipedia, Wiktionary, YouTube, Stack Overflow, MDN |
| Transcript | `List<TranscriptSegment>` displayed as clickable rows; active row highlighted |
| Time tracking | `@ontimeupdate` reads `currentTime` via JS interop |

When extending this component:
- Add new search sources by appending to `searchResults` inside `SearchForAnswer()`.
- Add transcript segments by adding `new TranscriptSegment(start, end, "text")` entries.
- Use `ElementReference` + `JS.InvokeVoidAsync("blazorHelpers.seekVideo", videoElement, time)` style helpers rather than bare `eval()`.

## Common Patterns

### Adding a New Page
```razor
@page "/my-page"
@rendermode InteractiveServer

<PageTitle>My Page</PageTitle>

<!-- markup -->

@code {
    // component logic
}
```
Then add a `<NavLink>` entry in `NavMenu.razor`.

### Injecting a Service
Register in `Program.cs`:
```csharp
builder.Services.AddScoped<IMyService, MyService>();
```
Inject in component:
```razor
@inject IMyService MyService
```

### JS Interop Helper Pattern
Add a function to `wwwroot/app.js` (create if it does not exist):
```javascript
window.blazorHelpers = {
    seekVideo: (element, time) => { element.currentTime = time; }
};
```
Call from C#:
```csharp
await JS.InvokeVoidAsync("blazorHelpers.seekVideo", videoElement, time);
```

## Build & Run

```bash
# Restore and run
 dotnet run --project HyperVideo/HyperVideo.csproj

# Build only
dotnet build HyperVideo/HyperVideo.csproj
```

Default URLs: `http://localhost:5092` / `https://localhost:7288`

## What to Avoid

- Do **not** use `@rendermode InteractiveWebAssembly` — this project is Blazor Server only.
- Do **not** add NuGet packages without checking compatibility with `net10.0`.
- Do **not** use bare `eval()` strings for new JS interop; prefer named helper functions.
- Do **not** use `async void` event handlers; use `async Task` and handle exceptions.
- Do **not** store secrets in `appsettings.json`; use environment variables or the .NET Secret Manager.

This is based on the skeleton program written in the past couple of postings, so it didn’t have all that much to go on. Nonetheless, it created a great context file with very specific instructions for CoPilot that will create a consistent interface and programming approach.

More to come as we develop HyperVideo but this will put us on the right track straight away.

• Writing prompts
• Writing apps that integrate AI (see Hypervideo)

If you are writing apps, you have a couple choices (well, more than a couple). One choice is to stay in the Azure/.NET world, in which case C# is just fine. The other (set of) choice(s) is to work in the rest of AI development, in which case Python is the language of choice.

I’m taking a course on agentics from Johns Hopkins University, and that course is in Python. It turns out that learning Python is pretty easy if you are a C# programmer, and it is even easier if you are a C# programmer with access to CoPilot and/or ChatGPT for Python.

I resisted learning Python all these years, but I’ve come to believe that if you are serious about AI then Python is in your future. So, might as well bite the bullet and get started now.

It’s Just Syntax

All the concepts are the same (more or less). There are variables, loops, dictionaries, tuples and so forth. Some of the syntax is different (no braces) and some of the rules vary a bit (tuples are immutable), but it won’t take you long to learn. Let’s start with the basics.

DataTypes: Python has only three numeric datatypes: int, float and complex. It also has str (string) and bool. One thing to watch for is truthy v true. True requires a bool but truthy is anything that evaluates to true. Huh? If a variable is of type bool, it can only. have one of two values: true or false. But an expression can evaluate to true (e.g., 5+7 = 12) which is truthy.

There are also collections. some are ordered: list (which is mutable), tuple (which is not mutable) and range (which is an immutable arithmetic progression). In addition, there is dict — a dictionary which works much like a dictionary in c#

If you need a dictionary with unique values, there is the set, which comes in two flavors: set (mutable) and frozenset (immutable)

Finally, None does the work of void

According to ChatGPT the core types you’ll use 90% of the time are:

• int
• float
• str
• bool
• list
• dict
• tuple
• set
• none

which pretty much corresponds to the big types in c# (except, perhaps set).

Indentation One big thing for C# programmers to watch out for is indentation. Python does not use braces in if statements, functions, etc.; it uses indentation.

if (myAge > 5)
   print("You are a big boy")
else
   print("You still have some growing to do")
   print("But don't worry, we all went through it")
print("this line is not in the if/else")

Notice that the last print statement is not in the if/else construct. Oh, there is also an elif statement so that you can have if, elif, elif, else.

Function definition You define a function with the keyword def and you use indentation to set the contents of the function:

def greet(name):
    print("Hello")
    print(name)

Some quick rules on indentation:

• Typically you indent 4 spaces (but that is not really a rule)
• All indentation must be the same amount
• You cannot mix tabs and spaces

Don’t forget to nest your indentation

def check_age(age):
    if age >= 21:
        print("Can drink")
    else:
        print("Cannot drink")

Lists Lists are created with square brackets

numbers = [10, 20, 30, 40]

Notice you do not put the type. You never declare the type, it is inferred. (this is true for all declarations, not just collections)

You iterate over lists with a very similar syntax to C#’s foreach

for number in numbers:
   print(number)

Don’t forget the colon!

Dictionaries Dictionaries are similar to lists, but you declare them with curly braces. You iterate over them using the key and the value:

students = {
    1001: "Alice",
    1002: "Bob"
}

for student_id, name in students.items():
    print(student_id, name)

This will print

1001 Alice
1002 Bob

You can access both with .items() or the keys with .keys() or the values with .values()

Tuples Tuples can be declared with or without parentheses

coordinates = (15, 20)
colors = ("red", "greeen", "blue", "yellow")
point = 5,10

You can iterate over a tuple

for color in colors:
   print(color)

A common thing to do with tuples is called unpacking. For example, using the point from above, you can write

point = (10, 20)

x, y = point
print(x)  # 10
print(y)  # 20

Or you can use this in loops, which is a common construct

pairs = ((1, "A"), (2, "B"), (3, "C"))

for number, letter in pairs:
    print(number, letter)

That’s plenty to get you started with Python. Of course there are more advanced constructs, and we’ll tackle them as we go, but these are the fundamentals.

1. Run the video and show a transcript in real time
2. Pause the video and type in any question on related or other topics (first cut)
3. Add speech recognition
4. Pause the video and be offered questions related to what was just said in the video
5. Ask a question and see a (hyper) video in response (a button appears to take you back one video)
6. Add text-to-speech to answer questions
7. Add history of previous questions to serve as context for future questions
8. Add quizzes at the end of the video
9. Add ability to scroll back in the transcript and be offered questions about the selected time slice or hypervideo link from there
10. Add hyperlinks to the transcript. Following the link potentially brings up new videos

More to follow, I’m sure, but that’s a pretty good starting list.

Here is 2026’s list…

Lists are always subjective, but it is helpful, I think, to exchange favorites now and again. Here’s my list in no particular order

1. Visual Studio 2026 – goes without saying that this is the world’s best IDE for .NET developers. I use it 8-12 hours a day; it just keeps getting better, especially with CoPilot.
2. Copilot – AI done right. Integrated with Visual Studio, this add-on is the most powerful and useful tool I have. It can get in the way a little, but when it does its stuff, watch out. Point it at a class and ask for documentation and/or unit tests and watch it go! More powerful is CoPilot Agents which will cook up substantial amounts of excellent code. But kids, don’t try this at home—it needs adult supervision.
3. ExamDiffPro – there are lots of comparison/merge utilities. Get a good one.
4. Tweaks by Mads Kristensen — small but very valuable addition to VS
5. Evernote: I use it to log everything I do, including every fix for recurring issues. It is quick, powerful, and easy to use. Although it has limitations, overall, I’ve found it helpful and reliable and it now holds thousands of notes for me. It does have a new transcription ability, but I find it somewhat limited (no summary, etc.) for that I use…
6. TalkNotes. This incredibly flexible iOS utility does just what it says: it takes notes and then will produce those notes in any number of ways, including custom reports. I use only a small portion of its potential, but they are critical to my workflow. (1) I use it to summarize meetings and tell me the action items, and (2) I dictate to it as I work so that I can ask, “What did I do 5 minutes ago that made this all break?” Note: this application type is exploding and there are many great competitors. One I have my eye on is Wave, which offers the ability to make inquiries about your meeting and which uses generative AI to provide meaningful answers.
7. WhisprFlow – by far the best dictation software I’ve seen. Only caveat is that this is for relatively brief dictation – enough to send a message, not enough to replace TalkNotes or Wave. On the other hand, WhisprFlow is available on iOS, Android, Mac, and Windows and works well on all (I don’t have Android, so can’t swear to that).
8. Roboform my password manager. I’d be lost without it. There are many, but this one is extremely straightforward and has been reliable for a very long time.
9. BlueSky—the single best social media site for .NET programmers
10. A note about Resharper. Many C# developers find it indispensable. Probably because I never became really proficient with it, and because VS has so many refactorings built in, I do not have it on my computer. But you may want to.

Note that nearly all of these are free. I do remember the days when a program like Lotus 123 cost something in the hundreds of dollars. It makes me laugh when I see people look at an app and say, “$4, naah, too expensive.” On the other hand, watch out for the AI apps, they can be over $100 / year.

I am not affiliated with any of these.