alvinashcraft's blurblog

SwiftUI Editor Architecture (Text, Media, Forms at Scale) by Sebastien Lato
Friday January 23^rd, 2026 at 8:36 PM

DEV Community

Editors are the hardest category of apps to build.

Examples:

note apps
document editors
form builders
drawing tools
media annotators

They combine:

large mutable state
frequent updates
undo/redo
validation
autosave
performance constraints

This post shows how to design a scalable editor architecture in SwiftUI that stays:

fast
correct
testable
maintainable

🧠 The Core Principle

An editor is a state machine with commands.

If you mutate models directly, undo, autosave, and validation become impossible to reason about.

🧱 1. Document Model as the Single Source of Truth

struct Document {
    var title: String
    var blocks: [Block]
    var metadata: Metadata
}

Never bind the UI directly to persistence.

🧬 2. Command-Based Mutations

Every edit becomes a command:

protocol EditorCommand {
    func apply(to doc: inout Document)
    func undo(on doc: inout Document)
}

This enables:

undo/redo
change tracking
batching
autosave

🔁 3. Editor Engine

final class EditorEngine: ObservableObject {
    @Published private(set) var document: Document
    let undoStack = UndoStack()

    func perform(_ command: EditorCommand) {
        undoStack.perform(command)
        objectWillChange.send()
    }
}

The engine owns all changes.

🧭 4. Validation Pipeline

enum ValidationState {
    case valid
    case invalid([FieldError])
}

Validate:

on commit
on autosave
on publish

Never inline validation into views.

💾 5. Autosave System

func scheduleAutosave() {
    autosaveTask?.cancel()
    autosaveTask = Task {
        try await Task.sleep(nanoseconds: 2_000_000_000)
        await save()
    }
}

Triggered by:

command execution
focus loss
background entry

🧠 6. Partial Rendering for Performance

Large documents must render lazily:

LazyVStack {
    ForEach(document.blocks) { block in
        BlockView(block: block)
    }
}

Never render entire documents at once.

🧪 7. Testing Editor Behavior

Test commands, not UI:

func testInsertBlock() {
    var doc = Document(...)
    let cmd = InsertBlock(...)
    cmd.apply(to: &doc)

    XCTAssertEqual(doc.blocks.count, 2)
}

The UI becomes trivial.

⚠️ 8. Avoid Direct Bindings

Bad:

TextEditor(text: $document.title)

Good:

TextEditor(text: Binding(
    get: { engine.document.title },
    set: { engine.perform(UpdateTitleCommand($0)) }
))

This enforces consistency.

❌ 9. Common Editor Anti-Patterns

Avoid:

direct state mutation
UI-driven persistence
no command layer
no undo
no validation
full document re-rendering

These don’t scale.

🧠 Mental Model

Think:

User Action
 → Command
   → Editor Engine
     → Document State
       → UI Render

Not:

“The view changes the model”

🚀 Final Thoughts

Editor apps fail when:

state is mutated freely
undo is bolted on
performance is ignored

Command-driven editors:

scale
remain correct
are testable
feel professional

Read the whole story

alvinashcraft

25 seconds ago

reply

Pennsylvania, USA

Edith Wharton On Writing Fiction by Writers Write
Friday January 23^rd, 2026 at 8:35 PM

Writers Write

We’re writing about the award-winning author, Edith Wharton. In this post, we read about Edith Wharton on writing fiction.

Edith Wharton was born 24 January 1862, and died 11 August 1937

Wharton was an American literary author who wrote novels of manners. She was the author of The Age of Innocence, Ethan Frome, The House of Mirth, and The Custom of the Country. She wrote more than 50 books in 40 years, including fiction, short stories, historical novels, travel books, and criticism. Wharton’s stories often included social satire and comedy.

She was known for her stories about upper crust society. In her writing, Wharton was influenced by Henry James, and her themes included social change, ethical issues, and the constraints of upper-class society. In The Age of Innocence, she tells of a romance doomed by duty in 1870s ‘Old New York’. Like many of her other novels, The Age of Innocence has been adapted for film.

Edith Wharton was also a significant writer of ghost stories, drawing from her fear of the genre as a child to create chilling tales like ‘Pomegranate Seed‘, ‘Afterward‘, and ‘The Lady’s Maid’s Bell‘.

