"Microsoft built things. It broke things." That's how the Seattle Times kicks off a series of articles celebrating Microsoft's 50th anniversary — adding that Microsoft also gave some people "a lucrative retirement early in their lives, and their own stories to tell." What did they remember from Microsoft's earliest days? Scott Oki joined Microsoft as employee no. 121. The company was small; Gates was hands-on, and hard to please. "One of his favorite phrases was 'that's the stupidest thing I've ever heard,'" Oki says. "He didn't use that on me, so I feel pretty good about that." Another, kinder phrase that pops to Oki's mind when discussing the international division he founded at Microsoft is "bringing home the bacon." An obsession with rapid revenue growth permeated Microsoft in those early days. Oki was about three weeks into the job as marketing manager when he presented a global expansion plan to Gates. "Had I done business internationally before? No," Oki said. "Do I speak a language other than English? No." But Gates gave Oki a $1 million budget to found the international division and sell Microsoft products overseas. He established subsidiaries in the most important markets at the time: Japan, United Kingdom, Germany and France. And, because he had a few bucks left over, Australia. "Of the initial subsidiaries we started, every single one of them was profitable in its first year," he says... Oki left Microsoft on March 1, 1992, 10 years to the day after he was hired. Other memories shared by early Microsoft employees: One recent graudate remembered her parents in Spokane saying "I think that's Mary and Bill Gates' son's company. If that kid is anything like those two, that is going to be a great company,'" She got her first job at Microsoft in 1992 — and 33 years later, she's a senior director at Microsoft Philanthropies. The Times also interviewed one of Microsoft's first lawyers, who remembers that "The day the U.S. government sued Microsoft ... that was a tough day for me. It kind of turned my world upside down for about the next eight years." Microsoft senior VP Brad Chase remembers negotiating with the Rolling Stones for the rights to their song "Start Me Up" for the Windows 95 ad campaign. ("Chase is quick to dispel any rumor that Mick Jagger called up Bill Gates and got $12 million. But he won't say how much the company paid.") But Chase does tell the Times that Bill Gates "used to say all of the time, 'We're going to bet the company on Windows.' That was a huge bet because Windows, frankly, was a lousy product in its early days."

Read more of this story at Slashdot.

