Thomas goes .NET - Blog

Sony Vaio VPCS12V9E/B Review

Thomas Bandt — Thu, 12 Aug 2010 23:33:00 +0200

Ich schreibe diesen Beitrag auf einem brandneuen Sony Vaio VPCS12V9E/B. Zwar bin ich mit meinem MacBook Late 2008 (13", 2,4 GHz Core2Duo, OCZ Vertex SSD) für den täglichen Gebrauch mehr als zufrieden, in der ein oder anderen Situation habe ich mir dann aber inzwischen doch schon etwas schnellere Hardware gewünscht. Dass ich nun aber schon mehr als anderthalb Jahre das gleiche Notebook besitze (wer mich kennt, weiß, dass das seeeeehr lang ist), rührt aber vor allem daher, dass Apple die Messleite einfach so unglaublich hoch gelegt hat. Ich habe bisher einfach keine brauchbare Alternative bei ähnlicher Qualität gefunden.

Der Zufall wollte es, dass ich letzte Woche bei Twitter auf eben jedes Sony Vaio aufmerksam wurde. Die Spezifikationen laßen sich prima, also sah ich es mir am Samstag im Laden an. Ersteindruck: hm. Ist halt Plastik. Also ließ ich es stehen und dachte noch ein wenig darüber nach. Vorgestern bestellte ich es dann doch, da ich mir einfach mal direkt ein Bild machen wollte. Nun steht es vor mir. Ich gehe es mal im Detail durch, soweit das nach einer Stunde möglich ist.

Optik

Definitiv Geschmackssache. Stünde es nur alleine vor mir und hätte ich noch nie ein MacBook gesehen, ich würde sagen es ist okay. Durch die Magnesiumlegierung und die Riffelung der Oberfläche der vorderen Handauflageflächen sieht es schon ganz gut aus. Stellt man es allerdings neben ein MacBook, fällt auf, dass es doch ganz schön dick ist, im Verhältnis zur Größe (13 Zoll).

Verarbeitung

Es ist un bleibt Plastik, Punkt. Gegen das Unibody-Gehäuse des MacBooks kann es einfach nicht anstinken. Der Displayrahmen ist nicht richtig versteift, die rechte Handauflagefläche lässt sich durchdrücken und mit einem nervösen Finger kann man durch beharrliches Tippen auf die DVD-Laufwerks-Abdeckung seine Umwelt gehörig Nerven kosten.

Tastatur

Optisch nicht ganz so straight wie die des Macs, allerdings von Verarbeitung, Anschlag und auch der Beleuchtung her top. Insbesondere die Größen der Tasten sagen mir zu, mit zehn Fingern tippt es sich jedenfalls wunderbar. Und als Windows-User auch nicht zu verachten: ein Windows-Layout ;-).

Display

Für mich eine einzige Enttäuschung, da von den blumigen Werbeversprechen nicht viel übrig bleibt. Die Blickwinkelstabilität ist nicht existent, die Helligkeit nur dann in Ordnung, wenn man keinen direkten Vergleich hat.

Touchpad

Man weiß beim Multitouchpad des MacBooks erst, was man an ihm hat, wenn man mal wieder ein gewöhnliches Trackpad benutzen muss. Zwar kann das Sony wohl auch Gestensteuerrung, allerdings ist das in der Qualität nicht annähernd zu vergleichen. Alleine ein Doppelklick mit zwei Fingern oder das Scrollen damit fehlt mir - hier habe ich am wenigsten Lust, mich umzugewöhnen.

Performance

Die gefühlte Performance ist schlecht. Das ist allerdings rein subjektiv und mag daran liegen, dass ich sowohl im MacBook als auch meinem "richtigen" Rechner im Büro seit mehr als einem Jahr mit SSDs arbeite. Festplatten waren, sind und bleiben einfach die Flaschenhälse. Für den Alltag ist es einfach völlig wurscht wieviel Power die CPU theoretisch hat, wenn das Starten des Systems aufgrund der lahmen Platte ein Vielfaches der Zeit eines Systems mit SSD braucht. Das ist dann auch der Grund, warum mir mein bald knapp zwei Jahre altes MacBook aus dem Stand noch schneller vorkommt. Bei CPU- und Speicher-lastigen Sachen wie Spielen wird sich der Eindruck natürlich nicht halten können.

Emissionen

Der für mich bei jedem Notebook definitiv wichtigste Punkt (gleich neben dem Design ;-)) sind die Emissionen. Weniger die Wärmeentwicklung, die kann ich an vielen Stellen verschmerzen. Wichtiger ist mir die Geräuschentwicklung. Nach mehr als 15 Minuten CPU-Dauerauslastung durch Prime95 lässt sich sagen: Aufgabe bestanden. Der Lüfter sprang sofort an und lief hörbar, aber nicht störend. Nachdem ich Prime95 stoppte, fuhr er auch sofort wieder herunter.

Während ich das tippe ist das Gerät nun seit einigen Minuten im normalen Betriebsmodus. Hier muss ich leider sagen, dass der Lüfter ständig leicht zu hören ist - nicht so beim MacBook.

Fazit

Für 1.200 EUR brutto erhält man ein solides Business-Notebook mit einer akzeptablen Verarbeitung und insgesamt doch sehr ordentlichem Preis-/Leistungsverhältnis. Für mich jedoch sind die Vorteile nicht überzeugend genug, um mich vom MacBook zu lösen. Ich hätte einfach das Gefühl einen Rückschritt zu machen, nicht zuletzt bei Verarbeitung (Unibody, Alu) und Design. Daher wandert das Sony nun wieder zurück in die Kiste und zum Händler. Ich muss wohl noch länger suchen und dann wohl auch tiefer in die Tasche greifen - oder einfach auf die nächste MacBook-Generation warten.

Aber einen Versuch war es wert.

Windows wins

Thomas Bandt — Tue, 10 Aug 2010 21:43:00 +0200

Es gab da vor vier Jahren einen Moment, in dem ich am liebsten alle Microsoft-Produkte weggeschmissen hätte. Das war die Zeit vor dem Launch von Windows Vista, als man in Redmond intensiv darüber nachdachte eine Art Wegwerf-Lizenz zu entwickeln, mit der man sein Windows nach einem Kauf nur noch 3x aktivieren konnte. Meine Wut darüber ging sogar soweit, dass ich mich kurz mit Java als Alternative zu .NET beschäftigte (von Mono war damals noch nicht wirklich zu sprechen) ;-).

Microsoft knickte nach einem Sturm der Entrüstung ein und veröffentlichte Vista schließlich unter einer Lizenz, wie man sie kannte. Was ihnen freilich auch nicht viel half – denn Vista war einfach nur träge, bunt und kein wirklicher Fortschritt. Der einzige Grund, warum ich es durchgängig einsetzte, war die Tatsache, dass Windows XP einfach schon steinalt und unsicher war.

So machte es mir Microsoft mit Vista Ende 2008 auch einigermaßen leicht, einen Blick nach Cupertino zu werfen. Mein erster Versuch anno 2006 war mehr oder minder kläglich gescheitert, aber durch die Liebe auf den zweiten Blick für das Alu MacBook bekam Apple seine zweite Chance.

