Mesh me up!

Microsoft’s Live Mesh ist ja nun endlich auch offiziell als Betaversion in Deutschland verfügbar. Grund genug, sich diese Web-Applikation einmal genauer anzuschauen…  Live Mesh (bzw. das derzeitige Frontend) ist (momentan!) vordergründig ein Online-Dienst zur Synchronisation von Daten zwischen mehreren Rechnern. Gerade für mich, der 3 Rechner besitzt und diese auch abwechselnd in Betrieb hat, kommt so eine Lösung gerade recht. Daten (z.B. Visual-Studio-Projekte), welche man auf allen seinen Rechnern immer auf dem aktuellsten Stand haben möchte, ohne z.B. über einen LAN-Server darauf zuzugreifen, können auf diese Art schnell synchronisiert werden.

Live Mesh

Mit seiner Windows-Live-ID hat man sich schnell beim Mesh-Dienst angemeldet und kann ein/sein Mesh anlegen. Zum Mesh gehört grundsätzlich eine Weboberfläche, über die neue Ordner angelegt werden können und über die sich neue Rechner/Geräte leicht in das bestehende Mesh aufnehmen lassen. Zudem steht über den „Live Desktop“ eine Art Desktop im Browser zur Verfügung, über den sich Dateien öffnen lassen und sogar Bilder angeschaut und Video-/Audio-Dateien abgespielt werden können. Die Datenhaltung erfolgt zentral, d.h. die zu synchronisierenden Daten liegen auf einem Server in einem MS-Datencenter, wobei der eigene Account über 5GB kostenlosen Speicher verfügt. Sensible Daten sollte man hier vielleicht nicht ablegen, je nachdem wie sehr man Microsoft vertraut 🙂  Dies ist sicher auch der größte Knackpunkt der Applikation, da nicht jeder Benutzer seine Daten auf einem Microsoft-Server halten möchte…

Clientseitig wird auf jedem Rechner, der an der Datensynchronisation teilhaben soll, eine kleine Desktop-Applikation installiert. Nachdem man den Rechner über die Webplattform zum Mesh hinzugefügt hat, lassen sich über diese Applikation schnell zu synchronisierende Ordner auswählen. Insgesamt erhält also jeder Client eine lokale Kopie der Ordner, die im Mesh abgelegt sind. Auf dieser Kopie kann gearbeitet werden und Dateien können geändert werden. Die Clientapplikation sorgt dann automatisch dafür, dass Änderungen zum zentralen Server hochgeladen werden und dann an die anderen angeschlossenen Geräte verteilt werden. So wird dafür gesorgt, dass die Dateien ohne Zutun des Benutzers auf dem aktuellen Stand sind. Benutzerfreundlicher kann man es kaum gestalten. Derzeit lassen sich Windows- und Mac-Rechner zum Mesh hinzufügen, bald sollen auch Mobiltelefone integriert werden können.

Nur zur Synchronisation?

Synchronisationssoftwares gibt es viele, Live Mesh bietet aber noch ein bisschen mehr. Über den Live Desktop kann man auch von Rechnern, die nicht an der Synchronisation teilhaben, auf Dateien zugreifen und neue Dateien hinzufügen. Die Webapplikation ist komplett in Silverlight geschrieben und gestaltet sich entsprechend intuitiv und benutzerfreundlich. Weiterhin kann man andere einladen und ihnen Zugriff auf einen Ordner gewähren. Somit lassen sich bestimmte Ordner leicht austauschen und gleichzeitig synchron halten. Eine News-Seite informiert dabei über aktuelle Änderungen und erlaubt auch ein Hinterlassen eigener Nachrichten. Eine interessante Möglichkeit ist zudem die Option, einen Remote-Zugriff via Live Mesh zu gewähren. Rechner, die online sind, können so von einem selbst über Live Mesh ferngesteuert werden, wenn man dies erlauben möchte.

Zukunftsstrategie