Wharton was thrilled to make friends with luminaries such as Henry James, Sinclair Lewis, Jean Cocteau, André Gide, Paul Bourget, and Percy Lubbock.

She was the first woman to receive the Pulitzer Prize for Fiction; an honorary Doctorate from Yale University; and full membership in the Academy of Arts and Letters. She was nominated for the Nobel Prize in Literature more than once.

She also wrote an autobiography, A Backward Glance, and penned The Writing of Fiction. ‘In The Writing of Fiction, Wharton provides general comments on the roots of modern fiction, the various approaches to writing a piece of fiction, and the development of form and style. She also devotes entire chapters to the telling of a short story, the construction of a novel, and the importance of character and situation in the novel.’ (via)

In this post, I will share some of her best writing advice.

Edith Wharton On Writing Fiction

1. The Middle Is The Hardest Part

‘What is writing a novel like?
1. The beginning: A ride through a spring wood.
2. The middle: The Gobi desert.
3. The end: A night with a lover.
I am now in the Gobi desert.’ (Diary entry from 1934, when working on The Buccaneers via Penguin Random House)

2. Have A New Vision

‘True originality consists not in a new manner but in a new vision. That new, that personal, vision is attained only by looking long enough at the object represented to make it the writer’s own.’ (The Writing of Fiction by Edith Wharton)

3. Don’t Be Afraid To Use The Same Plots

‘Another unsettling element in modern art is that common symptom of immaturity, the dread of doing what has been done before.’ (The Writing of Fiction by Edith Wharton)

‘Every dawning talent has to go through a phase of imitation and subjection to influences, and the great object of the young writer should be not to fear those influences, but to seek only the greatest, and to assimilate them so they become [her] stock-in-trade.’ (From a letter, 1918)

4. Immerse The Reader In The Story

‘The least touch of irrelevance, the least chill of inattention, will instantly undo the spell, and it will take as long to weave again as to get Humpty Dumpty back on his wall.’ (The Writing of Fiction by Edith Wharton)

5. Believe In Yourself

‘At last I had groped my way through to my vocation, and thereafter never questioned that storytelling was my job … The Land of Letters was hence forth to be my country and I gloried in my new citizenship.’ (From her autobiography, A Backward Glance. She describes how she felt at the publication of her first collection of short stories.)

‘My literary success puzzled and embarrassed my old friends far more than it impressed them, and in my own family it created a kind of constraint which increased with the years. None of my relations ever spoke to me of my books, either to praise or to blame — they simply ignored them …
At first I felt this indifference acutely; but now I no longer cared, for my recognition as a writer had transformed my life.’ (From her autobiography, A Backward Glance)

‘I have often wondered, in looking back at the slow stammering beginnings of my literary life, whether or not it is a good thing for the creative artist to grow up in an atmosphere where the arts are simply non-existent. Violent opposition might be a stimulus–but was it helpful or the reverse to have every aspiration ignored, or looked at askance?’ (From her autobiography, A Backward Glance)

6. Find Your Tribe

‘My long experimenting had resulted in two or three books which brought me more encouragement than I had ever dreamed of obtaining, and were the means of my making some of the happiest friendships of my life.
The reception of my books gave me the self-confidence I had so long lacked, and in the company of people who shared my tastes, and treated me as their equal, I ceased to suffer from the agonizing shyness which used to rob such encounters of all pleasure.’ (From her autobiography, A Backward Glance)

7. Create Your Characters For The Format

‘No subject in itself, however fruitful, appears to be able to keep a novel alive; only the characters in it can. Of the short story the same cannot be said. Some of the greatest short stories owe their vitality entirely to the dramatic rendering of a situation.’ (The Writing of Fiction by Edith Wharton)

8. Take The Critics With A Pinch Of Salt

‘After all, one knows one’s weak points so well, that it’s rather bewildering to have the critics overlook them & invent others that (one is fairly sure) don’t exist — or exist in a less measure.’ (Letter to Robert Grant, 19 November 1907)

9. Prevent Author Intrusion

‘I have never known a novel that was good enough to be good in spite of its being adapted to the author’s political views.’ (Letter to Upton Sinclair, 19 August 1927)

10. Let Your Characters’ Changes Seem Natural