Immer noch von dem Gedanken der Unabhängigkeit von Microsoft beseelt fing ich dann auch an OS X aktiv und intensiv als mein primäres Betriebssystem zu Hause und unterwegs zu verwenden. Wenn ich nun schon einen Mac hatte, wollte ich schließlich auch Mac OS verwenden. Das klappte auch – zwar musste ich für allerhand unter Windows gratis zu habende Utilities einiges zahlen, aber unterm Strich war ich fast eineinhalb Jahre sehr zufrieden.

Nun wurde in dieser Zeit das unglückliche Windows Vista durch Windows 7 abgelöst, auch auf all meinen Rechnern. Nutzte ich es anfangs auch auf dem MacBook zunächst via VM und später via Bootcamp noch parallel zu OS X, kam dann vor ein paar Monaten der Zeitpunkt, Apple wieder tschüss zu sagen.

Ich kann bis heute die Ursache nicht genau benennen, aber irgendwie vertrug meine OS-X-Installation das bootcampen nicht und ich war gezwungen alle paar Tage ein Backup (via TimeMachine ein Traum) einzuspielen. Irgendwann riss mir dann die Hutschnur und ich beschloss nur noch Windows 7 zu verwenden.

Nun bin ich immer noch durch meine Entwicklung mit .NET und Visual Studio sehr „Windows-addicted“ und das auch während der Nutzung von OS-X die ganze Zeit gewesen. Aber wie bereits geschrieben fand ich den Gedanken mehrgleisig zu fahren immer sehr reizvoll.

Das relativierte sich dann mit Windows 7 immer mehr. Heute bin ich an dem Punkt wo ich sage: Windows 7 ist nicht nur das beste Betriebssystem, dass Microsoft je veröffenlticht hat, es ist auch das bessere System im Vergleich zu Snow Leopard.

Dabei sind es vor allem die kleinen Dinge, die meine Produktivität einfach unglaublich steigern. Ob es das im Vergleich zu allen Mac-Lösungen viel funktionsreichere und effizientere Startmenü ist, der Windows Explorer mit seinen Favoriten (der Finder ist furchtbar umständlich im Vergleich) oder die Vorschau in der Windows-Taskleiste sowie die darüber erreichbaren gruppierten Instanzen einzelner Anwendungen (auch hier: das Dock löst das furchtbar umständlich!).

Es sind Kleinigkeiten die das Leben leichter machen – wie so oft. Natürlich bleiben Schattenseiten. Etwa die Höhe der Lizenzkosten, hier stellt sich Apple einfach viel geschickter gegenüber Privatkunden an (allerdings verdienen sie mit Software auch nicht ihr Geld, Microsoft schon). Und auch ein paar Features werde ich vermissen, beispielsweise das angesprochene Time Machine. Zwar nutze ich inzwischen Acronis 2010, was eine funktionierende „Nonstop Backup“-Funktion mitbringt, aber so bequem wie mit Time Machine ist es nunmal nicht.

Aber trotzdem: Windows wins. Zumindest in dieser Runde – und ich bin mir sicher, es werden noch viele folgen.

P.s.: Ich finde fast nichts peinlicher als Microsoft-Fanboys, wollte das aber mal gesagt haben ;-).

IIS 7.x - Uploadlimits konfigurieren

Thomas Bandt — Fri, 06 Aug 2010 16:19:00 +0200

Auch so ein Thema, dass mich mit jeder neuen Technologie-Generation für kleine Aufgaben stellt, solange ich denken kann, ist das Uploaden von Dateien auf den Webserver. Die Zeiten, in denen man dafür COM-Komponenten benötigte (Classic ASP) sind zum Glück vorbei, aber Microsoft lässt sich immer wieder was Neues einfallen, damit es auch spannend bleibt.

Da mit den Internet Information Services 7 die Konfiguration größtenteils in die Machine.config und Web.config gewandert ist, muss die maximale Größe für Dateiuploads pro Request (= Upload) nun auch dort eingestellt werden. Und zwar an zwei Stellen. Einmal in Bytes und einmal in ... genau, Kilobytes.

Nehmen wir also an, das Limit läge bei 100 MB. Dann sähe die Config wie folgt aus:

   1:  <?xml version="1.0" encoding="UTF-8"?>

   2:  <configuration>

   3:      <system.web>

   4:          <httpRuntime maxRequestLength="102400" />

   5:      </system.web>

   6:      <system.webServer>

   7:      <security>

   8:        <requestFiltering>

   9:          <requestLimits maxAllowedContentLength="104857600" />

  10:        </requestFiltering>

  11:      </security>

  12:      </system.webServer>

  13:  </configuration>

Da wusste die linke Hand wohl nicht, was die rechte ...

Installationsbefehl: Visual Studio Productivity Power Tools

Thomas Bandt — Thu, 05 Aug 2010 22:52:00 +0200

Ich bin gerade beim Abarbeiten meiner abonnierten RSS-Feads an einem Post von Scott Guthrie hängengeblieben, in dem er die Productivity Power Tools vorstellt. Irgendwo hatte ich davon neulich schon etwas aufgeschnappt, also habe ich sie mal installiert und nochmal Visual Studio gestartet.

Schon nach einigen Sekunden stand mir der Mund weit offen. Ehrlich gesagt verstehe ich gerade nicht, wie ich bisher darauf verzichten konnte!? Bisher dachte ich dass Jetbrains mit ReSharper das Maß aller Dinge hinsichtlich Visual-Studio-Erweiterungen darstellt, aber hier hat Microsoft selbst nochmal einen rausgehauen, der es in sich hat.

Lieblingsfeatures: Der Solution Navigator (wow!), Das Verschieben ganzer Code-Zeilen oder Fragmente per ALT+Pfeiltasten, der durchsuchbare Add-Reference-Dialog, pinnbare und farblich markierte Tabs. Scott hat es alles schon schön vorgestellt, daher spare ich mir die Details und verweise auf seine Posts:

Installieren und staunen! :-)

ASP.NET MVC - Wiederverwendbarer Pager

Thomas Bandt — Thu, 05 Aug 2010 15:34:00 +0200

Das Thema Paging (Deutsch: "Blättern") ist wohl so alt wie das World Wide Web, schließlich kann man den Usern große Listen von Daten so gut wie nie in einem Rutsch zumuten. Im aktuellen Projekt war es dann auch mal wieder so weit, Daten wollten seitenweise angezeigt und durchnavigiert werden.

Jetzt stand ich vor der Wahl ein noch aus WebForms-Zeiten stammendes, gut funktionierendes, Custom-Control zu verwenden, oder es "im MVC Style" zu machen. Irgendwie müssen ja Custom-Controls dann doch nicht mehr sein ;-). Ich stieß auf einen alten Beitrag von Robert von 2008. Seine Lösung gefielt mir damals gar nicht, irgendwie sah der Code etwas nach Nudeltopf aus. Allerdings habe ich mit dieser Art von Spaghetti-Code zu leben gelernt und finde ihn inzwischen nicht mehr wirklich schlimm. Zumindest nicht schlimmer als klassische Server-Controls mit ihren fünfhundert Templates, Attributen usw. Und die Grundlage, das Snippet von Rob Conery, habe ich so auch bereits verwendet.