Microsoft hat ja bereits mit Groove eine Synchronisationssoftware im Programm, was macht Mesh also für einen Sinn bzw. besonders? Insgesamt kann man Live Mesh bzw. das, was derzeit davon zu sehen ist, guten Gewissens als Spitze eines riesigen Eisberges sehen. Ziel ist vielmehr die Vereinigung der 4 Elemente Applikationen, Geräte, Daten und Menschen. Den Zugriff und Austausch zwischen diesen Elementen zu vereinheitlichen ist das Ziel von Live Mesh. Unter der Oberfläche ist die Windows Azure Plattform angesiedelt, darauf setzen die sogenannten „Live Services“ auf (s. Bild unten). Diese stellen Dienste/Services für Live Mesh zur Verfügung und über das Live Framework kann bequem dagegen programmiert werden. Das alles sieht sehr elegant und einfach aus. Um z.B. alle zum Mesh gehörenden Devices abzurufen, genügen folgende Zeilen: „var livefx = new LiveOperatingEnvironment(); livefx.Connect(); foreach(var dev in livefx.Mesh.Devices) …“. Außer Devices gibt es noch allgemeine Mesh Objects, Data Feeds und Data Entries, Contacts, Profiles, News, Media Resources etc.. Das Live Framework ist als CTP bereits verfügbar, allerdings existiert für den Download eine Warteliste, die ziemlich lang sein dürfte (ich warte immernoch…). Microsoft hat weiterhin bereits damit begonnen, auf Basis des Live Frameworks einige Applikationen zu schreiben. Im Vorfeld wurde schonmal mit Tracker eine „Demo-App“ zur Aufgabenverwaltung vorgestellt. Man stelle sich aber vor, was mit dieser Technologie alles möglich ist! Eigene Applikationen können leicht alle Mesh-Features nutzen und Daten über das Mesh anderen Devices zur Verfügung stellen. Weiterhin sind Anwendungen denkbar, die sowohl auf dem Live Desktop als auch auf den Client-Rechnern laufen und somit von überall erreichbar sind.

Ich bin gespannt, was da demnächst auf uns zukommt – get meshified 🙂

Multitouch: die nächste UI-Revolution?

Auf der PDC hat Microsoft einiges zum Thema Multitouch bekannt gegeben: Windows 7 kommt mit Multitouch-Funktionalität und mit dem Surface-Tisch wurde bereits ein Konzept für angewandte Multitouch-Funktionen vorgestellt. Dass Multitouch ein hohes Potential hat, zeigt die Benutzerakzeptanz, welche nicht zuletzt bei Apple’s iPhone demonstriert wurde. Der „Cool“-Faktor spielt dabei eine große Rolle und das ist ein Grund dafür, warum die Bedienung des Rechners per Touchscreen die nächste Ausprägung von Benutzerinteraktion mit dem Computer darstellen wird. Gerade im Endbenutzerbereich und im Bereich der Internet Tablets dürfte sich diese Funktionalität schnell durchsetzen, nur zum schnellen Schreiben und Programmieren werden meiner Meinung nach wohl noch herkömmliche Peripheriegeräte zum Einsatz kommen.

Multitouch bzw. Touchscreens allgemein senken nicht nur die Hemmschwelle für neue Computernutzer, sie erlauben auch eine nicht gekannte Fülle neuer Funktionen (Video-/Bildbearbeitung, CAD, Spiele, …) und somit neue Benutzerinterfaces. Viele heutige Programme werden mit Multitouch „besser“ im Sinne der Benutzerakzeptanz und der „User Experience“, wichtig ist dabei allerdings ein integriertes Konzept, durch welches der Benutzer intuitiv und schnell erlernen kann, wie er mit der neuen Funktionalität umzugehen hat und sie sich zunutze machen kann.

Für Surface wurde bereits ein SDK angekündigt, das Surface Device wird außerdem bald in Europa erhältlich sein (mehr Infos zu Surface hier).

Weitere Links:

C# 4.0 Neuerungen

Die ersten Neuerungen kurz in 3 Stichpunkten:

  • Aufruf dynamischer Sprachen: dynamic-Schlüsselwort
  • Optionale Funktionsparameter wie in C++ (wie ich das vermisst habe!)
  • Rückgabe anonymer Typen durch Funktionen

Einen umfassenden Überblick über die Neuerungen gibt ein Word-Dokument, welches Microsoft hier zum Download bereitstellt.

Links:

Microsoft’s Strategiewandel