‘The other difficulty is that of communicating the effect of the gradual passage of time in such a way that the modifying and maturing of the characters shall seem not an arbitrary sleight-of-hand but the natural result of growth in age and experience. This is the great mystery of the art of fiction. The secret seems incommunicable; one can only conjecture that it has to do with the novelist’s own deep belief in his characters and what he is telling about them.’ (The Writing of Fiction by Edith Wharton)

11. Work With A Mentor

‘He [Walter Berry] alone not only encouraged me to write, as others had already done, but had the patience and the intelligence to teach me how. Others praised, some flattered–he alone took the trouble to analyze and criticise. The instinct to write had always been there; it was he who drew it forth, shaped it and set it free.’ (From her autobiography, A Backward Glance)

12. Have Something Important To Say

‘A good subject, then, must contain in itself something that sheds a light on our moral experience. If it is incapable of this expansion, this vital radiation, it remains, however showy a surface it presents, a mere irrelevant happening, a meaningless scrap of fact torn out of its context.’ (The Writing of Fiction by Edith Wharton)

13. Embrace Ideas

‘Ah, good conversation – there’s nothing like it, is there? The air of ideas is the only air worth breathing.’ (The Age of Innocence by Edith Wharton)

Source for photograph: E. F. Cooper, Newport, Rhode Island, Public domain, via Wikimedia Commons

Amanda Patterson

by Amanda Patterson

If you enjoyed this post, you will love:

Top Tip: Find out more about our workbooks and online courses in our shop.

The post Edith Wharton On Writing Fiction appeared first on Writers Write.

Read the whole story

alvinashcraft

1 minute ago

reply

Pennsylvania, USA

White House caught altering press release photos by Séamus Bellamy
Friday January 23^rd, 2026 at 8:34 PM

Boing Boing

With the Trump administration trying so hard to alter reality by destroying information on once useful government websites, holding a line of denialist bullshit on the murder and detainment of American citizens by overzealous Gravy SEALs, and insisting that tariffs are good for the American people, it's not surprising to see the greasy buggers caught in another lie. — Read the rest

The post White House caught altering press release photos appeared first on Boing Boing.

Read the whole story

alvinashcraft

1 minute ago

reply

Pennsylvania, USA

A Practical Demo of Zero-Downtime Migrations Using Password Hashing by milan@milanjovanovic.tech (Milan Jovanović)
Friday January 23^rd, 2026 at 8:34 PM

Milan's .NET Weekly

Push updates live faster with RunPod
Spin up compute and storage in seconds with RunPod. Deploy serverless inference that scales automatically, with no manual tuning or capacity planning. Push updates live, iterate fast, and monitor everything in one place with logs, and metrics built in. RunPod is infrastructure for AI startups and technical teams who want to stay in flow, move fast, and spend less time on cloud plumbing and more time shipping real products. Explore Runpod

Data Engineering Design Patterns - Book Giveaway from Buf
Buf Schema Registry brings type safety to data pipelines with Protobuf. Manage schemas centrally, validate changes, and generate Python code automatically. Plus: Buf is giving away an O'Reilly Media book, Data Engineering Design Patterns with proven solutions to idempotency, error handling, observability challenges and more. Get your copy now.

Sponsor this newsletter →

Security requirements evolve. What was considered "secure enough" five years ago might not pass a security audit today.

You need to upgrade to a modern algorithm like Argon2 or Bcrypt. But here is the problem: hashing is a one-way operation. You cannot reverse-engineer the existing hashes to "upgrade" them.

If you simply swap your IPasswordHasher implementation, you break the application. Every single existing user who tries to log in will fail authentication because your new hasher doesn't understand the old format.

In this article, I want to demo a zero-downtime migration concept in practice.

Real systems have more constraints (and you should not build auth from scratch). But this is a clean example of a pattern you can reuse for database migrations:

Move from old format to new format
Keep existing behavior working
Gradually migrate data
Delete legacy only when you are done

Let's dive in.

The Naive Approach and Why It Fails

Let's imagine you have a simple authentication system. You want to replace your legacy PBKDF2 hasher with a standard Argon2 implementation.

You might think, "I'll just register the new implementation in the dependency injection container."

// Switching from LegacyHasher to ModernHasher
builder.Services.AddSingleton<IPasswordHasher, ModernHasher>();

Here is the failure scenario:

