Eigentlich ein grundlegendes Element im Web und der Nutzer macht bewusst Absätze – daher wäre es nur gerecht, wenn man das auch entsprechend würdigt.

Kleine MVC Demo App:

Wir wollen die Eingaben in diesem Textfeld etwas näher analysieren. In meiner Variante geschieht das “splitten” auf der Server-Seite, allerdings wäre es über Javascript natürlich genauso möglich.

Nach dem OK Klick:

Der Controller nimmt den Eingabetext entgegen. Wenn der Nutzer [Enter] in der Textarea drückt, kommt als “Steuerzeichen” entweder ein \n oder \r\n mit (ich glaub das hängt mit den Betriebssystemen zusammen… lange Geschichte )

Damit müssen wir den String nur noch bei diesen Zeichen splitten und schon können wir die einzelnen Absätze besonders behandeln:

        public ActionResult Multiline(string input)
        {
            ViewBag.MultilineRaw = input;

            List<string> eachLine = input.Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries).ToList();
            ViewBag.MultilineSplitted = eachLine;

            return View("Index");
        }

View:

@using(Html.BeginForm("Multiline", "Home"))
{
    @Html.TextArea("input")
    <button>OK</button>
}
@if(string.IsNullOrWhiteSpace(ViewBag.MultilineRaw) == false)
{
<h2>Input</h2>
<p>Raw: @ViewBag.MultilineRaw</p>
<h3>Each Line</h3>
    <ul>
        @foreach(var line in @ViewBag.MultilineSplitted)
        {
        <li>@line</li>
        }
    </ul>
}

Endergebnis:

Keine große Sache – aber vielleicht hilft es den einen oder anderen weiter.

[ Download auf Google Code ]

id Software, die Macher von Doom, Quake, Wolfenstein & co., stellen regelmäßig ihre älteren Spieltitle als Open Source zur Verfügung. Das Ganze runterzuladen fand ich bisher immer recht mühselig, allerdings gibt es seit kurzer Zeit die Sourcen auch auf GitHub.

Darunter Spiele wie Doom 3, Quake 3, Wolfenstein für iOS. Wer also schon immer mal Interesse hatte in die Spielentwicklung reinzuschauen sollte mal ein Blick rein werfen.

Wie bereits vom Twitter Bootstrap Team angekündigt wurde offiziel die Version 2.0 des UI Toolskits “Twitter Bootstrap” veröffentlich.

Zudem wurden die Slides, welche bei der Release Party gezeigt wurden auch veröffentlicht:

Downloads finden sich auf der Twitter Bootstrap Seite auf GitHub.

Dart, Google Javascript Alternative, wurde vor ein paar Monaten vorgestellt und die Webentwickler Szene ist noch etwas gespalten, ob Dart nun überflüssig ist oder einfach nur cool und längst überfällig ist. Um die Sprache näher zu erläutern hat Google die grundlegenden Javascript Basics nach Dart übersetzt. Das Ergebnis ist der “Translator”.

Der Name mag momentan noch nicht ganz passend sein, da es hier nur um eine statische Gegenüberstellung handelt und man kein Javascript Code momentan “konvertieren” kann. Ich vermute es geht irgendwann in diese Richtung

Für die Dart interessierten unter euch: Klick.

Der offizielle Release ist am 31. Januar, allerdings beginnt jetzt laut Mark Otto (einer der Hauptentwickler von Twitter Bootstrap) die intensive Test-Phase. Das heisst, das es nun offiziel auch die 2.0 Dokumentation online gibt.

Im Vergleich zur aktuellen Version 1.4 gibt es einige neue Controls, Javascripts und das Template wurde auch für Mobile Geräte und Tablets angepasst (Stichwort “Responsive Design”).

Wer mehr erfahren will – Mark Ottos Post “Bootstrap 2 ready for testing and feedback”

Wer mit RavenDB arbeitet kommt automatisch zu einem sehr mächtigen Mittel: Den Indexen. Der Hauptfokus des Posts liegt hierbei auf dem Unit-Testen von RavenDB. Unit-Testing in Datenbank-Projekten ist mehr als anstrengend und zeitfressend. RavenDB lässt sich allerdings recht einfach in einen “Test” Modus versetzen, sodass die Funktionalität erhalten bleibt.

Achtung: Streng genommen darf ein Unit-Test auch keine Datenbank berühren, da man damit mehr als die eigentliche Test-Einheit testet. Richtiger wäre Integrationstests, allerdings redet die halbe Softwarewelt generell von Unit-Tests. Daher belassen wir es mal bei der unschärfe.

Der Code selbst ist unter Mithilfe von Daniel Lang entwickelt, als er mir bei einem RavenDB Index geholfen hat.

Was ist ein RavenDB Index?

Ein RavenDB Index kann man sich als gespeicherte Abfrage vorstellen, welche von RavenDB im Hintergrund ausgeführt wird und das entsprechende Result zwischenspeichert. Über RavenDB Indexe können Abfragen über mehrere Dokumente gemacht werden und über Map/Reduce die Ergebnismenge angepasst werden.

Bsp:

Ein ganz simpler Index sieht so aus:

    public class SearchIndex : AbstractIndexCreationTask<Term>
    {
        public SearchIndex()
        {
            Map = terms => from term in terms
                            select new { term.Title };

            Index(x => x.Title, FieldIndexing.Analyzed);
        }
    }

Was das ganze überhaupt macht, ist hier gut erklärt. Wenn ich den Code anwenden möchte:

Session.Query<Term, SearchIndex>().Where(x => x.Title.StartsWith(searchTerm)).ToList();

Unit-Test dazu (gemacht mit xUnit)

public abstract class RavenTest
    {
        protected IDocumentStore GetDatabase()
        {
            var documentStore = new EmbeddableDocumentStore
                                    {
                                        RunInMemory = true
                                    };
            documentStore.Initialize();

            return documentStore;
        }
    } 

public class SearchIndexTest : RavenTest
    {
        [Fact]
        public void TitleContainsSearch()
        {
            using (var documentStore = GetDatabase())
            {
                IndexCreation.CreateIndexes(typeof(UserActivityFeedIndex).Assembly, documentStore);

                using (var documentSession = documentStore.OpenSession())
                {
                    documentSession.Store(new Term
                                              {
                                                  Title = "RavenDB",
                                              });
                    documentSession.Store(new Term
                                              {
                                                  Title = "ASP.NET MVC",
                                              });

                    documentSession.Store(new Term
                                            {
                                                Title = "Twitter Bootstrap",
                                            });

                    documentSession.SaveChanges();

                    var result = documentSession.Query<Term, SearchIndex>().Where(x => x.Title.StartsWith("Boot"))
                                                                           .Customize(x => x.WaitForNonStaleResults())
                                                                           .ToList();

                    Assert.Equal(1, result.Count);

                    Assert.Equal("Twitter Bootstrap", result[0].Title);
                }
            }
        }
    }

Die RavenTest Klasse erstellt die Connection zur RavenDB “embedded” Datenbank. Über “RunInMemory” wird dies auch nur im Arbeitsspeicher gehalten. Vorteil: Sehr schnell und kein Cleanup nach dem Test.

In der Testmethode wird erst der Index angelegt (über Reflection wird die Assembly durchsucht) und dann werden Testdaten in diese DB abgespeichert. Am Ende erfolgt die Abfrage und das Ergebnis wird überprüft. Bei der Abfrage wird noch ein WaitForNonStaleResults dazugehangen um auch die gerade eben gespeicherten Daten mit abzufragen (RavenDB speichert die Index-Ergebnisse zwischen, sodass es zu einer kurzen Verzögerung kommen kann. Ist im Unit-Testing allerdings ungünstig.)

Sehr einfach und wesentlich eleganter als bei einer klassischen DB.

Mein Projekt “KnowYourStack.com” (Arbeitstitel war mal BizzBingo – ein detailierter Blogpost dazu folgt noch) liegt auf GitHub und ich hatte ein Problem bei dem mir Daniel Lang sehr geholfen hat. Am Ende hat er ein Fork von meinem Projekt gemacht und mir ein Pull Request eingestellt:

Nun ist natürlich die Frage: Wie bekomm ich denn die Änderungen zu mir?

Da ich ein völliger Anfänger in Sachen Git / GitHub bin schreibe ich mal Schritt für Schritt mit. Die Hilfe von GitHub war ein guter Anfang, allerdings muss ich bei dieser Aktion noch diverse Files mergen, was das ganze nicht einfacher macht.

git checkout master
...
git pull https://github.com/dlang/BizzBingo master
... (VIELE DATEIEN werden gezogen)...

Ergebnis:

“Automatic merge failed; fix conflicts and then commit the result.”

$ git mergetool

Achtung: Man sollte allerdings vorher ein Mergetool eingestellt haben. Das ganze ist eigentlich auch recht einfach und ist hier detailiert beschrieben. Im Grunde muss man nur ein Merge Programm sich aussuchen (ich hab z.B. KDiff3 gewählt. Sieht aber hässlich aus.) und sagt git, welches Tool er beim Mergen zu nehmen hat. Am Ende sieht z.B. die .gitconfig so aus:

[diff]

	tool = kdiff3

[merge]

	tool = kdiff3

[mergetool "kdiff3"]

	path = C:/Program Files (x86)/KDiff3/kdiff3.exe

    keepBackup = false

    trustExitCode = false

[difftool "kdiff3"]

    path = C:/Program Files (x86)/KDiff3/kdiff3.exe

    keepBackup = false

    trustExitCode = false

Nach dem mergen die Files am Ende mit “commit” und “push” zu GitHub. Fertig

git commit -m " KOMMENTAR "
git push origin master