As Rust approaches its 10th anniversary, "there is an important piece of documentation missing that many other languages provide," notes the Rust Foundation. While there's documentation and tutorials — there's no official language specification: In December 2022, an RFC was submitted to encourage the Rust Project to begin working on a specification. After much discussion, the RFC was approved in July 2023, and work began. Initially, the Rust Project specification team (t-spec) were interested in creating the document from scratch using the Rust Reference as a guiding marker. However, the team knew there was already an external Rust specification that was being used successfully for compiler qualification purposes — the FLS. Thank Berlin-based Ferrous Systems, a Rust-based consultancy who assembled that description "some years ago," according to a post on the Rust blog: They've since been faithfully maintaining and updating this document for new versions of Rust, and they've successfully used it to qualify toolchains based on Rust for use in safety-critical industries. [The Rust Foundation notes it part of the consultancy's "Ferrocene" Rust compiler/toolchain.] Seeing this success, others have also begun to rely on the FLS for their own qualification efforts when building with Rust. The Rust Foundation explains: The FLS provides a structured and detailed reference for Rust's syntax, semantics, and behavior, serving as a foundation for verification, compliance, and standardization efforts. Since Rust did not have an official language specification back then, nor a plan to write one, the FLS represented a major step toward describing Rust in a way that aligns with industry requirements, particularly in high-assurance domains. And the Rust Project is "passionate about shipping high quality tools that enable people to build reliable software at scale," adds the Rust blog. So... It's in that light that we're pleased to announce that we'll be adopting the FLS into the Rust Project as part of our ongoing specification efforts. This adoption is being made possible by the gracious donation of the FLS by Ferrous Systems. We're grateful to them for the work they've done in assembling the FLS, in making it fit for qualification purposes, in promoting its use and the use of Rust generally in safety-critical industries, and now, for working with us to take the next step and to bring the FLS into the Project. With this adoption, we look forward to better integrating the FLS with the processes of the Project and to providing ongoing and increased assurances to all those who use Rust in safety-critical industries and, in particular, to those who use the FLS as part of their qualification efforts. More from the Rust Foundation: The t-spec team wanted to avoid potential confusion from having two highly visible Rust specifications in the industry and so decided it would be worthwhile to try to integrate the FLS with the Rust Reference to create the official Rust Project specification. They approached Ferrous Systems, which agreed to contribute its FLS to the Rust Project and allow the Rust Project to take over its development and management... This generous donation will provide a clearer path to delivering an official Rust specification. It will also empower the Rust Project to oversee its ongoing evolution, providing confidence to companies and individuals already relying on the FLS, and marking a major milestone for the Rust ecosystem. "I really appreciate Ferrous taking this step to provide their specification to the Rust Project," said Joel Marcey, Director of Technology at the Rust Foundation and member of the t-spec team. "They have already done a massive amount of legwork...." This effort will provide others who require a Rust specification with an official, authoritative reference for their work with the Rust programming language... This is an exciting outcome. A heartfelt thank you to the Ferrous Systems team for their invaluable contribution! Marcey said the move allows the team "to supercharge our progress in the delivery of an official Rust specification." And the co-founder of Ferrous Systems, Felix Gilcher, also sounded excited. "We originally created the Ferrocene Language Specification to provide a structured and reliable description of Rust for the certification of the Ferrocene compiler. As an open source-first company, contributing the FLS to the Rust Project is a logical step toward fostering the development of a unified, community-driven specification that benefits all Rust users."

Read more of this story at Slashdot.

A year ago, Bluesky was opening up to the public and was known as one of the many X competitors that emerged after Elon Musk acquired the network formerly known as Twitter. Today, Bluesky’s social network has grown to over 33 million users, while the technology it’s built upon — the AT Protocol (or ATProto […]

Last year Microsoft introduced Phi Silica and recently made an experimental release of the Windows App Sdk that can be used by Windows application to interact with Phi Silica. In this post we’ll connect an Uno Platform application to Phi Silica.

We’ll keep things simple and start with the Blank preset in the Uno Platform template wizard and add Mvvm support under the Presentation section.

In order to access the Phi Silica apis we’ll first need to update to the experimental release of the Windows App Sdk. With Uno, this is done by setting the WinAppSdkVersion property to the experimental version, 1.7.250127003-experimental3.

<PropertyGroup Condition="'$(TargetFramework)'=='net9.0-windows10.0.26100'">
    <WinAppSdkVersion>1.7.250127003-experimental3</WinAppSdkVersion>
</PropertyGroup>

The Phi Silica apis won’t appear whilst the Platform of the project is set to AnyCPU. To resolve this, we need to set both the Platforms and RuntimeIdentifiers properties, when the application is targeting Windows.

<PropertyGroup Condition="'$(TargetFramework)'=='net9.0-windows10.0.26100'">
    <Platforms>x86;x64;ARM64</Platforms>
    <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
    <WinAppSdkVersion>1.7.250127003-experimental3</WinAppSdkVersion>
</PropertyGroup>

After making this adjustment, open Configuration Manager and make sure the Platform value is set to the correct architecture.

Let’s add a MainViewModel that will be used to send a message to Phi Silica and get a response.

using Microsoft.UI.Xaml.Data;
#if WINDOWS
using Microsoft.Windows.AI.Generative;
#endif

namespace PhiMessagingApp;

[Bindable]
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    private string _response = string.Empty;

    [RelayCommand]
    public async Task SendMessage(string message)
    {
#if WINDOWS

        if (!LanguageModel.IsAvailable())
        {
            var op = await LanguageModel.MakeAvailableAsync();
        }

        using LanguageModel languageModel = await LanguageModel.CreateAsync();
        var result = await languageModel.GenerateResponseAsync(message);
        Response = result.Response;
#else
        Response = "Design-time response....";
#endif
    }
}

Next we’ll set an instance of the MainViewModel as the DataContext on the MainPage.

public MainPage()
{
    this.InitializeComponent();
    DataContext = new MainViewModel();
}

Whilst the Phi Silica APIs only work on Windows, for the purpose of designing the interface we’ll switch target to Desktop.

We’ll run the application and should see both Hot Design and Hot Reload buttons in the floating toolbar.

Clicking the Hot Design (left) button will enter the design experience. We’ll keep things simple by adding a TextBox (message input), Button (to invoke the SendMessage method) and TextBlock (response output). The following video shows adding these elements along with databinding the elements.

Now, with everything wired up we can switch back to the PhiMessagingApp (WinAppSDK Packaged) target.

Unfortunately, at this point you’ll likely run into the following exception:

System.Runtime.InteropServices.COMException: 'Interface not registered
Failed to find proxy registration for IID: {EBF3748D-1EF9-4B89-BA13-65D2B9EC04F0}.'

This exception is a result of the application running as self-contained, which is not supported by the experimental release, as noted in the docs.

Luckily, there’s a quick fix. We can adjust the WindowsAppSDKSelfContained property to false, which will resolve this issue.

<PropertyGroup Condition="'$(TargetFramework)'=='net9.0-windows10.0.26100'">
    <Platforms>x86;x64;ARM64</Platforms>
    <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
    <WinAppSdkVersion>1.7.250127003-experimental3</WinAppSdkVersion>
    <WindowsAppSDKSelfContained>false</WindowsAppSDKSelfContained>
</PropertyGroup>

Let’s go ahead and run the application and enter a prompt, “Why is the sky blue”, and see the response.

As you can see from this post, it’s easy to reference Phi Silca from an Uno Platform application. Whilst the APIs are for Windows only, this can be used to light up your cross platform application with locally executing AI when running on Windows.

The post AI on Windows: Chatting with Phi Silica appeared first on Nick's .NET Travels.

---

Welcome back, htmx explorer. Today, we’re unlocking two of the most powerful tools in the htmx toolbox: hx-target and hx-swap. These are the keys to making your Razor Pages do precisely what you want without breaking a sweat.

Why Targeting and Swapping Matter

When building interactive web pages, you don’t always want to replace the entire page every time you fetch new content. Sometimes, you want to update a small part of the page, like a form or a specific component. That’s where hx-target and hx-swap come in.

Let’s break down how these features work and see some real-world use cases.

Understanding hx-target

The hx-target attribute tells htmx where to place the response from a request. By default, htmx replaces the element that triggered the request, but you can specify any element you want.

Example Usage

Imagine you have a button that fetches user details without refreshing the page.

Index.cshtml

@page
@model IndexModel

<!DOCTYPE html>
<html>
<head>
    <title>htmx Targeting Demo</title>
    <script src="https://unpkg.com/htmx.org"></script>
</head>
<body>
    <h1>User Details</h1>

    <div id="user-info">
        <button hx-get="/Index?handler=GetUser" hx-target="#user-info">Load User Info</button>
    </div>
</body>
</html>

Index.cshtml.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;

namespace YourNamespace.Pages;

public class IndexModel : PageModel
{
    public IActionResult OnGetGetUser()
    {
        var userHtml = "<div><p>Name: John Doe</p><p>Age: 30</p></div>";
        return Content(userHtml, "text/html");
    }
}

What’s happening here? The button sends a request to /GetUser, and the result is injected into the #user-info div because of the hx-target attribute. Simple and effective.

Understanding hx-swap

Now let’s talk about hx-swap. It controls how the response is inserted into the target element. Here are your options:

• outerHTML (Default): Replaces the entire target element.
• innerHTML: Replaces only the contents of the target element.
• beforebegin: Inserts content before the target element.
• afterbegin: Inserts content inside the target element, before existing content.
• beforeend: Inserts content inside the target element, after existing content.
• afterend: Inserts content after the target element.

Example Usage

Suppose you have a list of items you want to update without replacing the entire list.

Index.cshtml

@page
@model IndexModel

<!DOCTYPE html>
<html>
<head>
    <title>htmx Swapping Demo</title>
    <script src="https://unpkg.com/htmx.org"></script>
</head>
<body>
    <h1>Item List</h1>

    <div id="item-list">
        <button hx-get="/Index?handler=AddItem" hx-swap="beforeend" hx-target="#item-list">Add Item</button>
        <div>Item 1</div>
        <div>Item 2</div>
    </div>
</body>
</html>

Index.cshtml.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;

namespace YourNamespace.Pages;

public class IndexModel : PageModel
{
    private static int _itemCount = 2;

    public IActionResult OnGetAddItem()
    {
        _itemCount++;
        var newItemHtml = $"<div>Item {_itemCount}</div>";
        return Content(newItemHtml, "text/html");
    }
}

In this example, hx-swap="beforeend" ensures that every time you click the button, a new item is added to the end of the list instead of replacing the entire list. That’s some serious power with minimal effort.

Use Cases for Dynamic Content Loading

The combination of hx-target and hx-swap is ideal for all kinds of scenarios, such as:

• Infinite Scrolling: Load more content when a user scrolls to the bottom of a page.
• Dynamic Forms: Adding or removing form elements without reloading the page.
• Comment Systems: Appending new comments without refreshing the comment thread.
• Real-time Updates: Swapping out parts of the UI based on live data.

Bringing It All Together

The true power of htmx lies in mixing and matching attributes to make your web apps more interactive without overloading them with client-side logic. Swapping and targeting with htmx is one of the simplest ways to improve your user experience with very little code.

Next up, we’ll be building full-fledged interactive applications where these techniques really shine. Stay tuned.

The post Swapping and Targeting Like a Pro: htmx Magic for Razor Pages appeared first on Chris Woody Woodruff.