New Users: They register and log in perfectly. Their passwords are hashed with Argon2 from day one.
Existing Users: A user enters their correct password. The system fetches the old PBKDF2 hash from the database.
The Crash: The ModernHasher tries to verify the PBKDF2 hash. It fails immediately, returning 401 Unauthorized.

You have inadvertently locked out your entire user base. We need a way to support both algorithms simultaneously without making the login code a mess.

The strategy is simple: we don't migrate the database in a batch job. We migrate users lazily when they prove their identity.

The flow looks like this:

Attempt 1: Try to verify the password using the New algorithm.
Attempt 2 (Fallback): If that fails, check if the Legacy algorithm can verify it.
The Migration: If the Legacy verification succeeds:
- Log the user in (Success).
- Immediately re-hash their password using the New algorithm.
- Update the database record.

Future logins for this user will now succeed via the standard flow.

A sequence diagram showing the migration on login flow, with attempts to verify using new and legacy hashers.

Implementation with .NET Keyed Services

In .NET 8, Microsoft introduced Keyed Services, which are perfect for this scenario. They allow us to register multiple implementations of the same interface and retrieve them by name.

1. Registering the Services

We register both hashers in our Program.cs, assigning them unique keys:

// Register the implementations with specific keys
builder.Services.AddKeyedSingleton<IPasswordHasher, Pbdkf2PasswordHasher>("legacy");
builder.Services.AddKeyedSingleton<IPasswordHasher, Argon2PasswordHasher>("modern");

// (Optional) Register the modern one as the default for other services
builder.Services.AddSingleton<IPasswordHasher, Argon2PasswordHasher>();

Now we implement the migration logic. We inject both hashers using the [FromKeyedServices] attribute.

public class LoginCommandHandler(
    IUserRepository userRepository,
    [FromKeyedServices("modern")] IPasswordHasher newHasher,
    [FromKeyedServices("legacy")] IPasswordHasher legacyHasher)
{
    public async Task<AuthenticationResult> Handle(LoginCommand command)
    {
        var user = await userRepository.GetByEmailAsync(command.Email);
        if (user is null)
        {
            return AuthenticationResult.Fail();
        }

        // 1. Try the new algorithm first (Happy Path)
        if (newHasher.Verify(user.PasswordHash, command.Password))
        {
            return AuthenticationResult.Success(user);
        }

        // 2. Fallback: Check if it's a legacy hash
        if (legacyHasher.Verify(user.PasswordHash, command.Password))
        {
            // 3. MIGRATION STEP: Re-hash and save
            var newHash = newHasher.Hash(command.Password);

            user.UpdatePasswordHash(newHash);
            await userRepository.SaveChangesAsync();

            return AuthenticationResult.Success(user);
        }

        return AuthenticationResult.Fail();
    }
}

This code ensures that active users are automatically upgraded. After a few months, the vast majority of your user base will be on the new algorithm.

Real-World Improvements

While the implementation above works, here are two improvements to make it production-ready.

1. Algorithm Prefixes

Relying on "trial and error" verification works, but it's cleaner to know exactly which algorithm was used to create a hash.

Standard algorithms often include a prefix (e.g., Bcrypt starts with $2a$ or $2b$ ). You can use this to route the request efficiently:

public bool IsLegacyHash(string hash)
{
    // This assumes we're storing a prefix for PBKDF2 hashes. Something to consider.
    return hash.StartsWith("pbkdf2$");
}

Another benefit this unlocks is being able to query the database for users still on the legacy format.

2. Feature Flags

Performing a database write during a login request adds latency. If you have high traffic, you might want to control this roll-out.

By wrapping the migration logic behind a Feature Flag, you can disable the "write" step if your database comes under load, while still allowing users to log in via the read-only fallback.

if (await featureManager.IsEnabledAsync(FeatureFlags.MigratePasswords) &&
    legacyHasher.Verify(user.PasswordHash, command.Password))
{
    // Perform migration...
}

Finishing the Migration

After you run this for a while (usually a few months), most active accounts will be upgraded. You can then run a cleanup script to identify any remaining legacy hashes and force those users to reset their passwords on the next login attempt.

At that point, you can remove:

The legacy hasher registration
The legacy verification code path
The feature flag

And the migration is complete.

Summary