Müsste so klappen – Danke nochmal an Daniel!

Spielwiese für HTML/CSS

Wer mal “schnell” eine Spielwiese für CSS und HTML benötigt der sollte mal ein Blick auf Dabblet.com werfen:

Grundprinzip ist schnell erklärt: Man kann CSS samt HTML Code in die Weboverfläche einhacken und sieht sofort das Ergebnis in der Preview.

Das ganze lässt sich auch per Link an andere Teilen oder direkt speichern. Mehr Informationen gibt es auch auf dem Blog oder ihr probiert es selber mal aus.

Spielwiese für Javascript (und HTML und CSS)

Wer eine Spielwiese für Javascript sucht und dazu auch noch diverse Frameworks “per Click” dazuhaben möchte, kann sich jsfiddler.com mal anschauen:

In der Sidebar kann man auch einige Beispiele anschauen, so z.B. ein einfacher Twitter Reader.

Auch da kann man CSS / HTML hinterlegen, allerdings sieht es von der Aufmachung her nicht ganz so schick aus wie bei dabblet.com.

hurl.it – curl online

Letzter Dienst in der Reihe: hurl.it, welcher angelehnt an curl ist.

Beispiele gibt es direkt auf der Startseite, so z.B. eine Anfrage an die GitHub API. Allerdings ist der Dienst recht instabil (jedenfalls ging er in den vergangen Tagen nicht) und scheint ab und an Probleme mit einigen Antworten zu haben (die Stackoverflow API geht z.B. nicht mit dem Tool). Trotzdem praktisch, wenn man mal schnell mit einem REST Service spielen möchte.

Twitter Bootstrap ist ein UI Toolkit um schnell und einfach Web-Oberflächen zusammen zu bauen. Es gibt eine ganze Reihe an Komponenten und sogar einige Javascripts, um das Interface aufzuwerten (ähnlich jQuery UI). Die Einbindung von Twitter Bootstrap habe ich bereits hier erläutert.

FBootstrap für Facebook Apps

Twitter Bootstrap sieht jedoch sehr aus wie Twitter und wenn jemand Facebook Web Apps entwickeln möchte ist dies nicht ganz so “passend”, daher hat @clmnsk ein Fork der aktuellen Twitter Bootstrap Version für Facebook namens FBootstrap gemacht:

Wer “Facebook Look-a-like” Web Applikationen entwickelt kann sich das Projekt näher anschauen. Ansonsten gibt es am Ende des Posts vielleicht noch eine andere Variante.

Vorschau auf Twitter Bootstrap 2.0

Auf Bootstrap.io/Demo gibt es eine aktuelle Demo der Twitter Bootstrap 2.0 Version zu sehen, welche “in wenigen Wochen” released werden soll:

Neu im Gegensatz zur aktuellen Version:

- Responsive Layout (auch bei einem kleineren Display fällt die Seite nicht auseinander )

- Ein paar neue “Controls” (Bildunterschriften bei Media-Einbindungen/Carousel)

- Icons!

- Viele Detailverbesserungen bei bestehenden Elementen (Forms/Buttons)

Themes für Twitter Bootstrap?

@SachaGreif arbeitet gerade an Themes für Twitter Bootstrap. Wäre natürlich eine sehr schöne Sache um sich trotz Twitter Bootstrap abzuheben. Schauen wir mal was da rauskommt.

Interessierte sollten hier klicken. Damit wären evtl. auch Facebook Themes möglich

Um Daten in einen MVC Controller zu bekommen ist das Modelbinding von MVCeigentlich recht clever. Allerdings ist es etwas kompliziert, die Fehlermeldung zu setzen, wenn das Binding nicht geklappt hat.

Bsp:

    public class RegisterModel
    {
		...

        [Required]
        [DataType(DataType.EmailAddress)]
        [Display(Name = "Email address")]
        public string Email { get; set; }

        [Required]
        [Display(Name = "Age")]
        public int Age { get; set; }

		...
    }

Dies ist das Standardmodell für die Registrierung in der ASP.NET MVC Projektvorlage. Ich habe ein Property “Age” vom Typ “int” hinzugefügt. Auch im View muss die mit angegeben werden:

            ...
			<div class="editor-label">
                @Html.LabelFor(m => m.Age)
            </div>
            <div class="editor-field">
                @Html.TextBoxFor(m => m.Age)
                @Html.ValidationMessageFor(m => m.Age)
            </div>
			...

Problem: Was passiert, wenn nun der Nutzer anstatt einer Zahl Buchstaben eingibt?

Solange die ClientValidation an ist, ist auch alles gut:

Wenn sie allerdings aus ist kommt im Standardfall diese Fehlermeldung:

Die Fehlermeldung “The value ‘Test’ is not valid for Age.” wird direkt in den ModelState geschrieben:

Leider lässt sich diese Meldung nur recht kompliziert ändern – dabei werden auch jegliche Sprachen ignoriert. Das sieht natürlich auf einer deutschen Seite nicht so schön aus.

Fix: Ressourcen Datei erstellen

Unter App_GlobalResources muss man eine Resource-Datei erstellen und ein Eintrag “PropertyValueInvalid” einfügen und dann dahinter den dazugehörigen Text:

In der Global.asax die Resource-Datei verlinken:

		protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            DefaultModelBinder.ResourceClassKey = "Errors"; <-- lookup in Errors.resx

            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);
        }

Ergebnis:

Hintergrund:

Jegliche Validierunglogik kann nicht ausgeführt werden, da das Framework das Property nicht binden kann. Interessanterweise ist das Verhalten des Frameworks etwas anders wenn man eine zu große Zahl dem Int zuweisen möchte. In diesem Fall kommt im ModelState eine Exception an, welche man abfangen kann. Auch die Validierung kann da greifen. Das Problem trat bei mir auch nur im Zusammenhang von String-Eingaben auf.

Durch Zufall bin ich heute auf die Seite von code.nasa.org gelandet. Ein kleines Mikrofon Icon hat meine Aufmerksamkeit geweckt:

Seit Chrome 11 gibt es “Unterstützung” für die Speech Input API. Gelesen hatte ich davon, allerdings hatte ich mir die Integration komplex vorgestellt. Sehr zur Überraschung ist die Implementierung allerdings sehr einfach – über das Attribut “x-webkit-speech” (später soll es einfach nur “speech” sein). Das ganze soll für Input und Textarea Elemente funktionieren:

//Supported elements

<input type="text" x-webkit-speech />
<textarea x-webkit-speech />

Eine Flasche Wermut

Es funktioniert nur im Chrome und man sollte sehr klar und deutlich sprechen. Deutsch versteht er kaum bis garnicht und englisch. Naja – ist noch weit von Siri entfernt. Die Speech Input API selbst ist momentan in einem sehr frühen Stadium und so richtige Fortschritte gab es seit Release Chrome 11 und heute kaum.

Ausprobieren

Ausprobieren kann man es z.B. hier. Das Video zeigt es allerdings auch gut (für die Leute, welche keinen Chrome nutzen )

Stackoverflow.com – der Segen für alle Programmierer und die, die es werden wollen. Die Seite enthält nicht nur Fragen und Antworten, sondern hat über die Tagging Funktion auch eine Art “Mini”-Wiki für Technologien entwickelt. Stackoverflow bietet natürlich auch eine API an und für einfache lesende Zugriffe gibt es auch eine Variante, welche die eigenen Serverkapazitäten schont und ziemlich clever ist: Die Rede ist von JSONP.

Was ist JSONP?

Durch das Sicherheitsmodell im Browser ist es heutzutage nicht wirklich einfach möglich AJAX Requests an Seiten zu schicken, welche eine andere Domain haben. Allerdings kann man einen kleinen Workaround benutzen: Es ist erlaubt, fremde Ressourcen von anderen Domains über GET einzubinden. Dazu zählt natürlich auch Javascript.

JSONP bedient sich diesem Trick: Der Browser erlaubt es, dass man fremden Javascript Content via Http GET auf die eigene Seite einbindet. Der fremde Javascript Code kann alles mögliche sein, u.a. auch JSON. Damit ist die Idee der JSONP API geboren.

jQuery und JSONP – sieht aus wie AJAX. Ist auch fast dasselbe.

Ein normaler jQuery AJAX Aufruf, um ein

$.ajax({
  url: "test.html",
  cache: false,
  success: function(html){
    $("#results").append(html);
  }
});

Der JSONP jQuery Aufruf ist leicht modifiziert und enthält ein “dataType jsonp” Property.

$.ajax({
  url: "otherDomain...",
  cache: false,
  dataType: 'jsonp',
  success: function(html){
    $("#results").append(html);
  }
});

Beispiel Stackoverflow API:

Ich möchte die Wiki Information über das Tag “RavenDB” mir über JSONP holen.

                $.ajax({
                    type: 'GET',
                    url: 'http://api.stackoverflow.com/1.1/tags/ravendb/wikis',
                    dataType: 'jsonp',
                    success: function (data) {
                        if (data.tag_wikis.length > 0) {
                            alert(data.tag_wikis[0].wiki_excerpt);
                     	}
                    },
                    jsonp: 'jsonp'
                });

Als Ergebnis kommen die Daten über den Browser geladen direkt von Stackoverflow.

Was bringt das?

Durch jsonp erspart man sich den Proxy, welcher zwischen dem Browser und dem eigentlichen Service vermitteln müsste. Allerdings sind die Anwendungsfälle recht beschränkt und ein praktischer Einsatz ist mir nur bei lesenden Sachen bekannt. Evtl. geht hier aber später mehr mit Websockets & co.