Eine Meldung, die nicht überraschen sollte: Microsoft will einen Strategiewandel vollziehen.

Zukünftig soll nicht mehr der einzelne Rechner im Fokus der Unternehmensstrategie stehen, sondern das Internet als Ganzes, d.h. als ultimative Applikationsplattform. Steve Ballmer: „So wie wir ein Betriebssystem für PC, Handy und Server haben, brauchen wir ein neues, das im Internet läuft.

Wird auch Zeit, schließlich hinkt Microsoft der Entwicklung in diesem Bereich etwas hinterher, einzelne bereits angebotene Online-Services sind noch nicht der Rede wert. Wenn Microsoft hier konsequent werden sollte (und bei der PDC wird sicher etwas Konkretes bekannt werden), dann könnte dieser Vorsprung aufgeholt werden, Microsoft könnte aufgrund seiner Marktdurchdringung bei Desktop-Betriebssystemen sogar eine Vorreiterrolle spielen. Trotzdem birgt der Strategiewechsel natürlich auch ein enormes Risikopotential in sich, demnach muss eine intelligente Lösung her, welche die Benutzer auf „sanfte Art“ in die neue Ära mitnimmt.

Ein Blick auf F#

Funktionale Programmierung hat mich bereits während des Studiums beschäftigt, allerdings eher am Rande in Lehrveranstaltungen wie „Objektorientierte Konzepte“, wo in den Übungen Haskell gepredigt wurde. Teils verwirrt, teils fasziniert von dieser Art zu denken und zu programmieren hat mich das Thema nie richtig losgelassen und erlebt gerade einen persönlichen Aufschwung durch F#. F# ist Microsoft’s funktionale .NET Programmiersprache, die wie viele Innovationen Microsoft Research entsprungen ist. Es ist explizit hervorzuheben, dass F# das .NET-Framework als Basis nutzt. Demzufolge stehen auch alle Bibliotheken zur Verfügung, welche .NET so mächtig machen. Doch genug der Vorrede, los geht es mit F#. Ein kleiner Praxistest soll an dieser Stelle erste Eindrücke vermitteln…

Los geht’s…

Die aktuelle F# CTP kann auf der zugehörigen MSDN-Seite herunter geladen werden. Hier stehen auch weitere Ressourcen zur Verfügung, die beim Einstieg in die neue Programmiersprache behilflich sind. Flux installiert lässt sich im Visual Studio bei der Erstellung eines neuen Projekts der Punkt „Visual F#“ wählen. Die ersten Zeilen Code sind bekanntlich die schwersten in jeder Programmiersprache, und doch halfen mir bereits hier meine ersten Erfahrungen in Haskell. Der große Unterschied: F# ist keine rein funktionale Programmiersprache wie Haskell, sie enthält ebenfalls imperative Elemente, welche die Ausdruckfähigkeit an einigen Stellen vereinfachen sollen. Erste Schritte waren also schnell gemacht. Mit „let“ werden Variablen deklariert und definiert, wobei es sich hierbei auch um Funktionen handeln darf. „let twice x = 2*x“ erzeugt z.B. eine Funktion „twice“, welche die Signatur „int -> int“ besitzt und zu einem übergebenen Argument seinen zweifachen Wert zurückgibt. Diese Funktion darf wieder an weitere Funktionen übergeben werden, Funktionen höherer Ordnung sind also ohne Probleme möglich. F# inferiert dabei den Typ von Variablen, d.h. ihre Signatur wird aus den angegebenen Definitionen automatisch ermittelt und so z.B. auch bei der Fehlerprüfung verwendet. Als Beispiel für eine Signatur sei „List.map“ angegeben. Deren Signatur lautet: „val map: (‚a -> ‚b) -> ‚a list -> ‚b list“. What the heck? Eigentlich ist es ganz einfach. „->“ gibt jeweils die Abgrenzung zweier Parameter an. Der Ausdruck nach dem letzten „->“ stellt den Rückgabetyp dar. Nehmen wir C# als Hilfestellung und schauen uns die Methode „Math.Pow“ an, so hat diese in C# die Signatur „double Pow(double x, double y)“ und übersetzt auf unser Schema die Signatur „double -> double -> double“. Sie würde also 2 double-Werte als Argumente nehmen und einen double-Wert zurückliefern. Aber zurück zu List.map… (‚a -> ‚b) besagt: „das erste Argument der Funktion List.map ist eine Funktion, welche ein Element des Typs a entgegennimmt und ein Element des Typs b zurückliefert“. Das zweite Argument „‚a list“ besagt, dass eine Liste mit Elementen vom Typ a erwartet wird. Der Rückgabetyp von List.map ist ‚b list, was als letzter Term der Signatur ausgewiesen ist. Was macht List.map jetzt eigentlich? Es „mapped“ Elemente einer übergebenen Liste mit Hilfe einer ebenfalls als Parameter übergebenen Funktion. Dazu wird auf jedes Listenelement des Typs a die Funktion angewendet, welche ein Element des Typs b zurückliefert. Am Ende ergibt dies eine Liste von Elementen des Typs b, welche zurückgegeben wird. Auch Lambda-Ausdrücke sind in F# kein Problem. „List.map (fun x -> 2*x) numbers“ würde z.B. von allen Elementen der Liste „numbers“ den doppelten Wert erzeugen und dies als Liste zurückliefern. Klar erkennbar sind bereits hier u.a. das funktionale Paradigma, Typsicherheit und Polymorphismus, auch wird bereits hier die Ausdrucksmächtigkeit erkennbar, wenn man bereit ist sich auf funktionale Programmierung einzulassen…