A "simple" hashing upgrade is really a data migration. This article is about the migration pattern. Not about reinventing auth.

The zero-downtime pattern looks like this:

New format for new writes
Support both formats for reads
Migrate old data gradually (migrate-on-login is a great trick)
Put it behind a feature flag
Delete legacy when you are done

By allowing the old and new formats to coexist for a period of time, you achieve a seamless transition. Once your monitoring shows that 99% of active users have migrated, you can identify the users on the legacy format and force a password reset on their next attempt.

If you want to see a practical demo of this, check out this video I made.

Hope this was helpful!

Read the whole story

alvinashcraft

1 minute ago

reply

Pennsylvania, USA

DiffLog - The Laziest Way to Write Professional Changelogs by johnnys.news
Friday January 23^rd, 2026 at 8:34 PM

Johnnys.News

Just shipped a new version - code is deployed, tests passed, and now, time to look at the diff from the last release. Time to write a changelog that consists of more than just “fix stuff”, “wip”, “actually fix it this time”, “fixed the fixes” and “please work”. Now turn that into professional release notes. For developers. And end users. And maybe a tweet. And your boss wants an executive summary too. We all know how this ends - you either spend an hour crafting the perfect changelog, or you just dump the git log and call it a day. <h1 id="tl;dr">TL;DR<a title="#tl;dr" href="#tl;dr"></a></h1> I built DiffLog - a CLI tool that turns your git history into polished release notes using LLMs. It generates changelogs for different audiences and formats automatically. DiffLog open source and available on GitHub: <a href="https://github.com/nor0x/difflog" target="_blank">github.com/nor0x/difflog</a> and can be installed via <a href="https://www.nuget.org/packages/difflog" target="_blank">NuGet</a> <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>dotnet tool install -g DiffLog </pre></td></tr></table></figure> <img src="2026/01/DiffLog-The-Laziest-Way-to-Write-Professional-Changelogs/screenshot.jpg" alt="" loading="lazy" class="φbp"> <h1 id="because-your-git-log-isn't-a-changelog">Because Your Git Log Isn’t a Changelog<a title="#because-your-git-log-isn't-a-changelog" href="#because-your-git-log-isn't-a-changelog"></a></h1> I’m currently building several new products and apps, and they all need proper changelogs. But here’s the thing - different people care about different things. Developers want to know about API changes and breaking changes. End users want to know about new features and bug fixes in plain language. Marketing wants something snappy for social media. And executives want a high-level summary without the technical jargon. Writing the same changelog four times? Nope! That’s where LLMs come in - guess what, they’re really good at taking a bunch of commit messages and turning them into coherent, audience-appropriate release notes. I decided to build a tool that automates this entire process. <h1 id="introducing-difflog">Introducing DiffLog<a title="#introducing-difflog" href="#introducing-difflog"></a></h1> DiffLog is a CLI tool that scans your git history, groups changes into clear sections, and uses AI to format the result for different audiences. The key idea is simple: your commits already contain all the information needed for a changelog - it just needs to be transformed into something readable. <h2 id="generate-from-anywhere-in-your-history">Generate from anywhere in your history<a title="#generate-from-anywhere-in-your-history" href="#generate-from-anywhere-in-your-history"></a></h2> DiffLog can work with tags, commit ranges, or date filters: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>difflog generate --from v1.0.0 --to v1.1.0 # between tags difflog generate --from HEAD~20 # last 20 commits difflog generate --from-date 2026-01-01 # since a date difflog generate -i # interactive mode </pre></td></tr></table></figure> the interactive mode is particularly nice for exploring your options - it guides you through selecting references and output settings. <h2 id="multiple-audiences,-one-command">Multiple audiences, one command<a title="#multiple-audiences,-one-command" href="#multiple-audiences,-one-command"></a></h2> This is where DiffLog really shines. You can generate notes tailored to specific audiences: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>difflog generate -a Developers --format Markdown difflog generate -a EndUsers --format Html -o release-notes.html difflog generate -a SocialMedia --format PlainText difflog generate -a Executive --format Markdown </pre></td></tr></table></figure> each audience gets a different perspective on the same changes: <ul> <li>Developers: Technical details, API changes, breaking changes, migration notes</li> <li>EndUsers: User-facing features and improvements in plain language</li> <li>SocialMedia: Snappy, engaging summaries perfect for tweets or announcements</li> <li>Executive: High-level business impact without the technical jargon</li> </ul> <h2 id="output-formats">Output formats<a title="#output-formats" href="#output-formats"></a></h2> DiffLog supports multiple output formats to fit your workflow: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>difflog generate --format Markdown # great for GitHub releases difflog generate --format Html # for documentation sites difflog generate --format PlainText # for emails or simple READMEs difflog generate --format Json # for programmatic processing </pre></td></tr></table></figure> <h2 id="extra-goodies">Extra goodies<a title="#extra-goodies" href="#extra-goodies"></a></h2> By default, DiffLog includes links to issues/PRs and a contributor list. You can toggle these off if you prefer a cleaner output: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>difflog generate --no-links # skip issue/PR links difflog generate --no-contributors # skip contributor list difflog generate --exclude "chore,docs" # exclude certain categories </pre></td></tr></table></figure> <h1 id="custom-system-prompts">Custom system prompts<a title="#custom-system-prompts" href="#custom-system-prompts"></a></h1> The audience and format options are built-in and should be sufficient for most general use cases. But this information can be fully customized using your own system prompts. You can override the prompt by either passing it directly on the command line or loading it from a file: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 </pre></td><td class="code"><pre># store a custom prompt for an audience difflog config --audience Developers --system-prompt-file prompts/dev.txt # or override just for this run difflog generate --system-prompt "Focus on security improvements and performance gains" difflog generate --system-prompt-file prompts/social.txt </pre></td></tr></table></figure> this can be incredibly useful when you have specific formatting requirements or want to emphasize certain aspects of your release. The prompt resolution order is: <ol> <li>Command-line <code>--system-prompt</code> or <code>--system-prompt-file</code></li> <li>Stored prompt for the selected audience</li> <li>Built-in defaults</li> </ol> <h1 id="github-actions-integration">GitHub Actions integration<a title="#github-actions-integration" href="#github-actions-integration"></a></h1> This is where I have integrated DiffLog into my workflow. I use it in my CI/CD pipelines to automatically generate release notes whenever i push a new tag: <figure class="highlight yaml"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 </pre></td><td class="code"><pre>name: Generate Release Notes on: push: tags: - 'v*' jobs: release-notes: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 # Required for full git history - name: Setup .NET uses: actions/setup-dotnet@v4 with: dotnet-version: '10.0.x' - name: Install DiffLog run: dotnet tool install -g DiffLog - name: Generate Release Notes env: OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} run: | PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "") CURRENT_TAG=${GITHUB_REF#refs/tags/} if [ -n "$PREV_TAG" ]; then difflog generate --from $PREV_TAG --to $CURRENT_TAG --format Markdown -o release-notes.md else difflog generate --to $CURRENT_TAG --format Markdown -o release-notes.md fi - name: Create GitHub Release uses: softprops/action-gh-release@v2 with: body_path: release-notes.md </pre></td></tr></table></figure> you can also generate weekly changelogs or PR-based summaries: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>difflog generate --from-date $(date -d '7 days ago' +%Y-%m-%d) --format Markdown -o changelog.md </pre></td></tr></table></figure> You can check out the <a href="https://github.com/nor0x/difflog" target="_blank">DiffLog GitHub repository</a> for the actions and how the tool is used in the CI and publish workflows. <h1 id="configuration">configuration<a title="#configuration" href="#configuration"></a></h1> DiffLog reads configuration from environment variables or a saved config file: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>difflog config --api-key sk-... --model gpt-4o difflog config -i # interactive setup </pre></td></tr></table></figure> environment variables take precedence, which is perfect for CI/CD: <ul> <li><code>OPENAI_API_KEY</code></li> <li><code>OPENAI_BASE_URL</code> (for Azure OpenAI or compatible APIs)</li> <li><code>OPENAI_MODEL</code></li> </ul> you can also list available tags in any repository: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 </pre></td><td class="code"><pre>difflog tags --path . ── 📝 Tags ─────────────────────────────────────────── v1.0.0 v1.1.0 v1.2.0 v2.0.0 </pre></td></tr></table></figure> <h1 id="tech-stack">tech stack<a title="#tech-stack" href="#tech-stack"></a></h1> Building DiffLog was a fun exercise in combining CLI development with AI integration. Here’s what i used: <ul> <li>.NET 10 - the core runtime and NuGet packaging</li> <li>Spectre.Console - for the terminal UI and formatted tables</li> <li>Spectre.Console.Cli - for command-line parsing</li> <li><a href="http://Microsoft.Extensions.AI">Microsoft.Extensions.AI</a> - for the AI abstraction layer</li> <li>OpenAI client - for LLM integration (might add support for more providers later)</li> <li>OpenCode - Claude Opus 4.5 was my coding partner throughout the project</li> </ul> <a href="https://spectreconsole.net/" target="_blank">Spectre.Console</a> continues to be my go-to for building CLI applications in .NET. The interactive prompts and formatted output make the tool feel polished and professional. <h1 id="start-generating!-📝">Start generating! 📝<a title="#start-generating!-📝" href="#start-generating!-📝"></a></h1> If you’re tired of writing changelogs manually (or not writing them at all), give DiffLog a try: <figure class="highlight bash"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>dotnet tool install -g DiffLog difflog generate -i </pre></td></tr></table></figure> <h1 id="improvements">Improvements<a title="#improvements" href="#improvements"></a></h1> I might add support for other LLM providers such as Anthropic or Google in the future - just tried to keep the initial version focused and tailored for my own needs first. Feedback and contributions are very welcome! The source code is on GitHub at <a href="https://github.com/nor0x/difflog" target="_blank">github.com/nor0x/difflog</a> - feel free to play with it, fork it, and contribute. I’m actively using this for all my projects now, and it’s been a huge time saver.