Ich besitz seit gut einem Jahr ein MacBook Pro (= aus dem Jahre 2010) und weil mich damals die Frage so beschäftigt hat, blogge ich mal meine Erfahrungen dazu.

Meine Notebook Konfiguration MacBook Pro April 2010

- 2,66 Intel Core i7
- 8GB RAM
- 15” Glossy Display
- Intel X-25M 168GB SSD

Die Hardware: Ein Traum – leider mit kleinen Einschränkungen

Was will man groß über Apple Hardware schreiben: Die Qualität ist sagenhaft. Im Vergleich zu dutzenden Plastiknotebooks liegen Welten. Auch das Touchpad und der sinnvolle Einsatz von Multitouch in der Desktop-Welt ist Apple mehr als geglückt. Das Display ist brillant und die Farben kräftig. Das “Glossy” hab ich selber nicht als störend empfunden, mag aber auch daran liegen, dass ich damit auch nicht in der Sonne arbeite. Aber he… dafür sind wir Entwickler

Als Entwickler ist die Tastatur natürlich besonders wichtig und hier kommen wir zu einem kleinen Problem:

a) es ist eine Notebook-Tastatur, wo ohnehin bereits einige Tasten wegrationalisiert wurden und

b) es ist eine Tastatur von Apple, wo noch viel mehr Tasten weg sind bzw. anders belegt oder nicht beschriftet

Im Vergleich dazu mal eine PC Tastatur (nicht sehr schön, aber so sehen sie aus) :

Entweder war mein Tastaturschema total verstellt, oder ich war zu blöd. Die Tasten “~” und “\”, welche man als Entwickler doch ab und an braucht waren wie weg. Auch “[“ “]”, “{“ “}” hatte ich immer mal wieder gesucht (auch wenn ich eigentlich die Tasten auf einer normalen Tastatur blind finde) und warum das “@” Zeichen auf einer gänzlich anderen Taste liegt ist mir ohnehin schleierhaft. 

Sobald man die vielen Goodis von Resharper nutzen möchte, benötigt man ohnehin noch ein paar Spezialtasten (POS1/ENDE…), welche nicht auf der MacBook Tastatur auffindbar sind.

Toll hingegen ist, dass die Tastatur im dunkeln leuchtet und das man auch sonst recht gut auf ihr schreiben kann. Programmieren ist allerdings etwas Finger-Mikado, aber man kann sich auch daran gewöhnen (bis vor kurzem hatte ich keine extra Tastatur )

Zusammenfassend zur Hardware:

Ohne externe Tastatur und Maus kann man zwar arbeiten, allerdings ist man wesentlich effektiver mit einer gescheiten Tastatur. Momentan schreib ich an dieser hier. Ansonsten gibt es von der Hardware Seite nichts negatives.

Zur Software: Mac OSX oder Windows? Wie wäre es mit beidem?

Ich bin eigentlich recht unbefangen, ob nun Mac OSX oder Windows 7. Beides hat seine Stärken und Schwächen. Allerdings bin ich natürlich auf Windows angewiesen, wenn ich Visual Studio und co. nutzen möchte.

Wofür ich Mac OSX nutze: Zum Großen Teil einfach nur zum Browsen im Web. Durch das grandiose Touchpad und den Gesten für meine Begriffe angenehmer als mit Maus oder einem Touchpad von einem Windows Notebook. Auch die Mail-App und iCal ist für den normalen Nutzer völlig in Ordnung. Die Mail-App funktioniert natürlich auch mit Exchange und ich hatte bislang keine Probleme bei der Synchronisation.

(Bildquelle)

Zusammenfassend:

- Webbrowsing zum Spaß

- Mail

Wofür ich Windows 7 nutze: Zum Entwickeln mit Visual Studio und wenn es doch mal ernsthaftere Bürosachen gibt. Office for Mac & co. hatte ich ehrlich gesagt nicht wirklich gemocht bzw. auch nicht das Bedürfnis danach: Office 2010 passt. Auch wenn es hin und wieder Macken hat, aber nichts ist perfekt . Zocken ist natürlich eigentlich nur ernsthaft auf der Windows Plattform überhaupt möglich.

Zusammenfassend:

- Entwickeln mit .NET / Visual Studio 2010

- Office

- Gaming

Mit Bootcamp & VMWare Fusion die beiden Welten verbinden – ohne Nachteile.

MacBooks sind seit der Umstellung auf Intel-Prozessoren “auch nur” PCs. Natürlich kann man auch Windows 7 nativ installieren – das ganze nennt Apple Bootcamp und Apple liefert die “passenden” Treiber dazu. Unter Bootcamp läuft Windows nativ wie auf jedem anderen PC und kann die ganze Leistung nutzen. Allerdings kann man unter Windows das Touchpad z.B. bei weitem nicht so nutzen wie unter Mac OSX.

Bootcamp “teilt” die Platte einfach in OSX und Windows Partition auf – allerdings muss dieser Schritt bei einer 160GB Festplatte wohl überlegt sein – viel Platz ist es ja nicht, wenn man ansonsten in Terabyte Größen denkt.

VMWare Fusion hat ein echt praktisches Feature: Man kann auch die Bootcamp Partition in einer VM booten. Das hat den charmanten Vorteil, dass man MacOSX und Windows parallel nutzen kann. Das geht natürlich zulasten auf die Performance, aber einfache Strategiespiele, Office oder Visual Studio gehen damit locker.

Im Gespann mit VMWare Fusion kann man beide Welten schön miteinander verbinden und wenn man mal Power braucht, nutzt man Bootcamp. Einzig Windows mag es nicht, dass sich die Hardwaresettings so oft ändern und verlangt ab und an nach einer Reaktivierung des Lizenzschlüssels.

Unter Bootcamp sieht der Windows Leistungsindex so aus (da das MacBook von 2010 ist, dürfte die neuste Generation natürlich noch besser sein)

Mal über den Tellerrand schauen (und für iOS Devs erst recht) !

Über den Tellerrand mal zu schauen und Mac OSX auszuprobieren kann natürlich auch ein Kaufgrund sein (war bei mir auch so). Wer nativ für iOS Geräte entwickeln möchte, kommt ohnehin schwer an ein MacBook Pro vorbei.

Wer es mag, kann auch Mono ausprobieren, aber ehrlich gesagt hatte ich das nie ernsthaft in Betracht gezogen – wenn .NET auf Windows super läuft und ich WebApps baue, warum mir dann diesen Schmerz antuen?

Aber die Optionen stehen auf alle Fälle offen und auch das reizt natürlich.

Ich bereue den Kauf auch nicht, allerdings benötige ich nun noch eine Kampfmaschine für Battlefield (aber da wäre wahrscheinlich auch fast jedes Windows Notebook am Ende gewesen ).

tl;dr Fazit: Taugt ein MacBook Pro nun als Gerät für .NET Entwickler?

Wer auf hochwertige Notebooks scharf ist, Performance braucht und trotzdem Mobil sein möchte: Ja, kann ich empfehlen. Allerdings würde ich mir für ein längeres ernsthaftes Arbeiten/Programmieren eine normale Windows Tastatur mit anstecken.

Wer nur ab und an Mobil ist, sollte allerdings trotzdem vielleicht eher einen Standrechner und für unterwegs ein MacBook Air in Betracht ziehen. Die Kombination kommt mir heute eigentlich  noch etwas cleverer vor.
Wer keine Kompromisse machen möchte, der kann das MacBook Pro nehmen – ein Fehlkauf wird es bestimmt nicht. Oder er wartet ab, was die Ultrabooks alles mal können sollen.

Letzte Frage – Gaming?

Ab und an, will man ja auch eine nette Abwechslung haben: Auf dem 2010ner Macbook (was ich hab) läuft Battlefield 3 in “minimalen” Settings für ca. 3 Stunden. Danach wird das Gerät zu warm und geht in den Ruhemodus Für ein Arbeitsgerät ganz nett, aber da muss was größeres her Aber da Battlefield gerade ein äußerst anspruchsvolles Spiel ist, sollte das nicht abschrecken: Etwas ältere Spiele laufen ohne Probleme.

Wer jetzt überzeugt ist und kaufen möchte: Bei Amazon oder Apple findet sich bestimmt was

Wie bereits vor einiger Zeit abzusehen war, unternimmt Microsoft alles um Windows Azure als “die” Cloud-Plattform für alle möglichen Sprachen & Frameworks zu positionieren. Microsoft, früher dafür bekannt seine eigenen Plattformen und Sprachen in den Markt zu pushen, ändert scheinbar seine Strategie und pusht nun u.a. auch node.js und stellt die SDKs auch auf GitHub bereit.

Node.js auf Windows Azure

Windows Azure unterstützt node.js! Im SDK enthalten sind Powershell-Cmdlets für das erstellen, testen und deployen von node.js Applikationen sowie Samples.

Noch nie was mit node.js was gemacht? Samples von Microsoft

Bislang konnte ich selbst node.js nur oberflächig anschauen, allerdings scheinen die Beispiele von Microsoft etwas größer zu sein als die dutzenden “Hello World” Artikel ohne aber gleich zu komplex zu werden. Das ersten Tutorial beinhaltet:

- IISNode für node.js auf IIS Basis

- Umgang mit dem Node-Package Manager “npm”

- Wie das ganze mit den Azure Diensten funktioniert.

- Samt MVC Framework “Express”

Für einen totalen node.js unerfahrenen Entwickler wie mich sieht es auf den ersten Blick ganz gut aus und auch recht verständlich. Anschauen schadet auf alle Fälle nicht.

Es gibt zudem noch ein zweites Tutorial, welches noch etwas komplexer ist: Node.js Web Application with Table Storage