Also habe ich seinen Code als Basis hergenommen und so modifiziert, dass ich einen im gesamten Projekt wiederverwendbaren Pager bekommen habe, den ich als Partial View überall einsetzen kann.

Erste Änderung: Die Properties sind aus der PagedList- in eine PagerInfo-Klasse gewandert. Somit lassen sie sich losgelöst von den eigentlichen Daten für die Generierung des Pagers verwenden, und zwar unabhängig vom verwendeten Typ der Objekte in der Liste.

   1:  public class PagedList<T> : List<T>

   2:  {

3:

   4:      public PagedList(IQueryable<T> source, int index, int pageSize)

   5:      {

6:

   7:          PagerInfo = new PagerInfo();

8:

   9:          PagerInfo.TotalCount = source.Count();

  10:          PagerInfo.PageSize = pageSize;

  11:          PagerInfo.PageIndex = index;

12:

  13:          PagerInfo.TotalPages = PagerInfo.TotalCount / pageSize;

14:

  15:          if (PagerInfo.TotalCount % pageSize > 0)

  16:              PagerInfo.TotalPages++;

17:

  18:          AddRange(source.Skip((index - 1) * pageSize).Take(pageSize).ToList());

19:

  20:      }

21:

  22:      public PagerInfo PagerInfo { get; private set; }

23:

  24:  }

25:

  26:  public class PagerInfo

  27:  {

  28:      public int TotalPages { get; set; }

  29:      public int TotalCount { get; set; }

  30:      public int PageIndex { get; set; }

  31:      public int PageSize { get; set; }

  32:      public bool HasPreviousPage { get { return (PageIndex > 1); } }

  33:      public bool HasNextPage { get { return (PageIndex * PageSize) <= TotalCount; } }

  34:  }

Als zweites habe ich einen entsprechenden Partial View angelegt, der das Rendern des Pagers übernimmt:

   1:  <ul class="pager">

   2:      <% if (Model.PagerInfo.HasPreviousPage) { %>

   3:          <li class="previous"><a href="<%= Url.Action(Model.Action, Model.Controller, new { page = Model.PagerInfo.PageIndex - 1 }) %>">« Zurück</a></li>

   4:      <% } else { %>

   5:          <li class="previous-off">« Zurück</li>

   6:      <% } %>

   7:      <%for (int page = 1; page <= Model.PagerInfo.TotalPages; page++) {

   8:          if (page == Model.PagerInfo.PageIndex) { %>

   9:          <li class="active"><%=page.ToString()%></li>

  10:          <% } else { %>

  11:              <li><a href="<%= Url.Action(Model.Action, Model.Controller, new { page }) %>"><%= page %></a></li>

  12:          <% }

  13:          }

  14:          if (Model.PagerInfo.HasNextPage) { %>

  15:          <li class="next"><a href="<%= Url.Action(Model.Action, Model.Controller, new { page = Model.PagerInfo.PageIndex + 1 }) %>">Weiter »</a>

  16:          <% } else { %>

  17:          <li class="next-off">Weiter »</li>

  18:      <% } %>

  19:  </ul>

Das Model beinhaltet nicht nur die "PagerInfo" sondern auch die Namen des Controllers und der Action, so dass das Ganze wiederverwendbar wird:

   1:  public class PagerViewModel

   2:  {

   3:      public PagerInfo PagerInfo { get; set; }

   4:      public string Controller { get; set; }

   5:      public string Action { get; set; }

   6:  }

Das war's im Prinzip schon, das Ergebnis kann man oben sehen. Zum Stylen kann ich genau wie Robert damals auf diesen Blogpost verweisen :-).

Anbei das Ganze als ausführbare MVC2-App.

Downloads

MvcPaging.zip (35,1 KB)

ASP.NET MVC - Formulare per Ajax verarbeiten

Thomas Bandt — Wed, 28 Jul 2010 12:03:00 +0200

Disclaimer: Ich bin kein Ajax-Entwickler. Als das Thema vor 5 Jahren auf den Tisch kam, hatte ich schon einige Jahre mit XmlHttpRequest im Internet Explorer gearbeitet, aber mich eigentlich schwerpunktmäßig immer auf die Serverseite konzentriert. Das hat sich auch bis heute noch nicht groß geändert - ich arbeite zwar mit jQuery, mootools und auch noch klassisch nativem JavaScript, aber meist wirklich nur für das Nötigste.

In normalen Formularen gehe ich was die Überprüfung der Eingaben angeht bislang recht klassisch vor - die Validierung findet im Service und damit auf der Serverseite statt. Sicherheit geht nunmal über alles. Entsprechend stiefmütterlich habe ich dann aber auch die clientseitige Validierung bisher behandelt.

Nun bin ich aber gestern zu einem Punkt gekommen, bei dem ich nur zwei Alternativen habe:

Eine vernünftige Lösung mit Ajax und/oder einem Client-Validation-Framework bauen.
Etwas serverseitiges und für den User schlecht benutzbares zusammenfrickeln.

Es geht um einen Dateiupload, genauer einen Multi-File-Upload, wie man ihn z.B. mit swfupload oder uploadify verwirklichen kann. Dieser Upload ist in ein normales Formular eingebettet, was einige Pflichtfelder besitzt. Wählt der Nutzer nun also Dateien aus und vergisst aber eines der Pflichtfelder auszufüllen und schickt das Formular ab - dann sind nach dem Roundtrip zum Server die ausgewählten Dateien wieder weg.

Keine gute Sache für den User. Also sollte der Workflow so aussehen:

Formular ausfüllen
Dateien auswählen
Formular überprüfen
Ggf. Eingaben korrigieren
Bei erfolgreichem Ausfüllen Formular abschicken und Hauptdatensatz anlegen
Anschließend die Dateien hochladen und dem Hauptdatensatz zuordnen

Dafür gibt es zwei brauchbare Wege (die mir einfallen):

Ajax

Validierung und Erzeugung des Hauptdatensatzes erfolgt per Ajax. Wenn dies geklappt hat, wird der Upload der ausgewählten Dateien angestoßen. Vorteil: die ID des Datensatzes steht hier vor dem Upload bereits zur Verfügung.

Client-Validation-Framework

Die Validierung erfolgt zusätzlich zur Serverseite, wo sie weiter obligatorisch bleibt, clientseitig, zum Beispiel mit dem jQuery-Validation-Plugin oder den Tools, die ASP.NET MVC dafür bereits mitbringt. Nachteile: doppelte Konfiguration (vernachlässigbar), im Zweifel verschieden aussehende Ausgaben der Fehler client-/serverseitig (vernachlässigbar), die ID des Hauptdatensatzes steht hier beim Dateiupload noch nicht zur Verfügung, da erst die Dateien hochgeladen müssen und dann der POST erfolgen kann.