Read the whole story

alvinashcraft

2 minutes ago

reply

Pennsylvania, USA

Agentic AI Foundation Announced
Friday January 23^rd, 2026 at 8:34 PM

I Programmer - full contents

Read the whole story

alvinashcraft

2 minutes ago

reply

Pennsylvania, USA

SwiftUI Editor Architecture (Text, Media, Forms at Scale) by Sebastien Lato Friday January 23rd, 2026 at 8:36 PM

🧠 The Core Principle

🧱 1. Document Model as the Single Source of Truth

🧬 2. Command-Based Mutations

🔁 3. Editor Engine

🧭 4. Validation Pipeline

💾 5. Autosave System

🧠 6. Partial Rendering for Performance

🧪 7. Testing Editor Behavior

⚠️ 8. Avoid Direct Bindings

❌ 9. Common Editor Anti-Patterns

🧠 Mental Model

🚀 Final Thoughts

Edith Wharton On Writing Fiction by Writers Write Friday January 23rd, 2026 at 8:35 PM

Edith Wharton On Writing Fiction

1. The Middle Is The Hardest Part

2. Have A New Vision

3. Don’t Be Afraid To Use The Same Plots

4. Immerse The Reader In The Story

5. Believe In Yourself

6. Find Your Tribe

7. Create Your Characters For The Format