Einstiegsvideo in 5 Minuten mit node.js & Azure:

node.js – ein seltsamer Hype?

Ich glaube mit ein paar eleganten Frameworks könnte node.js wirklich Spaß machen. Mit C# selbst komm ich auch nicht weit, erst Frameworks wie ASP.NET MVC machen die Sache interessant, daher bin ich gespannt auf die Entwicklung und man sollte mal abwarten was passiert.

Auf alle Fälle ist der von Microsoft eingeschlagene Weg auch der Richtige.

Alle Samples von Microsoft gibts auch auf GitHub.

Folgendes Setup bei mir:

- ASP.NET MVC Projekt samt .NET Framework 4.0

- DotNetOpenAuth via NuGet installiert

- Das Webprojekt hat noch “Cassini” genutzt

Beim Deployen auf einen richtigen IIS bekam ich diese Fehlermeldung:

“There is a duplicate ‘uri’ section defined”

Oder zu deutsch:

“Der “uri”-Abschnitt wurde doppelt definiert.”

Rot markiert war diese Zeile:

<section name=”uri” type=”System.Configuration.UriSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089″ />

Fehlerbeseitigung:

(recht einfach ) Die Zeile aus der eigenen Web.config entfernen:

<section name=”uri” type=”System.Configuration.UriSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089″ />

Grund: Dieser Eintrag ist bereits in der machine.config bei .NET 4.0 Applikationen mit dabei, daher wäre er doppelt.

Das Problem tritt allerdings nur im IIS und IIS Express auf. “Cassini” stört sich (leider) nicht daran.

Tipp (wie fast immer) von Stackoverflow (auch wenn dort die beste Antwort mir etwas kompliziert erscheint, daher auch der Blogpost )

Visual Studio produziert einige Dateien, welche man nicht in sein Source Control System haben sollte: Zum einen sind es Dateien, welche vom Betriebssystem automatisch erstellt werden (Thumbs.db), von diversen Tools (Resharper ahoi!) oder auch den lokalen Build-Output.

Da ich gerade etwas mit Git experimentiere, hier mal meine Erkenntnisse (bei Denkfehlern meinerseits bitte einfach einen Kommentar hinterlassen )

Die .gitignore Datei

Über dieses Datei kann man steuern, welche Dateien git tracken soll und welche nicht. Der Aufbau ist eigentlich simpel, aber irgendwie auch etwas konfus (IMHO ).

Meine .gitignore Datei (für meine Demosourcen auf Google Code) :

# Visual Studio Files and security files
######################
*.suo
*.user
*.cache
*.Publish.xml
_ReSharper.*

# Build Outputs
######################
bin/
obj/

# OS generated files #
######################
Thumbs.db

Der erste Block sind alles User-bezogene Dateien, welche Visual Studio oder Resharper erstellt. Die Build Outputs entferne ich im zweiten Teil und die Thumbs.db fliegt auch weg.

Anlegen der .gitignore Datei in Windows

Windows hat sich beim Anlegen einer “Namenlosen” .gitignore Datei etwas zickig, aber über Notepad++ auch kein Hürde.

Sobald man das File im Stammverzeichnis des Projekts hat, werden überflüssige Dateien nicht mehr eingecheckt.

Wie kann man bereits eingecheckte und getrackte Dateien wieder löschen?

Auf Stackoverflow hab ich mehrere Varianten gefunden, diese hat für mich funktioniert:

git add .gitignore
git commit -m "New .gitignore file"
git rm -r --cached .
git add .
git commit -m "Clean checkin"

In diesem Sinne:

Was ist der schnellste Webserver? Und kann man das überhaupt so einfach messen? Die Antwort: Naja. Man kann einiges Messen, aber ob das an realistische Zahlen rankommt ist immer noch eine andere Geschichte.

Allerdings hat diese Seite einen Test gemacht und der IIS hat “gewonnen”. Allerdings gibt es ja auch ein leuchtendes Beispiel.

Hintergrund

Getestet wurden die wohl größten Vertreter:

Apache, Nginx, Lighttpd, G-WAN und der IIS. Getestet wurde auf einer Quad-Core Workstation, wobei CentOS 6.0 bei allen nicht IIS Webservern eingesetzt wurde. Beim IIS kam ein Windows Server 2008 SP2 zum Einsatz.

Server-Konfiguration

Die Einstellungen der Webserver wurden nicht großartig verändert bzw. die normalen Handgriffe wurden gemacht, sodass z.B. der Webserver alle Kerne des Systems nutzt. Soweit beschrieben wurden auch sonst keine großen Veränderungen gemacht.

Was wurde getestet & das Problem daran.

Getestet wurden “nur”, wie schnell und unter welcher Last der Webserver statische Dateien senden kann. Das ist natürlich auch zugleich der größte Kritikpunkt: Statische Seiten sind vermutlich einfach zu verarbeiten und ein Großteil der IIS Infrastruktur langweilt sich vermutlich.

Trotzdem kann man sich die verschiedenen Werte (mit bunten Grafiken! ) anschauen und als ASP.NET / Webentwickler auf der Microsoft Plattform etwas mehr Selbstvertrauen bekommen.

Stackoverflow. 95Mio Page Views/Month & ein dutzend Server

Vermutlich das beste Beispiel in der .NET Welt, dass man auch auf der Microsoft Plattform eine gefragte Seite unterhalten kann (ohne das es von Microsoft selbst kommt).

Vor einiger Zeit wurden die Besucherzahlen und die Hardware von StackExchange (samt StackOverflow) näher bekannt gegeben.

TL;DR & Fazit zur IIS Performance

Warum? Hier und hier.

Ganz technisch gesprochen: Pingbacks dienen der Benachrichtigung einer Seite, wenn diese auf einer anderen Seite verlinkt wird. Größtes (und einzigstes?) Einsatzgebiet ist in der Blogwelt zu finden. Ziel davon ist es, dass ein Autor benachrichtigt wird, wenn jemand über einen Artikel etwas schreibt. Meistens landet der Pingback mit in den Kommentaren.

Eine ältere Form davon sind die “Trackbacks”, allerdings sind diese scheinbar etwas aus der Mode gekommen. Hier ein Beispiel aus der Praxis (auf die Spam Thematik gehen wir dann noch ein)

Die Spezifikation & Konzept der Pingbacks

Auf dieser Seite gibt es die Spezifikation der Pingbacks zum Nachlesen. Pingbacks müssen vom “Pingback Empfänger” auch unterstützt werden.

Um die Sache einfacher zu Erklären hier ein Beispiel: Ich hab einen Artikel auf code-inside.de verfasst und jemand anderes schreibt über diesen Artikel und verlinkt diesen. Im Hintergrund der Blogengine (oder des “Quell-Systems”) läuft dann ungefähr folgendes Schema ab:

Zuerst wird geprüft ob die Zielseite Pingbacks unterstützt:

Hierbei wird einfach nur ein GET-Webrequest zum Ziel gemacht ohne besondere Parameter.

Als Antwort muss im Header X-Pingback angegeben sein – wenn nicht, dann unterstützt das Ziel keinen Pingback-Mechanismus.

Nun wird der eigentliche Pingback zur XMLRPC Schnittstelle geschickt. Dabei wird die URL aus dem Header genommen und ein XMLRPC Aufruf gemacht, welches so ein XML beinhaltet:

<?xml version="1.0" encoding="utf-16" standalone="yes"?>
<methodCall>
	<methodName>pingback.ping</methodName>
	<params>
		<param>
			<value><string>http://www.bizzbingo.com/what-is/ravendb</string></value>
		</param>
		<param>
			<value><string>http://code-inside.de/blog-in/2011/11/05/use-ravendb-as-embedded-filebase/</string></value>
		</param>
	</params>
</methodCall>

Überprüfung auf der Zielseite

Das Ziel (in meinem Beispiel also mein Blog), überprüft nun die Herkunft und ob diese Seite auch wirklich diesen Artikel verlinkt (ansonsten gibt es eine Fehlermeldung). Die Zielseite sucht sich dann (scheinbar) selbstständig ein Auszug von dem Aufrufer.

Pingbacks in .NET

Der Code stammt zu fast 100% aus dem Blogengine.NET Projekt, da ich selber erst nicht durch die Spezifikation durchgesehen hatte

namespace pingback.webapp.Controllers
{
    using System;
    using System.IO;
    using System.Net;
    using System.Text;
    using System.Xml;

    /// <summary>
    /// Sends pingbacks to website that the blog links to.
    /// </summary>
    public static class Pingback
    {
        #region Events

        /// <summary>
        ///     Occurs just before a pingback is sent.
        /// </summary>
        public static event EventHandler<EventArgs> Sending;

        /// <summary>
        ///     Occurs when a pingback has been sent
        /// </summary>
        public static event EventHandler<EventArgs> Sent;

        #endregion

        #region Public Methods