Ein schwieriges Thema, bei dem wirklich hunderttausende Wege nach Rom führen. In Sachen Ajax stört mich der meist enorme Overhead. Ich habe relativ wenig Lust die Ausgabe der Fehler "zu synchronisieren".

Ein brauchbarer Weg erschien mir aber der von Jarrett Vance in seinem Post "Making an Ajax Form with jQuery in ASP.NET MVC" aufgezeigte. Vorteil: die Ausgabe bleibt exakt die gleiche, man muss sie nicht doppelt pflegen. Zudem braucht es auch keinen großen Aufwand auf der Client-Script-Seite. Nachteil: die Formulare müssen in PartialViews ausgelagert werden.

Ich habe es allerdings mal als Grundlage für eine Demo genommen und seinen Ansatz für meine Zwecke erweitert.

   1:  [HttpPost]

   2:  [ValidateAntiForgeryToken]

   3:  public ActionResult CreateTask(TaskViewModel model)

   4:  {

5:

   6:      // DEMO - Validierung wird im Service/BLL ausgeführt

7:

   8:      if(string.IsNullOrWhiteSpace(model.Name))

   9:          ModelState.AddModelError("Name", "Bitte geben Sie einen Namen an.");

10:

  11:      if(string.IsNullOrWhiteSpace(model.Text))

  12:          ModelState.AddModelError("Text", "Bitte geben Sie einen Text an.");

13:

  14:      if (ModelState.IsValid)

  15:          TempData["Success"] = "Task erfolgreich angelegt.";

16:

  17:      if(Request.IsAjaxRequest())

  18:      {

  19:          if(ModelState.IsValid)

  20:              return Json(new AjaxOperationResultInfo { Successfull = true, RedirectUrl = Url.Action("index") });

  21:          return PartialView("CreateTaskForm", model);

  22:      }

23:

  24:      if(ModelState.IsValid)

  25:          return RedirectToAction("index");

  26:      return View(model);

27:

  28:  }

Nur wenn es ein Ajax-Request ist, wird der PartialView zurückgegeben. Ansonsten, also in allen Fällen, in denen JavaScript im Browser deaktiviert ist, gibt es den normalen View zurück. Damit funktioniert der Spaß auch bei deaktiviertem JavaScript.

Nun ein Kompromiss:

Wenn ein Fehlerauftritt, wird der PartialView zurückgegeben. Wenn die Sache allerdings erfolgreich war, gebe ich ein JSON-Ergebnis zurück. Das ist zwar nicht astrein, erlaubt mir dann aber auf der Clientseite weitere Entscheidungen zu treffen. Im Beispiel übergebe ich die Ziel-URL, auf die nach erfolgreichem Verarbeiten des Formulars weitergeleitet werden soll. In meinem Praxisfall würde ich noch die ID des angelegten Datensatzes übergeben, damit diese beim Upload der Dateien gleich verwendet würden könnte.

Der JS-Code bleibt übersichtlich:

   1:  $(document).ready(function () {

   2:      $('#ajaxForm form').live('submit', function () {

   3:          $.post($(this).attr('action'), $(this).serialize(), function (result) {

   4:              if ($.isString(result)) {

   5:                  $("#ajaxForm").replaceWith($(result));

   6:              }

   7:              else if (result["Successfull"]) {

   8:                  window.location.href = result["RedirectUrl"];

   9:              }

  10:              else {

  11:                  alert('Es ist ein Fehler aufgetreten. Bitte benachrichtigen Sie den Codemonkey.');

  12:              }

  13:          });

  14:          return false;

  15:      });

  16:  });

17:

  18:  jQuery.isString = function (o) {

  19:      return (typeof o === "string");

  20:  }

Die komplette Projektmappe habe ich mal angehangen.

Unterm Strich bleibt es ein scheinbar brauchbarer Weg, richtig glücklich bin ich damit aber noch nicht. Ich werde als nächstes mal jQuery Validation testen sowie die DataAnnotations wieder ausgraben, rein für die clientseitige-Validierung.

Downloads

MvcApplication8.zip (110,72 KB)

ASP.NET MVC - TextBox für mobile Browser anpassen

Thomas Bandt — Thu, 22 Jul 2010 13:29:00 +0200

Im Vorgriff auf HTML 5 unterstützen viele mobile Browser bereits die neuen Input Types für Formular-Elemente, z.B. type="email".

Solange man nur für Desktop-Browser Websites erstellt, spielt das bislang keine Rolle.Interessant wird es für alle Szenarien, in denen keine physische Tastatur zur Verfügung steht - also z.B. für die Nutzer des iPad oder von Smartphones. Der Grund: je nach angegebenem Input Type wechselt das Tastaturlayout der Bildschirmtastatur.

Beispiel: hier sind die 3 verschiedene Felder eines Formulars aufgezeigt. Das erste ist ein Standard-Textfeld, das zweite erwartet eine E-Mail-Adresse und das dritte eine Telefonnummer, entsprechend sind auch die Input Types gesetzt (text, email, number).

Eine wirkliche Erleichterung für den Nutzer, da das Umschalten zwischen den einzelnen Ebenen der Tastatur nerven kann und es umso praktischer ist, wenn man die sowieso benötigten Zeichen, wie eben das @-Zeichen für E-Mail-Adressen oder Zahlen für Telefonnummern standardmäßig eingeblendet hat.

Die dargestellte Website läuft (noch) mit ASP.NET MVC 1.0, weshalb ich hierfür eine entsprechende Erweiterung geschrieben habe, die Textboxen mit beliebigen Input Types (als String) verarbeiten kann.

Code:

   1:  public static string MobileTextBox(this HtmlHelper html, string name, string inputType,

   2:      object value, object htmlAttributes)

   3:  {

4:

   5:      if (html.ViewData.ModelState.ContainsKey(name))

   6:          value = html.ViewData.ModelState.Single(s => s.Key == name).Value.Value.AttemptedValue;

7:

   8:      TagBuilder tagBuilder = new TagBuilder("input");

   9:      tagBuilder.MergeAttribute("name", name);

  10:      tagBuilder.MergeAttribute("type", inputType);

  11:      tagBuilder.MergeAttribute("value", (string)value);

  12:      tagBuilder.MergeAttributes(new RouteValueDictionary(htmlAttributes));

  13:      return tagBuilder.ToString(TagRenderMode.SelfClosing);

  14:  }

Anwendung:

   1:  <%= Html.MobileTextBox("email", "email", null, new { @class = "CssTextInput" })%>

   2:  <%= Html.MobileTextBox("telephone", "number", null, new { @class = "CssTextInput" })%>

iPhone 4 Review

Thomas Bandt — Tue, 20 Jul 2010 00:46:00 +0200

Da ist es also nun, das neue iPhone. Dieses Windows Vista unter den Telefonen mit furchtbaren Empfangsproblemen ...

Das Äußere

Als Besitzer eines iPhone 3G ist die neue Form für mich zunächst ungewohnt gewesen und der Funke mochte nicht sofort überspringen. Es ist wie bereits auf den Bildern zu sehen kantiger und liegt nicht mehr so geschmeidig in der Hand, wie noch die beiden Vorgängermodelle.

