Wie sich die Zeiten doch ändern: Ausgerechnet Microsoft liefert heute Open Source frei Haus. Richtig praktische und wirklich offene Werkzeuge für Entwickler reihte der Konzern auf der Build 2026 auf – ein quelloffenes KI-Terminal, hilfreiche Dev Configs, dazu WSL-Container und mehr als 75 Unix-Werkzeuge der Coreutils. Doch wer darin nur Entwicklerfreundlichkeit sieht, verpasst den eigentlichen Coup. Open Source ist inzwischen das perfekte Business für den Konzern.

Microsoft ging gegen offene Standards lange strategisch vor – und die Strategie trug in den 90ern ein berüchtigtes Kürzel: „EEE – Embrace, Extend, and Extinguish“. Das US-Justizministerium dokumentierte, wie der Konzern dabei vorging. Erst drang Microsoft in Märkte mit offenen Standards ein, dann erweiterte es diese Standards um proprietäre Funktionen, und schließlich nutzte es die so entstandenen Unterschiede, um die Konkurrenz auszuschalten.

Sofort wurde das zu Microsofts Geschäftspraxis: Zum Beispiel setzt Microsoft im Browserkrieg den Internet Explorer nicht nur offensiv gegen Netscape ein; interne Memos zeigen darüber hinaus, dass der Konzern Office und HTML-Funktionen so verzahnen wollte, dass sie als Hebel ausschließlich das eigene Ökosystem stärken.

Diesmal fehlt das dritte E

Doch die Ankündigungen der Build 2026 sind nicht einfach nur EEE 2.0 mit besserem Marketing. Das Umarmen war immer nur Mittel zum Zweck, und der Zweck hieß ersticken. Heute fehlt diese dritte Stufe.

Microsoft gibt bei den Werkzeugen, die Entwickler täglich nutzen, keinen Zentimeter Boden auf. Niemand muss migrieren oder sich umgewöhnen. Und niemand lockt den offenen Standard in eine proprietäre Sackgasse. Was hier an Reibung verschwindet, kostet Microsoft nur Entwicklungsaufwand – aber keinesfalls Marktmacht.

Nehmen wir als Beispiel die Datenbanken: Statt einer hauseigenen, geschlossenen Datenbank setzt Microsoft mit Azure HorizonDB auf das offene PostgreSQL. Die Botschaft: Bleibt bei Postgres, wir bauen die KI-Bausteine drumherum. Ausgerechnet der Konzern, der mit proprietären Datenbanken groß wurde, setzt jetzt auf die Open-Source-Alternative.

Die Motivation ist betriebswirtschaftlich, Satya Nadella hat das nie verheimlicht. Seit 2014 verschiebt Microsoft sein Kerngeschäft von der Lizenzsoftware zu den Plattformdiensten, und Nadella sagt offen, dass sich mit geschlossenen Lizenzen auf Dauer kein Staat mehr machen lässt. Warum eine Lizenz einmal verkaufen, wenn man dieselbe Leistung monatlich vermieten kann? Dass heute über die Hälfte der Azure-Workloads unter Linux laufen, gehört inzwischen zum Geschäftsmodell.

Microsoft kassiert trotzdem ab

Der Coup steckt im Business-Schlachtfeld selbst. Der Kampf heißt nicht mehr Windows gegen Open Source. Er heißt Cloud gegen Cloud. Die Maut kassiert Microsoft nicht mehr an der Systemgrenze, sondern beim Cloud-Dienst: bei Azure, bei GitHub, beim Copilot-Abo. Der Konzern stellt das Kassenhäuschen einfach woanders auf.

Selbst Steve Ballmer hat das inzwischen eingeräumt. Seine frühere Haltung sei für ihre Zeit richtig gewesen, doch die Linux-Bedrohung liege heute „im Rückspiegel“. Und die harte Linie habe dem Konzern damals mehr Umsatz gebracht, als ein frühes Umarmen es getan hätte. Erst kämpfen, dann kassieren, schließlich umarmen – aus Sicht der Bilanz hat sich jede Phase gelohnt.

Bleibt die Frage nach dem dritten E

Man sollte die Wende trotzdem nicht zu gutgläubig feiern. Viele Entwickler misstrauen dem freundlichen Microsoft bis heute aus gutem Grund. Als der Konzern 2021 eine Hot-Reload-Funktion aus dem quelloffenen .NET herauslösen wollte und sie erst nach lautem Protest zurückholte, blitzten die alten Reflexe wieder auf. Auch die heute „umarmten“ Werkzeuge wie GitHub, Copilot und Codespaces tragen proprietäre Schichten in sich. Jede Nutzung zentralisiert die Branche ein Stück weiter auf einen einzigen Anbieter.