        /// <summary>
        /// Sends pingbacks to the targetUrl.
        /// </summary>
        /// <param name="sourceUrl">
        /// The source Url.
        /// </param>
        /// <param name="targetUrl">
        /// The target Url.
        /// </param>
        public static void Send(Uri sourceUrl, Uri targetUrl)
        {
            if (sourceUrl == null || targetUrl == null)
            {
                return;
            }

            try
            {
                var request = (HttpWebRequest)WebRequest.Create(targetUrl);
                request.Credentials = CredentialCache.DefaultNetworkCredentials;
                var response = (HttpWebResponse)request.GetResponse();
                string pingUrl = null;

                var pingUrlKeyIndex = Array.FindIndex(
                    response.Headers.AllKeys,
                    delegate(string k)
                        {
                            return k.Equals("x-pingback", StringComparison.OrdinalIgnoreCase) ||
                                   k.Equals("pingback", StringComparison.OrdinalIgnoreCase);
                        });

                if (pingUrlKeyIndex != -1)
                {
                    pingUrl = response.Headers[pingUrlKeyIndex];
                }

                Uri url;
                if (!string.IsNullOrEmpty(pingUrl) && Uri.TryCreate(pingUrl, UriKind.Absolute, out url))
                {
                    OnSending(url);
                    request = (HttpWebRequest)WebRequest.Create(url);
                    request.Method = "POST";

                    // request.Timeout = 10000;
                    request.ContentType = "text/xml";
                    request.ProtocolVersion = HttpVersion.Version11;
                    request.Headers["Accept-Language"] = "en-us";
                    AddXmlToRequest(sourceUrl, targetUrl, request);
                    var response2 = (HttpWebResponse)request.GetResponse();

                    string answer;
                    using (var sr = new StreamReader(response2.GetResponseStream()))
                    {
                        answer = sr.ReadToEnd();
                    }

                    response2.Close();

                    OnSent(url);
                }
            }
            catch (Exception ex)
            {
                ex = new Exception();

                // Stops unhandled exceptions that can cause the app pool to recycle
            }
        }

        #endregion

        #region Methods

        /// <summary>
        /// Adds the XML to web request. The XML is the standard
        ///     XML used by RPC-XML requests.
        /// </summary>
        /// <param name="sourceUrl">
        /// The source Url.
        /// </param>
        /// <param name="targetUrl">
        /// The target Url.
        /// </param>
        /// <param name="webreqPing">
        /// The webreq Ping.
        /// </param>
        private static void AddXmlToRequest(Uri sourceUrl, Uri targetUrl, HttpWebRequest webreqPing)
        {
            var stream = webreqPing.GetRequestStream();
            using (var writer = new XmlTextWriter(stream, Encoding.ASCII))
            {
                writer.WriteStartDocument(true);
                writer.WriteStartElement("methodCall");
                writer.WriteElementString("methodName", "pingback.ping");
                writer.WriteStartElement("params");

                writer.WriteStartElement("param");
                writer.WriteStartElement("value");
                writer.WriteElementString("string", sourceUrl.ToString());
                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteStartElement("param");
                writer.WriteStartElement("value");
                writer.WriteElementString("string", targetUrl.ToString());
                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteEndElement();
                writer.WriteEndElement();
            }
        }

        /// <summary>
        /// Called when [sending].
        /// </summary>
        /// <param name="url">The URL Uri.</param>
        private static void OnSending(Uri url)
        {
            if (Sending != null)
            {
                Sending(url, new EventArgs());
            }
        }

        /// <summary>
        /// Called when [sent].
        /// </summary>
        /// <param name="url">The URL Uri.</param>
        private static void OnSent(Uri url)
        {
            if (Sent != null)
            {
                Sent(url, new EventArgs());
            }
        }

        #endregion
    }
}

Die Anwendung ist auch recht einfach:

            // source must be available from the target url (e.g. localhost doesn´t work)
            string source = "http://www.bizzbingo.com/what-is/ravendb";

            // source must contain the target link... otherwise: Error.
            string target = "http://code-inside.de/blog-in/2011/11/05/use-ravendb-as-embedded-filebase/";
            Pingback.Send(new Uri(source), new Uri(target));

Die Response:

Je nachdem ob alles gut gegangen ist oder nicht, gibt die aufgerufenen Seite auch eine Antwort. Die kann z.B. im Fehlerfall so aussehen:

<?xml version="1.0"?>
<methodResponse>
  <fault>
    <value>
      <struct>
        <member>
          <name>faultCode</name>
          <value><int>17</int></value>
        </member>
        <member>
          <name>faultString</name>
          <value><string>The source URL does not contain a link to the target URL, and so cannot be used as a source.</string></value>
        </member>
      </struct>
    </value>
  </fault>
</methodResponse>

Oder im besten Fall so:

<?xml version="1.0"?>
<methodResponse>
  <params>
    <param>
      <value>
      <string>Pingback from http://www.bizzbingo.com/what-is/ravendb to http://code-inside.de/blog-in/2011/11/05/use-ravendb-as-embedded-filebase/ registered. Keep the web talking!  </string>
      </value>
    </param>
  </params>
</methodResponse>

Die Fehlercodes finden sich auch in der Spezifikation wieder.

Problematisch: Spam

Pingbacks sind vom Prinzip her eine gute Sache, können allerdings leicht ausgenutzt werden, daher werden Sie entweder durch Blogspam-Filter (wie Akismet) herausgefiltert oder gar nicht mehr angezeigt. Spammer nutzen gerne diese Schnittstelle um Links auf allen möglichen Seiten abzulegen. Mein Blogtemplate z.B. zeigt keine Pingbacks an. Vermutlich muss die Quelle erst einen gewissen Grad an Reputation haben um nicht mehr als Spam für Akismet & co. zu gelten.

[ Code @ Google Code ]

Stellt einem Softwareentwickler mal die Frage, ob der Code den er vor ein oder zwei Jahren geschrieben hat immer noch gut findet. Meistens ist die Antwort: Würde ich heute anders machen.

Diesen Prozess habe ich sowohl in dienstlichen Projekten als auch in Privatprojekten mehr als einmal festgestellt. In die Liste der größeren Privatprojekte gehören ShoppingMap von 2007, ReadYou von 2008, DieSachsen.de von 2009 und BizzBingo.com von 2011.

Bei jedem Projektstart geht einem daher immer wieder dasselbe durch den Kopf:

(Bildquelle – schaut euch auch mal die anderen Comics an, sind einige Gute dabei)

Der Weg ist nicht immer das Ziel

Man lernt recht schnell, dass es nicht den richtigen Weg gibt um Software zu entwickeln. Es gibt dutzende Programmiersprachen, Frameworks und Konzepte. D.h. es gibt zwangläufig auch mehrere Wege das Ziel zu erreichen. Man muss sich im klaren werden:

Was ist das Ziel?

Möchte man einfach nur in eine Technologie reinschauen, dann kann man bauen was man möchte. Hat man jedoch ein konkretes Ziel im Auge, sollte man sich überlegen: Was bringt mich meinem Ziel näher? Brauch ich eine 5 Schichten Architektur, mit Response/Request Gedöns und muss ich streng gläubig nach TDD vorgehen? Muss ich mein Loginsystem jetzt mit der Windows-Identity Foundation ausstatten? Oder möchte ich einfach nur ein paar ganz triviale Daten so einfach wie möglich abspeichern?

Und wie verhindert man das Chaos?

Meist kommt das Chaos zustande, weil man zu viele Sachen gleichzeitig haben will. Man hat dutzende Ideen oder dutzende Feature Requests vom Kunden und natürlich muss alles bereits von Version 1, aber mindestens ab Version 2 dabei sein. Das heißt natürlich, man muss sich für alle Eventualitäten sichern.

Meistens endet sowas in einer völlig aufgeblasenen Architektur: Kanonen auf Spatzen oder die Kanone zielt wo ganz anders hin.

Die Software in kleinen Schritten entwickeln und immer wieder prüfen ob das Gebilde immer noch “in Takt” ist hilft dem Chaos Herr zu werden.

(Quelle)

Meine Empfehlung:

Wenn man ein Projekt entwickelt, was irgendwann einmal etwas sinnvolles tun möchte (!= Lernprojekte zum Rumspielen), dann geht in winzigen Schritten voran. Continuous Delivery kann ein Weg sein um schnell Antworten zu bekommen. Viele der Anforderung an die Software werden sich im Projektverlauf ohnehin noch ändern. Bei anderen Sachen gilt: YAGNI.

Konzentration aufs Wesentliche:

Welchen Zweck soll die Software erfüllen und wie kann man dies am einfachsten erreichen – ganz ohne Mondraketen-Architektur. Software baut man nicht “weil man es kann”, sondern weil man ein Bedürfnis/Zweck erfüllen möchte. Den richtigen Weg das zu tun gibt es nicht und solange der Zweck erfüllt ist, ist doch alles andere auch egal.

Vor einiger Zeit bin ich auf den “UI-Baukasten” von Twitter namens Bootstrap aufmerksam geworden und verfolge die Diskussionen und das Projekt auf GitHub. Nun bin ich auf eine ganz interessante Seite gestoßen, welche Webseiten listet, welche mit Bootstrap umgesetzt worden sind:

Built with Bootstrap

Warum ich die Idee ganz cool finde & Bootstrap awesome ist

Ich (als Entwickler und “Nicht-Designer”) begrüßte das Bootstrap Projekt sehr – es bietet bereits ein großes Spektrum an Grundfunktionalität und sieht ohne großes dazutun schick aus.

Über die Seite Build With Bootstrap sieht man eine große Bandbreite von Seiten und kann sehen wie Bootstrap in echt verwendet werden kann.

Beispiele:

Es gibt einige Seite, welche sehr “Twitter-look-a-like” sind:

OpsChannel.com

Hingegen gibt es auch Seiten, an dem man erst im zweiten Moment die Standard Bootstrap Elemente erkennt:

nicemetrics.com

… oder www.goncalorodrigues.com

Weitere Beispiele auf Built With Bootstrap

Die Beispiele auf der Seite geben IMHO ein recht guten Einblick, wie man z.B. auch Bootstrap verwenden kann und was optisch machbar ist.

