Event-driven architectures like this are a relatively common design pattern in distributed systems. Like other distributed development models, they have their own problems, especially at scale. When you’re getting tens or hundreds of events a minute, it’s easy to detect and respond to the messages you’re looking for. But when your application or service grows to several hundred thousands or even millions of messages across a global platform, what worked for a smaller system is likely to collapse under this new load.

At scale, event-driven systems become complex. Messages and events are delivered in many different forms and stored in independent silos, making them hard to extract and process and often requiring complex query mechanisms. At the same time, message queuing systems become slow and congested, adding latency or even letting messages time out. When you need to respond to events quickly, this fragile state of affairs becomes hard to use and manage.

That’s where Drasi comes in. It provides a better way to automate the process of detecting and responding to relevant events, an approach Microsoft describes as “the automation of intelligent reactions.” It is intended to be a lightweight tool that doesn’t need a complex, centralized store for event data, instead taking advantage of decentralization to look for events close to where they’re sourced, in log files and change feeds.

Core benefits of the Microsoft.Extensions.AI libraries include:

• Providing a consistent set of APIs and conventions for integrating AI services into .NET applications.
• Allowing .NET library authors to use AI services without being tied to a specific provider.
• Enabling .NET developers to experiment with different packages using the same underlying abstractions, maintaining a single API throughout an application.
• Simplifying the addition of new capabilities and facilitating the componentization and testing of applications.

Instructions on getting started with the Microsoft.Extensions.AI packages can be found in the October 8 blog post. Microsoft’s current focus is on creating abstractions that can be implemented across various services, the company said. There is no plan to release APIs tailored to any specific provider’s services. Microsoft’s goal is to act as a unifying layer within the .NET ecosystem, enabling developers to choose preferred frameworks and libraries while ensuring integration and collaboration across the ecosystem.

In explaining the libraries, Microsoft’s Luis Quintanilla, program manager for the developer division, said AI capabilities are rapidly evolving, with common patterns emerging for functionality such as chat, embeddings, and tool calling. Unified abstractions are crucial for developers to work across different sources, he said.

Unlike Electron, not very many mainstream desktop applications are built with Tauri, at least, not yet. Some of that may be due to Electron’s legacy presence, or the relative complexity of Rust versus JavaScript. But a fair number of apps, both commercial and open source, have been written with Tauri. The pgMagic GUI client for PostgreSQL, the Payload file transfer tool, and the Noor team chat app are examples.

IDG

Which is better: Tauri or Electron?

Right now, Electron remains the most prominent and well-understood of the cross-platform UI frameworks. For all the criticism levied against it, it’s still a popular default choice for delivering cross-platform applications with good system integration and a rich GUI. But complaints about Electron’s memory consumption and the size of its binaries are valid, and they aren’t going away soon. They’re intimately tied to the design of Electron apps, and only a redesign of either Electron or the underlying browser components will fix that issue.

Tauri apps are designed differently from the ground up to use less disk space and less memory. But that comes at the cost of it being a newer technology that relies heavily on Rust—a relatively new language, also with a relatively new development ecosystem. A commitment to Tauri requires a commitment to both Rust and JavaScript, for the back end and front end, respectively.

// script.js
const wsUri = "ws://localhost:3000";
const outputDiv = document.getElementById("output");
const messageInput = document.getElementById("message");
const sendButton = document.getElementById("send-btn");

let websocket;

function connect() {
    websocket = new WebSocket(wsUri);

    websocket.onopen = function (event) {
        outputDiv.innerHTML += "
Connected to server!
";
    };

    websocket.onmessage = function (event) {
        const receivedMessage = event.data;
        outputDiv.innerHTML += "
Received: " + receivedMessage + "
";
    };

    websocket.onerror = function (event) {
        outputDiv.innerHTML += "
Error: " + event.error + "
";
    };

    websocket.onclose = function (event) {
        outputDiv.innerHTML += "
Connection closed.
";
    };
}

sendButton.addEventListener("click", function () {
    const message = messageInput.value;
    if (websocket && websocket.readyState === WebSocket.OPEN) {
        websocket.send(message);
        messageInput.value = "";
    } else {
        outputDiv.innerHTML += "
Error: Connection not open.
";
    }
});

connect(); // Connect immediately

This script sets up several event handlers using the browser-native API. We start up the WebSocket as soon as the script is loaded and watch for open, onclose, onmessage, and onerror events. Each one appends its updates to the DOM. The most important one is onmessage, where we accept the message from the server and display it.

The Click handler on the button itself takes the input typed in by the user (messageInput.value) and uses the WebSocket object to send it to the server with the send() function. Then we reset the value of the input to a blank string.

Assuming the back end is still running and available at ws://localhost:3000, we can now run the front end. We can use http-server as a simple way to run the front end. It’s a simple way to host static files in a web server, akin to Python’s http module or Java’s Simple Web Server, but for Node. It can be installed as a global NPM package or simply run with npx, from the client directory:

Vendor dissatisfaction. Enterprises are not happy with major cloud providers due to service outages, egress fees, or lack of transparency around pricing and service-level commitments. Businesses are rethinking their cloud reliance and exploring on-premises alternatives.

A new way of thinking

I’ve often pointed out that the IT world is moving to heterogeneity and ubiquity, meaning that no approach, cloud or on-premises, will rise to the top and become “the standard.” I view this as a good thing, as long as we’re prepared to deal with the complexity it will bring. Thus far, many enterprises have stubbed their toe on that issue.

I’m now having these conversations often, whereas in the past, it was not spoken about in polite company–and certainly not at cloud conferences. Indeed, the concepts of multicloud and optimization are seeping back into the talks at significant events, when just a few years ago, presenters were pulling those slides out of their decks.

Joule will also be integrated into SAP Build Work Zone, a low-code tool for creating web sites. Joule’s generative AI capabilities will provide support while navigating data from connected business systems. All this will be available in SAP Build Work Zone standard edition, the SAP Start site, and the SAP Mobile Start app.

New capabilities such as code explanation and documentation search in SAP Build Code will assist Java and JavaScript developers, who will also be able to automate workflows in SAP Build Process Automation, with assistance from generative AI.

Early next year, SAP plans to extend Joule to help developers using ABAP (Advanced Business Application Programming), SAP’s high-level programming language, to generate high-quality code and unit tests that comply with SAP’s ABAP Cloud development model. Joule will also be able to generate explanations for legacy code, to ease the path to modernizing legacy codebases and the migration to a “clean core”, a modern ERP system without hard-coded customizations.

“This experience is not unique, but provides parity with other development environments,” said Park.

He pointed out that Databricks Apps has a lot of competition from business intelligence vendors supporting data apps such as Tableau, Qlik, Sisense and Qrvey. It also vies for market share with “mega vendors” including Microsoft, Oracle, SAP, Salesforce, ServiceNow, and Zoho. Then there are low-code and no-code apps such as Mendix, Appian, and Quickbase at the fringes of the market.

The most important “tactical capabilities” Databricks brings to the table with the new platform, Park noted, is the ability to reuse existing governance, launch from an open-ended serverless environment, and provide a single tool to manage data, infrastructure, and code applications all at once.