Microsofts Open-Source-Zuneigung mag heute echt sein – aber sie entspringt eben nicht einem Altruismus, sondern dem nüchternen Kalkül, nicht wie einst IBM zu erstarren. Doch in fünf Jahren kann schon wieder eine andere Business-Logik gelten.

(fo)

Microsoft bringt in Version 1.123 von Visual Studio Code weitere neue Features für den Umgang mit großen Sprachmodellen. Dazu gehören synchronisierte Chat-Sessions über mehrere Geräte hinweg, ein vergrößertes Kontextfenster für spezielle Modelle und die Möglichkeit, multiple Agenten-Fenster parallel zu öffnen.

Synchronisierte (Agenten-)Chats

Als neue Standardfunktion synchronisiert Visual Studio Code nun Chat-Sessions zum GitHub-Account seiner Nutzerinnen und Nutzer, inklusive aller lokalen Agenten-Sessions. Wie Microsoft betont, seien die synchronisierten Chats privat, außer wenn Nutzer sie explizit teilen. Auf github.com erscheinen die Chats im Agents-Tab eines Repositories und lassen sich durchsuchen.

Wer die Synchronisierung nicht nutzen will, setzt die auf Organisationsebene bestehende Einstellung chat.sessionSync.enabled auf false.

Agentenvergleich auf einen Blick

Das Preview-Feature Agents Window hat eine neue Funktion erhalten: Neben einer geöffneten Agenten-Session lässt sich nun eine zusätzliche in „Side by Side“-Ansicht öffnen. Um eine weitere Session zu öffnen, wählen Entwicklerinnen und Entwickler im Kontextmenü einer Session innerhalb der Session-Liste Open to the Side aus, ziehen die gewünschte Session per Drag & Drop in den Sessions-Ansichtsbereich oder wählen sie bei gedrückter Alt-Taste aus.

Dabei ist zu beachten, dass jeweils nur eine der sichtbaren Sessions aktiv ist. Eine neue ausgewählte Session wird automatisch zur aktiven Session View, außer wenn die vorherige Session angepinnt wurde. Das Anpinnen erfolgt über die Pin-Aktion in der oberen rechten Ecke der View.

Ein weiteres Update betrifft das Kontextfenster unterstützter Anthropic- und OpenAI-Modelle: Es kann nun eine Million Token umfassen. Diese Erweiterung soll es Usern ermöglichen, mit deutlich größeren Codebasen zu arbeiten sowie längere Konversationen zu führen, ohne wichtigen Kontext einzubüßen.

Weitere Details zu den Neuerungen in Visual Studio Code 1.123 lassen sich der Ankündigung entnehmen.

Dabei handelt es sich nicht um die einzigen Updates im Bereich KI von Microsoft: Im Rahmen der in dieser Woche stattgefundenen Hauskonferenz Microsoft Build wurde unter anderem eine eigenständige Desktopanwendung für GitHub Copilot vorgestellt.

(mai)

IAsyncEnumerable ist die in .NET Core 3.0 eingeführte asynchrone Variante von IEnumerable. Sie ermöglicht asynchrone Streams: das schrittweise, nicht-blockierende Iterieren über Daten, die asynchron bereitgestellt werden.

LINQ-Operationen auf IAsyncEnumerable erforderten bisher das NuGet-Paket System.Linq.Async. Nun ist diese Funktionalität im Kern von .NET verfügbar.

Folgender Code nutzt Where() und OrderBy() mit IAsyncEnumerable:

namespace NET10_Console.FCL;

using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

public readonly record struct Kabinettsmitglied(string Name, string Amt);

/// 