Dazu ist es gefühlt etwas schwerer als das 3G. Aber was erst im direkten Vergleich mit beiden Geräten in den Händen auffällt: es ist merklich kleiner und dünner geworden.

Und für sich betrachtet ist es aber ein echtes Schmuckstück und optisch insgesamt mit den verbauten Materialien mal wieder ein echter Meilenstein, wenn auch auf den zweiten Blick (wie es die Alu-MacBooks z.B. auch sind/waren).

Bei Apple hat einfach jeder Knopf eine Funktion und weniger ist hier im Vergleich zum HTC Desire beispielsweise wirklich mehr. Dazu kommt die Rückseite aus Glas, die es wirklich edel erscheinen lässt.

Was ich nicht so ganz testen mag ist die Kratzempfindlichkeit der Rückseite. Mein 3G hat nur einen gröberen Kratzer davongetragen, ansonsten hat das Plastik in den letzten 2 Jahren gute Dienste geleistet. Beim iPhone 4 wird wohl eine Hülle fällig, aber Apple verschenkt sie ja in Kürze ... ;-)

Empfangsprobleme

Keine.

Emissionen

Das Ding wird warm. Das wurde zwar das 3G auch schon, aber jetzt habe ich das Gefühl bei etwas intensiverer Nutzung – ich rede nicht von 3D-Spielen, sondern Musik, E-Mail und Browsen – sofort einen Temperaturanstieg zu spüren. Richtig störend war es aber noch nicht.

Das Display

Nur ein Wort: Wahnsinn. Das Display vom HTC Desire hat mir schon richtig gut gefallen, das des iPhone 4 steht ihm in nichts nach. Gestochen scharfe Darstellung, insbesondere bei Text ein nicht zu unterschätzender Fortschritt.

Die Geschwindigkeit

Nur ein Wort: Wahnsinn. Insbesondere das (verkappte) Multitasking, dass die verbliebenen aber reduzierten Gedenksekunden beim Start einzelner Apps drastisch reduziert, zeigt Wirkung. Ob E-Mail, SMS, Kontakte, Browsen oder das Durchblättern meiner 12GB Musik darauf – es geht einfach alles „sofort“.

Im Vergleich zum 3G ein absoluter Quantensprung. Zum 3G S hingegen sicher eher eine kleinere Veränderung.

Browsen

Der Vorteil des iPhone war 2007 bzw. 2008, dass es einen vollwertigen Browser mitbrachte, der neue Standards setzte. Endlich war es theoretisch möglich, das ganz normale Web auf dem Browser zu nutzen. Neben der limitierten Auflösung des Displays waren es aber vor allem der langsame Prozessor und der geringe Arbeitsspeicher, die das Surfen über nicht-mobile Websites unerträglich langsam machten. Das ist nun Geschichte, ob mit UMTS oder W-LAN, auch normale Websites werden benutzbar.

Die Software

Nun musste ich notgedrungen durch die Nötigung zum Jailbreak auf 3.1.3 bleiben, womit 4.0.1 nun für mich neu ist. Hintergrundbilder und Ordner sind nett, sonst ist nichts zu bemerken. Aber es tut eben alles, was ich konkret benötige (Stichwort Synchronisation von Kontakten und Terminen aus zwei Quellen und deren Zusammenführung auf dem Gerät) und ist natürlich nichts Neues zum 3G.

Der Umstieg war übrigens super einfach. Anschließen an den Rechner, iTunes starten, Backup des alten Telefons einspielen. Bis auf die Passwörter, die ich neu setzen musste, waren alle Apps und Einstellungen wieder vorhanden. Prima!

Die Kamera

Die Kamera ist besser als die des 3G, aber meine Canon PowerShot SX200 IS wird sie nicht ablösen. Der Digitalzoom ist natürlich Quatsch, auch der LED-Blitz ist eher von beschränkter Wirkung – aber besser als nix und für den Schnappschuss zwischendurch auf jeden Fall geeignet.

Die Videofunktion habe ich auf dem 3G natürlich vermisst – jetzt habe ich sie. Die Qualität erscheint mir ganz gut, es läuft alles flüssig und es ist ein Grund, die 32-GB-Variante zu nehmen ;-).

Tethering

Noch so eine Sache, mit der mich T-Mobile gequält hat, war mein UMTS-Stick, den unter Windows zu betreiben besonders viele Nerven kostet. Das Ding kann nun zu eBay, ich brauche ihn nicht mehr. Stattdessen setze ich einfach auf Tethering, dass am iPhone selbst innerhalb von Sekunden eingerichtet ist und auch mit Windows per USB problemlos klappt (Tethering an, iPhone andocken, iTunes starten, schon ist die Verbindung hergestellt). Ein Traum (und ein Grund mehr für O2 ...).

Fazit

Es sind jetzt erst 4 Tage, aber ich möchte es nicht mehr hergeben. Softwareseitig erfüllt es exakt meine Ansprüche, es ist schnell, schick und werthaltig. Für mich persönlich eine absolut gelungene Investition, da das mobile Arbeiten jetzt noch flüssiger wird.

TDD in der (meiner) Praxis – Wunsch und Wirklichkeit

Thomas Bandt — Sat, 17 Jul 2010 14:59:00 +0200

Zunächst einmal: Test Driven Development, wozu ich insbesondere „test first“ zähle, hat für mich einen gewissen Charme. Es ist zweifelsfrei so, dass dadurch die Architektur der eigenen Anwendung verbessert wird und viele kleine Fehler vermieden werden können. Der Teufel steckt ja bekanntlich im Detail. Umso besser, wenn man nun ein wirksames Werkzeug gegen ihn hat.

Die Frage ist nur: zu welchem Preis?

Nehmen wir mal eine Situation aus meinem Alltag. Ein potentieller Kunde fragt bei mir die Erstellung einer Webapplikation an, die ein wenig vom Standard abweicht, den ich mit meinen Komponenten abdecken kann. Individualprogrammierung ist also gefragt.

Nun kann ich den Aufwand in Stunden kalkulieren, ein paar Prozent Puffer draufschlagen und das Ganze mit meinem Stundensatz multiplizieren und erhalte in etwa den Preis, den ich dem Kunden machen kann.

Üblicherweise bewegen sich die Aufwände in meinen Alltagsprojekten dann zwischen 40 und 120 Stunden. Setze ich nun strikt auf TDD, muss ich hier von Anfang an mehr Zeit einkalkulieren – trotz inzwischen fast zweijähriger Praxis würde ich diesen Mehraufwand irgendwo zwischen 10 und 30% ansetzen.

Sind wir bei 100 Stunden und einem fiktiven Stundensatz von 80 EUR also bei 8.000 EUR, lande ich mit einer realistischen Kalkulation und TDD schon bei 10.000 EUR.