Momentan liegt es voll im Trend ein Design mit schlichter eleganz zu entwerfen. Insbesondere das Metro Design, welche Microsoft auf breiter Front in immer mehr Produkten einsetzt, zeigt dies recht deutlich. Natürlich müssen auch passende Icons gefunden werden, daher hier mal einige kostenlose Empfehlungen, welche auch für kommerzielle Projekte genutzt werden können:

Bei den nachfolgenden Icons hatte ich nichts “negatives” feststellen können.Bitte prüft trotzdem vorher die Lizenzbestimmungen der jeweiligen Icon Designer! Die Lizenzbestimmung kann sich jederzeit ändern. Zudem muss darauf geachtet werden, ob der Designer mit erwähnt werden muss oder nicht.

 The Noun Project

Icons8

Angelehnt an Windows 8 + man kann Vorschläge für neue Icons machen! Es kommen täglich neue dazu!

somerandomdude

Hier gibt es auch mehrere Iconsets – auch für “spezial-Fälle” wie z.B. Multitouch Anwendungen

PC.de

Auf dieser Seite gibt es diverse Abwandlungen dieser Icons:

108 MONO Icons

gCon @ smashingMagazin

Weitere Icons

Der Suchbegriff “monochrom Icons” bringt recht viel Ergebnisse, so z.B. auch diverse andere Iconsammlungen. Auch hier gilt natürlich: Die Lizenz muss beachtet werden, insbesondere bei deviantart sind viele Sachen nur für den Privatgebrauch bestimmt!

Ein Blick in die Vergangenheit

Vor 3 Jahren hatte ich ein ähnlichen Blogpost geschrieben, allerdings waren damals die Icons wesentlich bunter und im 3D Look. Ich bin gespannt was in 3 Jahren dann sein wird.

www oder ohne www?

Was genau besser ist, kann man nicht genau sagen. Ich persönlich finde die www. Variante mittlerweile besser. Der Grund lieg hier, dass man für die “www” Subdomain einen C-Name setzen kann. Der C-Name ist z.B. entscheidend, wenn man die eigene Webanwendung über seine eigene Domain auf Windows Azure betreiben will.

Spontan habe ich dazu noch zwei Artikel gefunden, welche allerdings schon etwas älter sind.

Wichtig: Man muss sich entscheiden

Wenn die Website sowohl mit www als auch ohne www aufrufbar ist, dann Werte Google den Content als “doppelt” – dies wirkt sich negativ auf die SuchmaschienenGoogle-Optimierung aus.

Wie kann man dies am einfachsten im IIS erreichen

Mein Blog z.B. soll nur über die non-www Variante aufrufbar sein, dafür habe ich die Site “Code Inside” angelegt. Diese Seite hört auch nur auf code-inside.de.

Die andere Seite “www.code-inside.de” hört hingegen nur auf die www-Variante.

Redirect in IIS

Nun gibt es im IIS eine recht einfache Möglichkeit ein Redirect einzustellen:

Dort die entsprechende Zieladresse eingeben und den Status auf “Permanent (301)” setzen.

Diese Variante funktioniert, kann aber dazu führen, dass man recht viele “Dummy” Seiten im IIS hat, welche nur für ein Redirect zuständig sind. Diese Variante würde ich aber als recht einfach sehen und welche auch schnell zu machen ist – funktioniert jedenfalls bei mir

Andere Variante: Über web.config

Natürlich gibt es noch mehrere andere Methoden, so kann man im IIS über Rewrite Rules einiges machen. Allerdings bin ich ganz ehrlich: Direkt beschäftigt hab ich mich damit noch nicht. Vielleicht hat jemand den passenden Snippet für die Umleitung von www zu non-www und umgekehrt parat

Content von anderen Seiten, z.B. YouTube, Flickr, Slideshare auf die eigene Seite einzubetten ist auf den ersten Blick immer nur schwer möglich. Insbesondere wenn man dies “automatisiert” anhand der URL machen möchte. Wie die Einbettung erfolgt hängt stark vom Content ab – bei YouTube und co. muss ein Videoplayer zum Einsatz kommen, Slideshare und co. nehmen Flash/JS für die Präsentationen. Allerdings gibt es einen Standard, welche genau diesen Fall abdecken möchte: oEmbed.

Ziel von oEmbed

oEmbed soll eine einheitliche Schnittstelle sein, über den der eigene Content von anderen Seiten eingebettet werden kann. Es gibt einige große Namen, welche oEmbed unterstützen, darunter YouTube und Flickr:

Beispiel Flickr:

Der Client ruft diese URL auf:

http://www.flickr.com/services/oembed/?url=http%3A//www.flickr.com/photos/bees/2341623661/

Und bekommt als Antwort:

{
	"version": "1.0",
	"type": "photo",
	"width": 240,
	"height": 160,
	"title": "ZB8T0193",
	"url": "http://farm4.static.flickr.com/3123/2341623661_7c99f48bbf_m.jpg",
	"author_name": "Bees",
	"author_url": "http://www.flickr.com/photos/bees/",
	"provider_name": "Flickr",
	"provider_url": "http://www.flickr.com/"
}

Beispiel YouTube:

Aufruf:

http://www.youtube.com/oembed?url=http%3A//youtube.com/watch%3Fv%3DM3r2XDceM6A&format=json

Antwort:

{
	"version": "1.0",
	"type": "video",
	"provider_name": "YouTube",
	"provider_url": "http://youtube.com/",
	"width": 425,
	"height": 344,
	"title": "Amazing Nintendo Facts",
	"author_name": "ZackScott",
	"author_url": "http://www.youtube.com/user/ZackScott",
	"html":
		"<object width=\"425\" height=\"344\">
			<param name=\"movie\" value=\"http://www.youtube.com/v/M3r2XDceM6A&fs=1\"></param>
			<param name=\"allowFullScreen\" value=\"true\"></param>
			<param name=\"allowscriptaccess\" value=\"always\"></param>
			<embed src=\"http://www.youtube.com/v/M3r2XDceM6A&fs=1\"
				type=\"application/x-shockwave-flash\" width=\"425\" height=\"344\"
				allowscriptaccess=\"always\" allowfullscreen=\"true\"></embed>
		</object>",
}

Insbesondere bei dem YouTube Beispiel kommt die Idee zum Tragen: Im HTML Property steht der komplette Code zum Einbinden des YouTube Players.

oEmbed Rückgaben

Laut Standard kann als Ergebnis entweder XML oder JSON zurückkommen, allerdings ist heute JSON eher gebräuchlich. YouTube unterstützt aber z.B. beides.

jQuery oEmbed Bibliothek

Es gibt auch eine jQuery Bibliothek um diese Services abzufragen. Dabei wird auf JSONP zurückgegriffen.

embed.ly – oEmbed Hub

Durch oEmbed ist das Format vorgegeben, jedoch muss man trotzdem dutzende Provider einzeln anfragen und die entsprechenden URLs wissen. Mit dem Dienst embed.ly kann man auch auf eine Art “Hub” zurückgreifen. Embed.ly stellt einen oEmbed Endpunkt bereit und man kann “fast” jede Adresse an embed.ly senden und man bekommt meist eine passende Antwort.

embed.ly selbst kann einfach über das jQuery Plugin angesprochen werden.

embed.ly – Kostenpunkt

embed.ly hat allerdings auch einen Haken: Es ist nicht kostenlos. Es gibt allerdings einen kostenfreien Account-Typ (nach unten scrollen!). Über diesen Account kann man monatlich 10.000 Aufrufe machen. Danach sind die Preise gestaffelt.

Für wen ist embed.ly und oEmbed interessant?

Allen voran ist die offensichtlichste Nutzung bei “Link-Sharing” Seiten wie Digg.com etc. Allerdings bekommt man auch über die pure URL ein paar Meta-Informationen raus, sodass man sich u.a. auch die Anbindung an eine komplexe API sparen kann.

Selbst ausprobieren auf embed.ly

embed.ly stellt ein “Test-Client” bereit über den man ein Gefühl dafür bekommt, welche Ergebnisse man erwarten kann.

Häufige Fehlerquelle: Das WebDAV Modul

Wenn im IIS noch WebDAV aktiviert ist, dann kommt dies Fehlermeldung meistens, weil es Überschneidungen mit dem WebDAV Modul gibt. Daher sollte man sicher gehen, dass man es entweder via web.config deaktiviert hat:

	<system.webServer>
		...
        <modules>
            <remove name="WebDAVModule" />
        </modules>
	</system.webServer>

… und wenn dies nicht hilft, dann nochmal kontrollieren ob die Einstellung auch greift. Zur Not kann man das Modul auch über den IIS Manager entfernen:

Wichtig: Es kann viele Fehlerquellen geben.

Im IIS kann man jedem Modul die entsprechenden Verben zuordnen:

Allerdings ist das recht kompliziert und im Regelfall sollte man nicht alles verstellen

Vor sehr, sehr langer Zeit hatte ich drüber gebloggt, wie man mit den Google Data APIs auf YouTube zugreift. Da einige Zeit vergangen ist, gibt es natürlich auch neue Wege wie man nun die Daten abrufen kann. Google stellt für YouTube eine “einfachere” Schnittstelle zur Verfügung. Wer low-Level HTTP calls machen möchte, der kann dies natürlich auch machen.

Ziel: Ich möchte die Daten zu diesem YouTube Video – dabei habe ich die genaue URL bereits:

http://www.youtube.com/watch?v=ItqQ2EZziB8 (anders als mein alter Blogpost, wo ich Dinge gesucht habe)

Per NuGet die Bibliotheken runterladen

Für das komfortable Zugreifen eignet sich die Google Data APIs. Diese findet man auch auf NuGet.

Benötigt werden das Google.GData.Client und das Google.GData.YouTube Package:

Code