8. Take The Critics With A Pinch Of Salt

9. Prevent Author Intrusion

10. Let Your Characters’ Changes Seem Natural

11. Work With A Mentor

12. Have Something Important To Say

13. Embrace Ideas

If you enjoyed this post, you will love:

White House caught altering press release photos by Séamus Bellamy Friday January 23rd, 2026 at 8:34 PM

A Practical Demo of Zero-Downtime Migrations Using Password Hashing by milan@milanjovanovic.tech (Milan Jovanović) Friday January 23rd, 2026 at 8:34 PM

DiffLog - The Laziest Way to Write Professional Changelogs by johnnys.news Friday January 23rd, 2026 at 8:34 PM

SwiftUI Editor Architecture (Text, Media, Forms at Scale) by Sebastien Lato
Friday January 23^rd, 2026 at 8:36 PM

Edith Wharton On Writing Fiction by Writers Write
Friday January 23^rd, 2026 at 8:35 PM

White House caught altering press release photos by Séamus Bellamy
Friday January 23^rd, 2026 at 8:34 PM

A Practical Demo of Zero-Downtime Migrations Using Password Hashing by milan@milanjovanovic.tech (Milan Jovanović)
Friday January 23^rd, 2026 at 8:34 PM

DiffLog - The Laziest Way to Write Professional Changelogs by johnnys.news
Friday January 23^rd, 2026 at 8:34 PM