Nun ist das eine schöne Milchmädchenrechnung. Was zählt ist aber die reale Welt – und in dieser konkurriere ich mit meist gleich mehreren Marktteilnehmern, deren Qualitätsansprüche an die eigene Software ich nur erahnen kann (In diesen Budgetregionen konkurriert man im Zweifel auch häufiger mit PHP-Scriptern). Und klar gibt es Ausnahmesituationen in denen es keinen Sinn für den Kunden macht wg. 2.000 EUR zu entscheiden, da sollten andere Kriterien mehr zählen – aber nicht jeder Kunde tickt so.

Dann kommt zwangsläufig die Frage auf: welchen Wert hat es für mich, auf TDD zu beharren? Oder es gar selbst zu finanzieren, also auf die 30% Aufschlag zu verzichten und es „einfach zu machen“?

Von einem gebauchpinselten Ego kann ich mir am Ende des Monats nichts kaufen. Und den wesentlich besseren Code, den ich durch TDD ohne Frage erhalte, sehe ich in 80 von 100 Fällen sowieso nie wieder, da in diesen Fällen im Lebenszyklus der Anwendung höchstens einmal kosmetische Anpassungen fällig werden – bis die App nach ein paar Jahren verrichteten Dienstes einfach weggeworfen wird. Und selbst dort, wo die Anwendung kontinuierlich weiterentwickelt wird und Refactoring an der Tagesordnung ist, kann es sein, dass der Kunde Hautausschlag bekommt, wenn auf der Rechnung dafür auch nur irgendetwas mit „Test“ draufsteht – O-Ton: „Das ist für mich selbstverständlich!“.

Und wenn man die Augen aufmacht und mal sieht was es alles so an Technologien da draußen gab, gibt und geben wird, mit denen Software entwickelt wird – da muss man sich doch wirklich fragen, ob man nicht auf einem etwas zu hohen Ross sitzt? Schließlich werden auch heute noch Anwendungen mit Access, Filemaker, und was es nicht sonsts noch so an Verbrechen gibt, erstellt, betreut und von den Kunden begeistert oder wenigstens zufrieden verwendet. Obwohl es jedem von uns vermutlich den Magen umdreht, wenn man mal unter die Haube schaut.

Und nicht zuletzt muss man auch sagen, dass früher ja nun nicht alles schlecht war. Ich habe auch vor der Verwendung von TDD bereits robuste und gute Software entwickelt und ich kann nicht sagen, dass ich bei jedem Projekt im Anschluss erstmal lange Zeit für Bugfixing benötigt habe. Natürlich ist der ein oder andere Fehler erst beim Klicken durch die (Web-) Anwendung aufgetaucht – aber, so what?

Und den Versuch die Architektur meiner Anwendungen zu verbessern, unternehme ich auch nicht erst seit TDD. Sicher arbeite ich nun mit wesentlich weniger Koppelungen, mache mir noch mehr Gedanken im Detail – aber ich mache noch immer Fehler oder treffe (Design-)Entscheidungen, die ich so schon beim nächsten Projekt nicht mehr treffen würde. Das Rad dreht sich eben ständig weiter. Das heißt der alte Spruch „Bitte lass mich mit meinem Code von vor zwei Jahren in Ruhe“ wird so auch mit TDD nicht an Gültigkeit verlieren.

Zum Abschluss noch etwas Konkretes. Aufgabe: in der Datenbank werden Aufgabenlisten zu einem Projekt gespeichert. Es soll ein Formular erstellt werden, über welches diese Listen erzeugt werden. Die Aufgabenlisten sind wirklich simpel:

   1:  public class TaskList : EntityBase

   2:  {

   3:      public int ProjectID { get; set; }

   4:      public string Name { get; set; }

   5:      public string Description { get; set; }

   6:  }

Ohne TDD wäre das vermutlich eine Sache von 10-15 Minuten. Mit TDD und der damit verbundenen Zeremonien ... tja, ich glaube es war etwas mehr als eine dreiviertel Stunde.

Controller Tests (70 Lines of Code)

   1:  [TestFixture]

   2:  [Category("Blubr.App.Areas.Project.Controllers.TasksController")]

   3:  public class Wenn_eine_Aufgabenliste_angelegt_werden_soll :

   4:      ConcernOfTasksController

   5:  {

6:

   7:      private ITaskService TaskService;

8:

   9:      public override void Setup()

  10:      {

11:

  12:          base.Setup();

13:

  14:          TaskService = MockRepository.DynamicMock<ITaskService>();

15:

  16:          Sut = new TasksController(TaskService);

  17:          Sut.SetCurrentProject(new Domain.Model.Project { ID = 69 });

18:

  19:          using(MockRepository.Record())

  20:          {

  21:              Expect.Call(TaskService.CreateTaskList(Arg<TaskList>.Matches(l => l.Name == "Valid"),

  22:                  Arg<IValidationState>.Is.Anything)).Return(true);

  23:              Expect.Call(TaskService.CreateTaskList(Arg<TaskList>.Matches(l => l.Name == "Invalid"),

  24:                  Arg<IValidationState>.Is.Anything)).Return(false);

  25:          }

26:

  27:      }

28:

  29:      [Test]

  30:      public void Wird_der_Name_gemappt()

  31:      {

  32:          Sut.CreateList(new TaskListViewModel { Name = "testname" });

  33:          TaskService.AssertWasCalled(s =>

  34:              s.CreateTaskList(Arg<TaskList>.Matches(l => l.Name == "testname"),

  35:              Arg<IValidationState>.Is.Anything));

  36:      }

37:

  38:      [Test]

  39:      public void Wird_die_Beschreibung_gemappt()

  40:      {

  41:          Sut.CreateList(new TaskListViewModel { Description = "desc" });

  42:          TaskService.AssertWasCalled(s =>

  43:              s.CreateTaskList(Arg<TaskList>.Matches(l => l.Description == "desc"),

  44:              Arg<IValidationState>.Is.Anything));

  45:      }

46:

  47:      [Test]

  48:      public void Wird_die_ProjektID_gemappt()

  49:      {

  50:          Sut.CreateList(new TaskListViewModel { Description = "desc" });

  51:          TaskService.AssertWasCalled(s =>

  52:              s.CreateTaskList(Arg<TaskList>.Matches(l => l.ProjectID == 69),

  53:              Arg<IValidationState>.Is.Anything));

  54:      }

55:

  56:      [Test]

  57:      public void Wird_zur_Übersicht_weitergeleitet_wenn_alles_geklappt_hat()

  58:      {

  59:          var result = (RedirectToRouteResult) Sut.CreateList(new TaskListViewModel { Name = "Valid" });

  60:          Assert.AreEqual("index", result.RouteValues["action"]);

  61:      }

62:

  63:      [Test]

  64:      public void Wird_das_Model_zurückgegeben_wen_nein_Fehler_aufgetreten_ist()

  65:      {

  66:          var result = (ViewResult)Sut.CreateList(new TaskListViewModel { Name = "Invalid" });

  67:          Assert.AreEqual("Invalid", ((TaskListViewModel) result.ViewData.Model).Name);

  68:      }

69:

  70:  }