(da mein Testclient eine Konsolenanwendung ist und ich Funktionalität aus der System.Web Assembly benötige, habe ich es auf das volle .NET 4.0 Framework umgestellt.)

			Uri youTubeLink = new Uri("http://www.youtube.com/watch?v=ItqQ2EZziB8");
            var parameters = System.Web.HttpUtility.ParseQueryString(youTubeLink.Query);
            var videoId = parameters["v"];

            Uri youTubeApi = new Uri(string.Format("http://gdata.youtube.com/feeds/api/videos/{0}", videoId));
            YouTubeRequestSettings settings = new YouTubeRequestSettings(null, null);

            YouTubeRequest request = new YouTubeRequest(settings);
            var result = request.Retrieve<Video>(youTubeApi);

            Console.WriteLine(result.Title);
            Console.WriteLine(result.Description);
            Console.WriteLine(result.ViewCount);

            Console.ReadLine();

Erklärung

In Zeile 3 hole ich mir den “v”-Parameter für das Video. In Zeile 5 lege ich leere YouTubeRequestSettings an – damit kann ich alle öffentlichen Daten abrufen, allerdings keine Kommentare verfassen oder Videos hochladen (was eigentlich klar ist).

Danach wird über request.Retrieve das Video abgeholt. Danach stehen mir allerhand Meta Informationen zum Video zur Verfügung.

Keine “Retrieve”-Methode zu sehen?

Ich hatte beim Entwickeln ein seltsames Problem – unter dem Request-Objekt hatte ich keine Retrieve oder Get Methode. Ich bin mir nicht sicher woran es lag. Jedenfalls stammt die YouTubeRequest Klasse aus dem Google.YouTube Namespace – evtl. hatte ich eine andere Klasse erwischt.

Weitere Infos gibts es auf der YouTube API .NET Seite.

Ergebnis meines Codes

[ Code on Google Code ]

Bereits im ersten Blogpost um RavenDB hatte ich auch das Management-Tool RavenDB Studio erwähnt. Wenn man RavenDB richtig als Server-Anwendung (z.B. innerhalb des IIS) ausführt, steht dort das Studio mit zur Verfügung. Wer allerdings RavenDB innerhalb der Applikation laufen lässt, muss zwei kleine Handgriffe machen um auch da die Management Oberfläche zu benutzen.

EmbeddedHttpServer mit starten

Das Studio muss innerhalb eines “Web-Servers” laufen – d.h. z.B. im IIS. Allerdings kann RavenDB auch einen “EmbeddedHttpServer” benutzen:

        private static IDocumentStore CreateDocumentStore()
        {
            var documentStore = new EmbeddableDocumentStore
            {
                ConnectionStringName = "RavenDB",
                UseEmbeddedHttpServer = true
            }.Initialize();

            return documentStore;
        }

Wichtig hier: UseEmbeddedHttpServer = true.Damit startet RavenDB auf Port 8080 einen Webserver.

Fehlermeldung “Missing file”

Wenn man nun auf Port 8080 über den Browser zugreift, kann einem diese Fehlermeldung begegnen:

Could not find file Raven.Server.xap, which contains the RavenDB Studio functionality. Please copy the Raven.Server.xap file to the base directory of RavenDB and try again.

Hier muss man die XAP vom RavenDB Studio besorgen – dies kann man z.B. hier runterladen. Die “Raven.Studio.XAP” befindet sich u.A. in dem Server Verzeichnis. Dieses File muss in das Root-Directory der Anwendung (Parallel z.B. zu eurer Global.ascx) kopiert werden.

Jetzt sollte das Studio aufgehen und man kann loslegen.

Meine Kollegen von der T-Systems Multimedia Solutions GmbH Sebastian Wagner und Daniel Kubis stellen auf den Visual Studio ALM Days (ehemals “TeamConf”) vor, wie wir bei uns den TFS einsetzen.

Dabei sind sie mit drei Vorträgen dabei:

- Praxisstudie zum erfolgreichen Einsatz des TFS 2010 bei der T-Systems Multimedia Solutions GmbH

- Was ist TFS Teambuild? Was kann ich damit machen und wie passe ich den Prozess an meine Bedürfnisse an

- Einblick in die SharePoint Entwicklung mit dem Team Foundation Server 2010 bei der T-Systems Multimedia Solutions GmbH

Wer Fragen zum TFS hat, kann vom 23.-25.11 sich auch vertrauensvoll an meine Kollegen in München wenden. Generell ist die Agenda für mit bekannten Namen aus der Szene besetzt.

Neugierig? Wir suchen!

Wer neugierig ist und sehen möchte, was wir sonst noch machen kann sich auf der Website umschauen. Natürlich suchen wir auch immer nach neuen Kollegen in den unterschiedlichsten Bereichen.

Dauerbrenner auf dem Blog ist der Artikel HowTo: 3-Tier / 3-Schichten Architektur. Allerdings hatte ich schon einige Zeit Zweifel (Ist eine 3 Schichten Architektur mit eigener DAL immer empfehlenswert?)daran, dass dieses Standardvorgehen immer der richtige Weg ist. Vor ein paar Tagen hatte ich dann einen interessanten Blogpost gelesen, welcher in die gleiche Richtung geht: Keep your code simple!

Von Spaghetti-Code zum Lasagne-Code

Jeder Entwickler hat verstanden, dass es nicht gesund ist 1000 Zeilen Code zu produzieren, welche nur für eine Funktion gut sind. Die Trennung in Schichten kann allerdings auch in das andere Extrem schlagen: Lasagne Code. Dutzende Schichten Code, ohne das sie wirklich was machen. Einfach nur, damit die Objekte von Schicht zu Schicht wandern.

KISS & YAGNI

Bevor man grundlos eine 3-Schichten Architektur wählt, sollte man sich die Frage stellen: Wozu brauch ich dies eigentlich?
Wozu Repository-, Business und Presentation-Layer? Wenn man wirklich zwei Frontends (WebApp und Fat-Client), dann mag das clever sein – aber meisten braucht man es nicht (YAGNI). Je mehr Schichten, desto langsamer wird die Entwicklung. Da eine Schnittstelle definieren und dort noch ein Property hinzufügen und dieses dann implementieren und das nur, weil man plötzlich auf der Website ein Feld mehr anzeigen will.

Mh… und wie könnte eine Lösung aussehen?

Ich bin mittlerweile recht pragmatisch geworden und hab auch keine so große Schmerzen mehr die Datenabfrage direkt im Controller (im ASP.NET MVC Sinne) zu machen.
Erst wenn ich die Abfrage doch noch woanders brauche, mach ich mir intensivere Gedanken ob man dies nicht in eine Art “Query”-Klasse auslagern kann.

Schreibende Vorgänge würde ich anfangs ebenso behandeln – erst wenn man es an mehreren Stellen braucht, würde ich dies in “Command”-Klassen auslagern.

Ziel davon: Copy/Paste sollte natürlich nach wie vor vermieden werden – die Businesslogik doppelt zu halten ist der falsche Weg.

Und wie steht es mit Unit-Tests?

Der einzige Knackpunkt an der Sache ist, dass man ohne Interfaces etc. natürlich schlechter mocken kann. Allerdings bin ich mir mittlerweile auch unsicher, welchen Wert diese Unit-Tests haben. Dutzende Tests, welche gegen Mocks gehen und 5 Zeilen Code testen.

Integrationstests, welche die gesamte Applikation testen, sind am Ende “aussagekräftiger” – dies kann z.B. über eine SQLLiteDb erfolgen oder man geht gegen die richtige (aber langsame Datenbank) etc. Bei einem kleinen Projekt, welches keine großen Abhängigkeiten hat, sollte dies im Bereich des machbaren liegen. Je größer die Backendsysteme, desto eher muss man sich einen Kopf darum machen, wie man das am Ende testen möchte.

“Poor-Mans CQRS”

CQRS ist ein nettes Konzept, welches die Trennung von Queries (Abfragen) und Commands (Schreibende Aktionen) vorsieht (und noch weit mehr). 

Daniel Lang (Autor vom Blogpost “Keep your code simple!”) hatte für seinen Ansatz den Begriff “Poor-Mans CQRS” gewählt – gefällt mir

Was am Ende zählt…

Am Ende des Tages muss immer eine funktionstüchtige Software rauskommen. Die Software sollte ihren Zweck erfüllen und es nützt nichts wenn man immer “streng nach Vorschrift” entwickelt – “es kommt halt drauf an…”.

TL;DR

Bevor man anfängt sich dutzende Schichten zurecht zu bauen, um auch alles mit Mocks und Unit-Tests ausstatten zu können sollte man sich die Frage stellen: Brauch ich das überhaupt? Was ist das Ziel? Vermeidet trotzdem Copy/Paste und lagert Sachen nach dem Prinzip “CQRS” aus – Queries für lesende Sachen und Commands für Aktionen.

Wer sich mit dem Trend? Thema NoSql beschäftigt wird früher oder später auch auf mongoDB stoßen. Was mongoDB für mich spannend macht, ist zu einem die versprochene Performance (auch wenn ich mit normalen Datenbank da noch nie an die Grenzen gestoßen bin) und zum anderen, das versprechen sich von diesem ganzen O/R Mapper Quatsch verabschieden zu können(und da stoße ich ständig an irgendwelche Grenzen).

Robert hatte sich schon hier und hier mit RavenDB beschäftigt und hier erste Ideen zum Design von NoSql Strukturen gesammelt. 

Wer sich jetzt Fragt: Was ist bitte der Unterschied zwischen mongoDB und RavenDB? (abgesehen vom cooleren Namen)