/// LINQ auf IAsyncEnumerable erforderte bisher NuGet-Paket System.Linq.Async
/// 
public class FCL10_LINQAsyncEnumerable
{
 public async Task Run()
 {
  CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));

  // Hole Personen im Bundeskabinett
  var datenquelle = new Bundeskabinett().GetAll();

  // Asynchrone Iteration mit LINQ (Filtern und optional Sortieren)
  // Achtung: .OrderBy(x=>x.Name) führt dazu, dass foreach auf das letzte Element warten muss --> Vorteil von async entfällt :-(
  await foreach (var person in datenquelle.Where(x => x.Amt.Contains("ministerin")))
  {
   Console.WriteLine(DateTime.Now.ToLongTimeString() + ": " + person);
  }
 }

 public class Bundeskabinett
 {
  /// 

  /// Liefert alle Mitglieder des Bundeskabinetts (Stand: 21.09.2025) als Async-Stream.
  /// Quelle: Bundesregierung.de (siehe Code-Kommentar).
  /// 
  public async IAsyncEnumerable GetAll(
      [EnumeratorCancellation] CancellationToken cancellationToken = default)
  {
   // Quelle: 
   var daten = new List
        {
            new("Friedrich Merz", "Bundeskanzler"),
            new("Lars Klingbeil", "Bundesminister der Finanzen"),
            new("Alexander Dobrindt", "Bundesminister des Innern"),
            new("Dr. Johann Wadephul", "Bundesminister des Auswärtigen"),
            new("Boris Pistorius", "Bundesminister der Verteidigung"),
            new("Katherina Reiche", "Bundesministerin für Wirtschaft und Energie"),
            new("Dorothee Bär", "Bundesministerin für Forschung, Technologie und Raumfahrt"),
            new("Dr. Stefanie Hubig", "Bundesministerin der Justiz und für Verbraucherschutz"),
            new("Karin Prien", "Bundesministerin für Bildung, Familie, Senioren, Frauen und Jugend"),
            new("Bärbel Bas", "Bundesministerin für Arbeit und Soziales"),
            new("Dr. Karsten Wildberger", "Bundesminister für Digitales und Staatsmodernisierung"),
            new("Patrick Schnieder", "Bundesminister für Verkehr"),
            new("Carsten Schneider", "Bundesminister für Umwelt, Klimaschutz, Naturschutz und nukleare Sicherheit"),
            new("Nina Warken", "Bundesministerin für Gesundheit"),
            new("Alois Rainer", "Bundesminister für Landwirtschaft, Ernährung und Heimat"),
            new("Reem Alabali Radovan", "Bundesministerin für wirtschaftliche Zusammenarbeit und Entwicklung"),
            new("Verena Hubertz", "Bundesministerin für Wohnen, Stadtentwicklung und Bauwesen"),
            new("Thorsten Frei", "Bundesminister für besondere Aufgaben / Chef des Bundeskanzleramtes"),
        };

   foreach (var m in daten)
   {
    cancellationToken.ThrowIfCancellationRequested();
    yield return m;
    await Task.Delay(200); // Simuliere etwas Wartezeit
    await Task.Yield(); // sorgt für echte Asynchronität beim Streamen
   }
  }
 }
}

Ein Praxisbeispiel dazu: Folgender Code zeigt die Ausführung einer Reihe von HTTP-Aufrufen mit asynchroner Ausgabe der Ergebnisse via Task.WhenEach(). Hier ist nun ein Filtern mit Where() oder eine Sortierung mit OrderBy() möglich. Diese blockiert jedoch – wie üblich – die Weiterverarbeitung, bis das letzte Ergebnis vorliegt, und beeinträchtigt damit den Vorteil der asynchronen Ausführung.

public async Task Run()
{
 CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));
 Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: Starte Websiteabfragen...");
 using HttpClient http = new();
 Task t1 = http.GetAsync("
 Task t2 = http.GetAsync("
 Task t3 = http.GetAsync("
 Task t4 = http.GetAsync("
 Task t5 = http.GetAsync("
 Task t6 = http.GetAsync("
 Task t7 = http.GetAsync("
 // Liste aus Tasks
 List> taskList = new() { t1, t2, t3, t4, t5, t6, t7 };
 // WhenEach() gibt es seit .NET 9.0
 IAsyncEnumerable> taskList2 = Task.WhenEach(taskList);
 
 // NEU in .NET 10.0: LINQ auf IAsyncEnumerable
 taskList2 = taskList2.Where(x => x.Result.RequestMessage.RequestUri.ToString().Contains("dot"));
 taskList2 = taskList2.OrderBy(x => x.Result.RequestMessage.RequestUri.Host);

 await foreach (Task t in taskList2)
 {
  try
  {
   Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: {t.Status} {t.Result?.RequestMessage?.RequestUri} = {t?.Result?.StatusCode}"); // Status des HTTP-Aufrufs
  }
  catch (Exception ex)
  {
   CUI.Warning(ex);
  }
 }
}

(rme)