Controller Implementierung (16 LOC)

   1:  [HttpPost]

   2:  [ValidateAntiForgeryToken]

   3:  public ActionResult CreateList(TaskListViewModel model)

   4:  {

5:

   6:      var taskList = new TaskList();

   7:      taskList.ProjectID = CurrentProject.ID;

   8:      taskList.Name = model.Name;

   9:      taskList.Description = model.Description;

10:

  11:      if (TaskService.CreateTaskList(taskList, new ViewModelValidationState(ModelState)))

  12:          return RedirectToAction("index");

13:

  14:      return View(model);

15:

  16:  }

Service Tests (99 LOC)

   1:  #region Wenn eine Aufgabenliste validiert wird

2:

   3:  [TestFixture]

   4:  [Category("Blubr.Domain.Services.TaskService")]

   5:  public class Wenn_eine_Aufgabenliste_validiert_wird : ConcernOf<TaskService>

   6:  {

7:

   8:      public override void Setup()

   9:      {

  10:          Sut = new TaskService(Arg<ITaskRepository>.Is.Anything);

  11:      }

12:

  13:      [Test]

  14:      public void Darf_der_Name_nicht_NullOrWhitespace_sein()

  15:      {

  16:          var validationState = new MockValidationState();

  17:          Sut.ValidateTaskList(new TaskList { ProjectID = 1, Name = "" }, validationState);

  18:          Assert.IsTrue(validationState.ContainsKey<TaskList>(l => l.Name));

  19:      }

20:

  21:      [Test]

  22:      [ExpectedException(typeof(ArgumentException))]

  23:      public void Muss_die_ProjektID_angegeben_sein()

  24:      {

  25:          var validationState = new MockValidationState();

  26:          Sut.ValidateTaskList(new TaskList { ProjectID = 0 }, validationState);

  27:      }

28:

  29:      [Test]

  30:      public void Darf_die_Beschreibung_nicht_länger_als_500_Zeichen_lang_sein()

  31:      {

  32:          throw new NotImplementedException();

  33:      }

34:

  35:      [Test]

  36:      public void Darf_der_Name_nicht_länger_als_100_Zeichen_lang_sein()

  37:      {

  38:          throw new NotImplementedException();

  39:      }

40:

  41:  }

42:

  43:  #endregion

44:

  45:  #region Wenn eine Aufgabenliste angelegt werden soll

46:

  47:  [TestFixture]

  48:  [Category("Blubr.Domain.Services.TaskService")]

  49:  public class Wenn_eine_Aufgabenliste_angelegt_werden_soll : ConcernOf<TaskService>

  50:  {

51:

  52:      private ITaskRepository TaskRepository;

53:

  54:      public override void Setup()

  55:      {

  56:          TaskRepository = MockRepository.DynamicMock<ITaskRepository>();

  57:          MockRepository.ReplayAll();

  58:          Sut = new TaskService(TaskRepository);

  59:      }

60:

  61:      [Test]

  62:      public void Wird_true_zurückgegeben_wenn_alles_geklappt_hat()

  63:      {

  64:          var result = Sut.CreateTaskList(new TaskList { ProjectID = 1, Name = "Valid" }, new MockValidationState());

  65:          Assert.IsTrue(result);

  66:      }

67:

  68:      [Test]

  69:      public void Wird_die_übergebene_Liste_validiert()

  70:      {

  71:          var validationState = new MockValidationState();

  72:          Sut.CreateTaskList(new TaskList { ProjectID = 1, Name = null }, validationState);

  73:          Assert.IsTrue(validationState.ContainsKey<TaskList>(l => l.Name));

  74:      }

75:

  76:      [Test]

  77:      public void Wird_false_zurückgegeben_wenn_ein_Fehler_aufgetreten_ist()

  78:      {

  79:          var result = Sut.CreateTaskList(new TaskList { ProjectID = 1, Name = null }, new MockValidationState());

  80:          Assert.IsFalse(result);

  81:      }

82:

  83:      [Test]

  84:      public void Wird_das_Erstellungsdatum_gesetzt_wenn_alles_ok_ist()

  85:      {

  86:          Sut.CreateTaskList(new TaskList { ProjectID = 1, Name = "Valid" }, new MockValidationState());

  87:          TaskRepository.AssertWasCalled(r => r.CreateTaskList(Arg<TaskList>.Matches(l => l.Created.Date == Sut.DateTime.Date)));

  88:      }

89:

  90:      [Test]

  91:      public void Wird_die_Liste_im_Repository_gespeichert_wenn_alles_ok_ist()

  92:      {

  93:          Sut.CreateTaskList(new TaskList { ProjectID = 1, Name = "Valid" }, new MockValidationState());

  94:          TaskRepository.AssertWasCalled(r => r.CreateTaskList(Arg<TaskList>.Is.Anything));

  95:      }

96:

  97:  }

98:

  99:  #endregion

Service Implementierung (37 LOC)

   1:  public class TaskService : ServiceBase, ITaskService

   2:  {

3:

   4:      public TaskService(ITaskRepository taskRepository)

   5:      {

   6:          TaskRepository = taskRepository;

   7:      }

8:

   9:      private readonly ITaskRepository TaskRepository;

10:

  11:      public bool ValidateTaskList(TaskList taskList, IValidationState validationState)

  12:      {

13:

  14:          if (taskList.ProjectID == 0)

  15:              throw new ArgumentException("Projekt-ID nicht gesetzt");

16:

  17:          if(string.IsNullOrWhiteSpace(taskList.Name))

  18:              validationState.AddError<TaskList>(l => l.Name, "Bitte wählen Sie einen Namen für die Aufgabenliste.");

19:

  20:          return validationState.IsValid;

21:

  22:      }

23:

  24:      public bool CreateTaskList(TaskList taskList, IValidationState validationState)

  25:      {

26:

  27:          if (!ValidateTaskList(taskList, validationState))

  28:              return false;

29:

  30:          taskList.Created = DateTime;

  31:          taskList.ID = TaskRepository.CreateTaskList(taskList);

32:

  33:          return true;

34:

  35:      }

36:

  37:  }

Repository Tests (66 LOC)

   1:  #region Wenn eine Aufgabenliste angelegt wird