Quicksort in F#

Beim Stöbern bin ich auf eine F#-Implementierung des Sortieralgorithmus Quicksort gestoßen, welche ich euch nicht vorenthalten wollte:

let lt  x = List.filter (fun xi -> xi < x)
let geq x = List.filter (fun xi -> xi >= x)
 
let rec qs = function
             | []    -> []
             | x::xs -> (xs |> (lt x >> qs)) @ [x] @ (xs |> (geq x >> qs))

That’s it… Über z.B. „printfn „sorted: %A“ (qs [3;1;9;5;2;10;8;6;7;4])“ kann die Sortierung getestet werden. Zunächst werden zwei Funktionen „lt“ und „geq“ definiert, welche jeweils eine Element x übergeben bekommen. Sie liefern genau die Funktionen zurück, welche für einen weiteren übergebenen Wert xi berechnen, ob x kleiner oder größer gleich xi ist. „let rec qs …“ definiert eine rekursive Funktion qs, welche eine Liste als Argument übergeben bekommt. Mit „|“ wird der Wert der Liste geprüft und anhand dessen der Funktionswert bestimmt. Ist die Liste leer („[ ]“), so wird auch nur eine leere Liste zurückgeliefert. Ansonsten wird die Argumentliste mittels „x::xs“ in den Kopf x und die Restliste xs zerlegt und mit diesen beiden Elementen wird der folgende Term definiert. Dieser ist zunächst in 2 Teile aufgeteilt, die mit „@“ voneinander getrennt sind. Im mittleren steht mit [x] eine Einerliste, welche nur das Pivotelement des Quicksort-Durchlaufs enthält. Links davon wird die Teilliste von xs erzeugt, welche alle Elemente kleiner als x enthält, rechts davon entsprechend die Teilliste mit allen Elementen größer gleich xs. Mit „(xs |> (lt x >> qs))“ werden über den Pipe-Operator |> die Elemente aus xs ausgewählt, die kleiner als x sind (die Liste xs wird mittels Pipe weitergeleitet an lt und qs) und für diese Teilliste wird qs rekursiv aufgerufen (>> stellt die Verkettung zweier Funktionsaufrufe dar). Da mit jedem Aufruf von qs die Liste um mind. 1 Element kleiner wird, terminiert der Algorithmus in endlich vielen Schritten. Ok, an die Syntax muss man sich erst einmal gewöhnen, aber mal ehrlich… wie viele Zeilen hättet ihr in C# gebraucht?

Ja und?