Naja eigentlich ist das ein Thema für einen eigenen Blogeintrag. Um es ganz kurz zu machen: monogoDB scheint schneller zu sein, unterstützt mehr Sprachen und hat deshalb die größere Community wohingen RavenDB die (viel) bessere Integration in die .net Landschaft bietet. Für mich persönlich ist mongoDB interessanter weil ich es auch für kommerzielle Projekte kostenlos nutzen kann.

So, toll… wo ist der Code?

Installieren

1. Hier lädt man sich mongoDB für Win, OSX, Solaris oder Linux runter: http://www.mongodb.org/downloads
2. Das Einzige was man selber machen muss ist dieses Verzeichnis anlegen “C:\data\db”
   Den Pfad kann man aber auch konfigurieren, nur wird mongoDB ihn nicht selber anlegen
   
3. Unter Windows reicht ein auspacken der Zip Datei und der Doppelklick auf die mongod.exe
   Wenn man will kann man mongoDB auch als Windows Service starten.
   
4. Das war einfach

Code

1. Was wir noch brauchen ist der mongoDB .Net Treiber und den gibt’s hier:
http://www.mongodb.org/display/DOCS/CSharp+Language+Center

2. Jetzt muss man diese beiden Referenzen einbinden:

3. So jetzt können wir die Verbindung herstellen:

MongoServer server = MongoServer.Create(); // connect to localhost                        

MongoDatabase demo = server.GetDatabase("demo");  // connect to database       

MongoCollection<User> users = demo.GetCollection<User>("users");

Mit Zeile 1 bauen wir die Verbindung auf, wenn nichts angegeben ist zu localhost und ohne Nutzername/Passwort. Zeile 3 gibt uns eine Datenbank zurück und Zeile 5 eine “Tabelle”. Mongo verhält sich hier wie eine normale Datenbank.

4. Daten einfügen

//insert
for (int i = 0; i < 10; i++)
{
  var result = users.Insert<User>(new User { Name = "Karl", Age = 20 });
}

5. Daten lesen

var userResult = users.FindAll();
foreach (var item in userResult)
{
 Console.WriteLine(string.Format("{0} - {1}",item.Name,item.Age));
}

6. Datenmodell

class User
{
    public ObjectId _id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public List<ObjectId> Tags { get; set; }
}

Ich habe als Typ für die ID ObjectId (kommt mit dem mongo Treiber) und nicht Guid benutzt. Der Treiber kann zwar auch mit Guid umgehen, allerdings wird die dann BASE64 Codiert als Binärfeld in die DB geschrieben und ich vermute einfach mal, dass dann die hauseigene ObjectId schneller ist.

7. n:m-Beziehungen …

… sind auch möglich, einfach in dem man das über die ID’s verknüpft. Ob man seine Daten Normalisieren will/ muss ist eine andere Frage, möglich ist es auf jeden Fall.

//setup second collection
MongoCollection<User> tags = demo.GetCollection<User>("tags"); // add & get a new collecton
tags.Drop();
List<Tag> initialTags = new List<Tag>() { new Tag("Cool"), new Tag("Fast"), new Tag("Jedi"), new Tag("Ninja") };
tags.InsertBatch(initialTags);

//add tags to a user (many to many)
foreach (var item in userResult)
{
    var randomTags = initialTags.Take(new Random().Next(0, 4)).Select(x=>x._id).ToList(); // add some random tags
    item.Tags = new List<ObjectId>(randomTags);
    users.Save(item); // saves changes to mongo
}

class Tag
{
    public Tag(string name)
    {
        Name = name;
    }
    public ObjectId _id { get; set; }
    public string Name { get; set; }
}

Jetzt haben wir zwei “Tabellen” eine mit Nutzern und eine mit Tags die den Nutzern zugeordnet werden können. Diese Bespiel zeigt auch wie man bei NoSql DB’s eigentlich nicht vorgeht. (ist mir erst hinter aufgefallen) Normalerweise würde ich dem Nutzer einfach Tags als Text zuweisen und mir eine Map/Reduce Abfrage bauen, wenn ich z.B. die Tags zählen möchte und das kann so aussehen: http://cookbook.mongodb.org/patterns/count_tags/

Wie schnell bist du?

Performace Tests sind immer so eine Sache, weil sie von vielen Faktoren abhängig sind. Allerdings war ich irgendwie neugierig und wollte mal sehen was passiert, wenn ich viele Elemente anlege und wieder lese.
Also hab ich mal auf verschiede Arten 10000 User angelegt, gelesen und wieder gelöscht:

int UsersToAdd = 10000;
//setup some users
Func<List<User>> getTestUsers = () =>
{
    var tmp = new List<User>();
    for (int i = 0; i < UsersToAdd; i++)
    {
        tmp.Add(new User { Name = "Karl" + i, Age = 20 });
    }
    return tmp;
};

//insert
Stopwatch insertTimer = new Stopwatch();
insertTimer.Start();
foreach (var item in getTestUsers())
{
    users.Insert<User>(item);
}
insertTimer.Stop();
Console.WriteLine(UsersToAdd + " users added in: " + insertTimer.ElapsedMilliseconds + "ms");

//bulk insert
insertTimer.Start();
users.InsertBatch<User>(getTestUsers());
insertTimer.Stop();
Console.WriteLine(UsersToAdd + " users added in an Batch: " + insertTimer.ElapsedMilliseconds + "ms");

//parallel insert
insertTimer.Start();
System.Threading.Tasks.Parallel.ForEach<User>(getTestUsers(), x => users.Insert<User>(x));
insertTimer.Stop();
Console.WriteLine(UsersToAdd + " users added parallel in: " + insertTimer.ElapsedMilliseconds + "ms");

//load all
insertTimer.Start();
var all = users.FindAll();
insertTimer.Stop();
Console.WriteLine("all users loaded in: " + insertTimer.ElapsedMilliseconds + "ms");

//drop all
insertTimer.Start();
users.Drop();
insertTimer.Stop();
Console.WriteLine("all users droped in: " + insertTimer.ElapsedMilliseconds + "ms");

Und hier sind meine Ergebnisse (4GB RAM QuadCore, HDD RAID5, keine SSD)

Verwaltung

Zum verwalten von mongoDB gibt es eine Reihe von Tools. Ich hab fürs erste den MongoExplorer genommen. Das schicke Silverlight Tool kann man bequem direkt von der Webseite aus installieren.

http://mongoexplorer.com/

Abfragen

Zum Thema Abfragen und Map/Reduce lohnt es sich einen eigenen Artikel zu schreiben. Nur so viel: steuern kann man mongoDB komplett mit Javascript. Mir persönlich hat diese ziemlich gute Präsentation viele Fragen beantwortet:

Microsoft hat auf der gerade stattfindenden SQLPass die Roadmap für die Thematik “Big Data” vorgestellt. Das Apache Projekt Hadoop wird dabei ein zentralen Punkt einnehmen.

Hadoop? Mhh… ?

Hadoop ist ein Framework oder ein System, welches verschiedene Komponenten umfasst. Ziel ist es immer, riesige (auch “ungeordnete”) Datenmengen zu verwalten und/oder zu analysieren:

The project includes these subprojects:

• Hadoop Common: The common utilities that support the other Hadoop subprojects.
• Hadoop Distributed File System (HDFS™): A distributed file system that provides high-throughput access to application data.
• Hadoop MapReduce: A software framework for distributed processing of large data sets on compute clusters.

Other Hadoop-related projects at Apache include:

• Avro™: A data serialization system.
• Cassandra™: A scalable multi-master database with no single points of failure.
• Chukwa™: A data collection system for managing large distributed systems.
• HBase™: A scalable, distributed database that supports structured data storage for large tables.
• Hive™: A data warehouse infrastructure that provides data summarization and ad hoc querying.
• Mahout™: A Scalable machine learning and data mining library.
• Pig™: A high-level data-flow language and execution framework for parallel computation.
• ZooKeeper™: A high-performance coordination service for distributed applications.

Hadoop selbst ist mit Java entwickelt und ist eher auf der Linux-Welt beheimatet, daher war die Ankündigung auch recht überraschend.

Hadoop & Windows Azure/Server

Laut Ankündigung soll Hadoop auch vollständig auf Windows Server laufen und es wird als Dienst in Windows Azure integriert. Die erste Beta soll bereits Ende des Jahres kommen. Danach im nächsten Jahr die Live-Schaltung.

Was heisst große Daten? Wer nutzt das?

Facebook hat vermutlich den größten Hadoop Cluster – in diesem Blogpost sind ein paar Zahlen und Fakten genannt. Beeindruckend auf alle Fälle.

Javascript ist überall!

Eine kleine Sache, welche mich als Entwickler zum Schmunzeln gebracht hat (und die wahrscheinlich viele DBAs in den Wahnsinn treiben wird):

For developers, we will enable integration with Microsoft developer tools as well as invest in making Javascript a first class language for Big Data. We will do this by making it possible to write high performance Map/Reduce jobs using Javascript. Yes, Javascript Map/Reduce, you read it right.

Ha!

Toolunterstützung

Für den SQL Server soll es Konnektoren geben, welche die Kommunikation zwischen der NoSQL Welt und der SQL Welt bewerkstelligen. Auch Excel und co. sollen entsprechend die neuen Möglichkeiten nutzen können.Weitere technische Details erfahrt ihr in diesem Blogpost.

Auch wenn ich selbst jetzt direkt nicht von dieser Neuigkeit betroffen bin, find ich es jedoch clever von Microsoft nicht sein eigenes Süppchen zu kochen sondern mal über den eigenen Tellerrand zu schauen. Ein paar mal hätte es jedenfalls in der Vergangenheit nicht schaden können.