2:

   3:  [TestFixture]

   4:  [Category("Blubr.Domain.Data.SqlServer.TaskRepository")]

   5:  public class Wenn_eine_Aufgabenliste_angelegt_wird : ConcernOfSqlServerRepository<TaskRepository, Model.TaskList, TaskList>

   6:  {

7:

   8:      public override void FixtureSetUp()

   9:      {

  10:          Sut = new TaskRepository();

  11:          InitializeDatabase();

  12:      }

13:

  14:      public Model.TaskList DummyTaskList()

  15:      {

  16:          var list = new Model.TaskList();

  17:          list.Description = "Text";

  18:          list.Name = "Name";

  19:          list.ProjectID = 69;

  20:          list.Created = DateTime.Now;

  21:          return list;

  22:      }

23:

  24:      [Test]

  25:      public void Wird_die_ID_zurückgegeben()

  26:      {

  27:          var id = Sut.CreateTaskList(DummyTaskList());

  28:          Assert.AreNotEqual(0, id);

  29:      }

30:

  31:      [Test]

  32:      public void Wird_der_Name_gespeichert()

  33:      {

  34:          var id = Sut.CreateTaskList(DummyTaskList());

  35:          var list = Sut.Database.TaskLists.Single(l => l.ID == id);

  36:          Assert.AreEqual("Name", list.Name);

  37:      }

38:

  39:      [Test]

  40:      public void Wird_die_Beschreibung_gespeichert()

  41:      {

  42:          var id = Sut.CreateTaskList(DummyTaskList());

  43:          var list = Sut.Database.TaskLists.Single(l => l.ID == id);

  44:          Assert.AreEqual("Text", list.Description);

  45:      }

46:

  47:      [Test]

  48:      public void Wird_die_ProjektID_gespeichert()

  49:      {

  50:          var id = Sut.CreateTaskList(DummyTaskList());

  51:          var list = Sut.Database.TaskLists.Single(l => l.ID == id);

  52:          Assert.AreEqual(69, list.FKProjectID);

  53:      }

54:

  55:      [Test]

  56:      public void Wird_das_Erstellungsdatum_gespeichert()

  57:      {

  58:          var dummy = DummyTaskList();

  59:          var id = Sut.CreateTaskList(dummy);

  60:          var list = Sut.Database.TaskLists.Single(l => l.ID == id);

  61:          Assert.AreEqual(dummy.Created, list.Created);

  62:      }

63:

  64:  }

65:

  66:  #endregion

Repository Implementierung (21 LOC)

   1:  public class TaskRepository : RepositoryBase<Model.TaskList, TaskList>, ITaskRepository

   2:  {

3:

   4:      public int CreateTaskList(Model.TaskList taskList)

   5:      {

   6:          var newTaskList = new TaskList();

   7:          newTaskList.Created = taskList.Created;

   8:          newTaskList.Name = taskList.Name;

   9:          newTaskList.FKProjectID = taskList.ProjectID;

  10:          newTaskList.Description = taskList.Description;

  11:          Database.TaskLists.InsertOnSubmit(newTaskList);

  12:          Database.SubmitChanges();

  13:          return newTaskList.ID;

  14:      }

15:

  16:      public override Model.TaskList Map(TaskList source)

  17:      {

  18:          throw new NotImplementedException();

  19:      }

20:

  21:  }

Mein (Zwischen-)Fazit:

TDD ist cool, TDD ist nützlich, TDD verhilft zu besserer Software. Aber ist TDD auch alltagstauglich? Sollte ich es konsequent für alle Projekte, die jenseits von C:\Development\Tests\WebsiteProject12 hinausgehen einsetzen? Oder sollte ich zu alter Produktivität zurückkehren, ein paar mehr Fehler in Kauf nehmen? Die Antwort muss ich euch schuldig bleiben - mir schwirrt da vieles durch den Kopf, eine Entscheidung habe ich noch nicht getroffen.

iPhone 4: Da ist das Ding

Thomas Bandt — Fri, 16 Jul 2010 20:59:00 +0200

Nachdem ich vor knapp einem Monat von der Telekom zu O2 wechselte und von letzterer quasi zum Jailbreak genötigt wurde, habe ich dann nicht mehr groß überlegt und noch am selben Wochenende die Konsequenz für mich ganz persönlich gezogen: da ich weder Lust auf die Gängelung der Telekom hatte noch eine Alternative zum iPhone 4 sah, bestellte ich es mir einfach in England.

Das geht, weil dort die Exklusivbindung an einen Provider nicht (mehr) existiert und man das Gerät wie jedes andere einfach im Shop kaufen kann. Einziges Problem: Apple verlangt zwingend eine Lieferadresse in Großbritannien. Schon vorher bin ich über den Dienstleister Borderlinx aufmerksam geworden. Und nach einiger Recherche mit beruhigenden Ergebnissen (unter anderem hatten viele bereits das Nexus One Anfang des Jahres aus den USA darüber bestellt) habe ich mich dann kurzerhand entschlossen es einfach zu wagen.

Also bei Borderlinx registriert, individuelle Adresse in UK bekommen und diese bei der Bestellung einfach angegeben. Der Shop meckerte zwar und wollte eine seltsame Alternativadresse vorschlagen, aber man kann bei seiner bleiben. Als Rechnungsadresse wählte ich übrigens meine deutsche Büroadresse.

Das alles war am 19. Juni - die Lieferung wurde für den 14-16. Juli angekündigt. Tatsächlich war ich mir nicht sicher, ob Apple die Bestellung nicht doch noch stornieren würde - aber es geschah: nichts. Stattdessen kam am 6. Juli die Meldung, dass meine Sendung verschickt wurde, am 9. Juli folgte die Rechnung. Es dauerte bis zum 12. als die Sendung, wohl direkt aus dem Werk in China, in England eintraf.

Zumindest entnahm ich das aus dem TNT-Tracking. Borderlinx selbst zeigte keine Regung. Über Twitter erhielt ich dann den Tipp es mal mit nem Chat mit dem Support zu probieren. Und tatsächlich, das half (dringende Bestellung ;););)). Am 13. Juli wurde das Paket dann bei Borderlinx eingebucht. Nun musste ich die Weiterleitung noch bezahlen und wählte als Option Express-Lieferung.

Leider scheint Borderlinx eine etwas andere Definition von Expres zu besitzen, als ich es tue. Es tat sich jedenfalls anderthalb Tage nichts. Daraufhin chattete ich wieder mit dem Support, der mir diesmal aber nicht konkret helfen wollte. Mein Paket würde heute rausgehen (Agent 1) bzw. in 24-48h bearbeitet (Agent 2).

Ich lehnte mich schließlich zurück und ließ die Dinge laufen. Auf ein oder zwei Tage mehr oder weniger kam es jetzt ja auch nicht mehr an. Allerdings ging es dann doch relativ schnell: gestern Morgen um 9 meldete Borderlinx die Übergabe an DHL, 24h später schrieb mir der Empfang in meinem Büro, dass ein Paket für mich angenommen wurde.

Fazit also:

Wer das Gerät in Deutschland für 1.000 bis 1.200 EUR kauft, hat nicht mehr alle Tassen im Schrank. Für insgesamt rund 750 EUR für das 32GB-Gerät kann man getrost auf die Bestellung über Borderlinx zurückgreifen, etwas Geduld und eine Kreditkarte vorausgesetzt.

Ich bin jedenfalls froh das gemacht zu haben, auch wenn ich jetzt erstmal rund 500 EUR ärmer bin, als ich es bei einer Vertragsverlängerung bei T-Mobile gewesen wäre. Dafür amortisiert sich das Ganze durch meine extrem gesunkenen laufenden Kosten bei O2 auf 2 Jahre gesehen, und ich habe die Option im nächsten Jahr mit geringem Verlust direkt auf die nächste Variante upgraden zu können oder gar zu einem Android- oder Windows-Phone-Device zu wechseln. Nicht zu vergessen das günstigere (Daten-)Roaming, dass durch den fehlenden Netlock möglich wird.