Jetzt könnte man sagen: ja fein, F# ist eine neue funktionale Programmiersprache, hat das .NET Framework unter sich liegen und lässt sich auch recht flexibel verwenden… doch warum in aller Welt sollte mich das kümmern? Funktionale Programmiersprachen gibt es schon seit Ewigkeiten und mit C# komme ich gut zurecht, was will ich mit F#? Die Antwort auf diese Frage ist nicht leicht und zudem recht komplex. Zunächst einmal gibt es derzeit keine sehr guten Gründe, um F# wirklich intensiv zu lernen. Im Arbeitsleben ist diese Sprache noch nicht angelangt und somit eher eine Spielwiese zum Lernen funktionaler Programmierung und zum Erfreuen von enthusiastischen Programmierern. Es ist nicht abzusehen und auch nicht das Ziel von Microsoft, dass F# bestehende Sprachen wie C# ablöst. Ein großer Aspekt für die funktionale Programmierung ist das Problem der parallelen Programmierung. Viele Jahrzehnte lang haben wir sequentiell programmiert und imperative Programmiersprachen eigneten sich hierzu hervorragend. Doch mit dem Aufkommen von Multicore-Prozessoren wird die Notwendigkeit nach der Parallelisierung von Aufgaben immer größer und hier stoßen imperative Programmiersprachen an ihre Grenzen. Funktionale Programmiersprachen hingegen sind zunächst nebenwirkungsfrei und damit grundlegend für eine Parallelisierung geeignet. Variablen sind immutable (unveränderlich), womit Programmteile ohne Probleme verteilt bearbeitet werden können. Funktionale Programmierung kann damit einen Ausweg aus dem Dilemma der Parallelisierung von Programmen weisen. Wichtig dabei ist meiner Meinung nach, dass kein kompletter Paradigmenwechsel vollzogen wird. Funktionale Programmierung ist schwer und teilweise kompliziert, wenn man lange Zeit imperativ programmiert hat. Imperative Programmiersprachen geben einem Programmierer mehr Flexibilität mit dem Nachteil, dass es Wechselwirkungen geben kann, was gerade bei komplexen Softwareanwendungen häufig zu erheblichen Problemen führt. Aber funktionale Elemente werden meiner Meinung nach Einzug in Sprachen, Bibliotheken und Muster halten und somit bestehende Programmiersprachen wie C# bereichern. F# ist dabei auf einem guten Weg, da es eine hohe Ausdrucksmächtigkeit besitzt und performanter agiert als viele seiner funktionalen Kollegen. Erste Elemente von F# sind bereits in C# eingeflossen, es bleibt abzuwarten welche noch folgen werden…

So far for now… Matthias

PDC 2008

Morgen geht es los mit der PDC, Microsoft’s jährlicher Professional Developer Conference, die nicht selten den Ausgangspunkt für viele der neuesten Technologien (nicht nur für Entwickler) dargestellt hat. Ich freue mich darauf, aus der Ferne von News in den Bereichen .NET, C# und Visual Studio zu erfahren und einen Ausblick darauf zu erhaschen, was Microsoft in der Zukunft mit diesen Technologien vor hat.

Im Vorfeld der PDC konnte man bereits einiges erfahren und auch die Agenda gibt einigen Aufschluss. Das Thema Parallel Computing ist sicher ein wichtiges für C# bzw. das .NET Framework und mit der Integration der Parallel Extensions wird Microsoft einen wichtigen Schritt in diese Richtung tun. Doch das kann nicht alles sein, gerade im Bereich Patterns ist da noch mehr nötig und hier wird auf der PDC sicherlich einiges auf uns zukommen.

Eins steht schon fest: .NET bekommt ein neues Logo. Hier ist es:

Mich freut’s… das alte war doch „leicht“ angestaubt und erinnerte eher an Zeiten von Windows 98 und ME anstatt an ein aktuelles Entwicklungs-Framework…

Also ich bin gespannt auf die News dieser Woche und werde in diesem Blog auf die besten davon eingehen.

Webcast: Velocity – eine Einführung

„Velocity“ ist eine verteilte In-Memory-Anwendungs-Cache-Plattform mit dem Augenmerk auf Skalierbarkeit, Verfügbarkeit und Performanz. In diesem Webcast wird die Architektur von „Velocity“ vorgestellt und erklärt, wie man dieses Modell in seine eigenen Projekte und Anwendungen einbinden kann.