Goed. Wat kunnen we hieruit concluderen? Dat alles gelukkig (?) gelijk getrokken wordt aan de interfaces van Windows Phone 7, XBox en Zune. Nu ‘heb elk voordeel zen nadeel’, en zo ook deze. Het feit dat Microsoft dit filmpje zo vroeg naar buiten heeft gebracht (en gaan geruchten dat Windows 8 in de tweede helft van 2012 uitgebracht wordt) heeft natuurlijk als reden gehad dat ze simpelweg aandacht willen krijgen voordat ze worden ondergesneeuwd door Google (Chromium OS) of Apple (iOS 5). Echter had ik gisteren een blog gelezen, waarin er goede tegenargumentatie besproken werd. De kans bestaat namelijk dat de verkoop van Windows 7 door een aankondiging als deze ingeperkt wordt.

De post is hier te lezen. Hij maakt een goede opmerking over het koopgedrag van de consument: Wanneer je weet dat de opvolger eraan komt, wat zou de consument dan motiveren om de huidige versie aan te schaffen?

En waar die post dan geen rekening mee houdt: ons ontwikkelaars. Gaat Windows 8 nu ook gebruik maken van Silverlight als basis voor haar applicaties? Zal het slechts HTML5 applicaties gaan betreffen? Hoe gaan ze om met bestaande softwarepakketten (third party)? Dit zijn allemaal punten waar wij in ieder geval straks rekening mee moeten houden. Nu laat het filmpje wel zien dat er een oudere shell (Windows 7) beschikbaar is, maar ik persoonlijk vind dat niet de beste oplossing. Nu biedt dit denk ik wel de beste mogelijkheid voor backwards-compatibility, zowel voor de programma’s als voor de gebruikers zelf.

Voor degenen voor wie het niet duidelijk is wat Model View Presenter doet, zal ik het even toelichten.

Model staat voor het Model Domain: Het (business) probleem dat je op probeert te lossen.
View staat voor de UI waarmee je met de gebruiker gaat communiceren.
Presenter staat voor de laag tussen die je Model fysiek van de View scheidt. Deze laag zorgt ervoor dat je Model niet afhankelijk is van je UI. In de praktijk blijkt deze laag ook uitermate geschikt voor unittesting. Je bent immers niet langer afhankelijk van je UI om je businesslogic te kunnen testen.

In de praktijk zal bestaat het Model vaak uit een of meer data entiteiten en businessrules. De view bestaat uit een interface die de mogelijkheden die de UI heeft omschrijft. De UI (Windows/WPF/Silverlight/Web/???) implementeert de view interface. De presenter zorgt voor de communicatie tussen de view interface en het model.

MVP Schematic Model

Voorbeeld:
Als voorbeeld gebruik ik een zeer vereenvoudigde manier om persoonsgegevens te muteren.

UI wordt geladen en roept op de Presenter een Initialize method aan. De presenter gebruikt het Model om de juiste gegevens te verzamelen. Vervolgens roept de presenter op de View de FillFields method aan en geeft de data als parameter mee. De UI die de View implementeert weet hoe de data weergegeven moet worden.

Vervolgens wordt er op OK geklikt. De OK button roept op de Presenter de SaveData method aan met de data, waarna de Presenter aan het Model opdracht geeft om eventuele wijzigingen op te slaan. Als hierbij een regel overtreden wordt, dan ontvangt de Presenter van het Model een validatie waarschuwing. De Presenter roept op de View een method aan aan met het validatiebericht, waarop de UI zorgt dat de melding getoond wordt.

Op deze manier is het zelfs mogelijk om twee hele verschillende UI’s dezelfde taak te laten uitvoeren. Als de UI de View inteface implementeert en de juiste calls op de presenter maakt zal het gewoon werken. De UI is in feite nog maar een heel dun schilletje dat geen enkele logica meer bevat.

Klinkt makkelijk he?

Is het deels ook. Deels ook helemaal niet. Dat komt door de fundamenteel verschillende manieren waarop een UI platform kan werken.
Als je je namelijk bij het ontwerp van je MVP classes en interfaces alleen richt op Windows Forms applicaties dan kom je jezelf onherroepelijk tegen als je deze classes wil gebruiken in een ASP.NET Webforms applicatie. Je hebt namelijk waarschijnlijk je hele ontwerp erop gebaseerd dat je state hebt. En dat heb je in ASP.NET niet op dezelfde manier zoals je dat in een Windows Forms applicatie. ASP.NET is in de basis zo stateless als maar zijn kan. ‘Gewoon’ even wat data in memory houden is er dus niet bij. Met statics moet je in ASP.NET Webforms rekening houden met multithreading.

Ok, dan vliegen we het toch aan vanuit de hoek van ASP.NET Webforms? Als je je bij het ontwerp van je MVP classes en interfaces alleen richt op ASP.NET Webforms dan kom je jezelf waarschijnlijk ook tegen. Je hebt het state probleem namelijk zojuist waarschijnlijk opgelost door gebruik te maken van je SessionState of Cache, wat het gebruik van deze classes en interfaces in een Windows Forms applicatie (bij het gebrek aan deze twee middelen) op zijn zachtst gezegd tot een uitdaging maakt.

I bring to you: Stateless Windows Forms.
Als je dus geen gebruik mag maken van de ‘statehulpmiddelen’ van ASP.NET, dan is ASP.NET WebForms tot nu toe helaas stateless. Daar doe je weinig aan. Bij Windows Forms heb je, hoewel het in het begin misschien wat vreemd aanvoelt, de keuze. Als je er rekening mee houdt dat je MVP classes en interfaces geen gebruik mogen maken van de state die Windows Forms biedt, maar ook niet van de technieken die ASP.NET biedt om het state(less) probleem op te lossen, dan kom je al een heel eind. Om jezelf te dwingen om hier rekening mee te houden doe je er goed aan om je Views en Presenters in een apart project onder te brengen waarbij je System.Windows.?? en System.Web.?? weigert te referencen. Bij je Model (data en businesslogic) hield je hier (als het goed is) al rekening mee.

Oplossing in het Driessen Framework
Met  bovengenoemde uitdaging in het achterhoofd hebben we in het framework een kleine ‘MVP Suite’ gebouwd die het voor de develpers makkelijk moet maken om applicaties standaard op MVP op te tuigen. Zo is straks een eventuele overstap van Windows Forms naar WPF ook eenvoudiger.

Het klinkt misschien vrij complex maar de daadwerkelijke implementatie is eigenlijk een lachertje, als je het concept maar snapt.

Model
Voor het Model hebben we in het Driessen Framework een BaseModel class gebouwd. De specifieke model class zal hiervan inheriten en bevat, naast de data entiteit en eventuele gerelateerde gegevens, de businesslogic voor het domain model. Deze class is gebouwd volgens stateless sessions, maar zonder gebruik te maken van SessionState of Caching. In Web gebruik je wel het SessionId om de sessie voor de dataclass te identificeren. In Windows bepaald het entry form een SessionId door een GUID hiervoor te genereren. De data wordt gecached via een custom caching systeem dat dus multi-platform werkt. Dit systeem zorgt er bijvoorbeeld ook automatisch voor voor dat disposes op het juiste moment plaatsvinden.

 /// <summary>
/// Base model for MVP projects that is able to work stateless/cross-session
/// Inherit: MyModel:BaseModel<MyModel>
/// </summary>
/// <typeparam name="TModelType">The type of the model that inherits this BaseModel</typeparam>
/// <example>
/// How to implement:
/// MyModel:BaseModel<MyModel>;
/// {
///    OtherEntityGrid otherEntityGrid;
///
///     public override Init(IBaseClass baseClass, IList<RelatedItem>relatedItems)
///     {
///         base.Init(baseClass, relatedItems);
///
///         otherEntityGrid = new OtherEntityGrid(baseClass.Core);
///         AutoDispose.Add(otherEntityGrid);
///     }
/// }
///
/// How to retrieve an instance:
/// MyModel myModel = MyModel.GetInstance(sessionId);
///
/// if (!myModel.Initialized)
/// {
///     myModel.Init(baseClass);
/// }
/// </example>
public class BaseModel<TModelType> : IDisposable
where TModelType : IDisposable
{
   #region Instance Members

    private readonly DisposableList autoDispose = new DisposableList();

    /// <summary>
   /// Auto dispose list for the Model to use to automatically dispose resources
   /// </summary>
   protected IList<IDisposable> AutoDispose
   {
      get
      {
         return autoDispose;
      }
   }

   /// <summary>
   /// True after the Init method was called
   /// </summary>
   public virtual bool Initialized
   {
      get;
      private set;
   }

   /// <summary>
   /// The baseclass used for editing
   /// </summary>
   public virtual IBaseClass BaseClass
   {
      get;
      private set;
   }

   /// <summary>
   /// The related items of the class
   /// </summary>
   public virtual IList<RelatedItem> RelatedItems
   {
      get;
      private set;
   }

   /// <summary>
   /// Initializes the model
   /// </summary>
   /// <param name="baseClass">The main baseclass of the model (optional)</param>
   /// <param name="relatedItems">Related items for the model (optional)</param>
   public virtual void Init(IBaseClass baseClass = null, IList<RelatedItem> relatedItems = null)
   {
      Initialized = true;
      BaseClass = baseClass;
      RelatedItems = relatedItems;
   }

   #endregion

   #region Static Members

   /// <summary>
   /// The default cache session id
   /// </summary>
   private const string defaultSesionId = "[DefaultSession]";

   /// <summary>
   /// The cache for session support
   /// </summary>
   private static volatile DisposableDictionary<string, TModelType> cache = new DisposableDictionary<string, TModelType>();

   /// <summary>
   /// Gets an instance from the cache for the provided session (or for the default session)
   /// Creates a new instance if no instance exists for the session yet
   /// </summary>
   /// <param name="sessionId">The session to get an instance for (optional)</param>
   /// <returns>The instance for the provided session (or the default session instance)</returns>
   public static TModelType GetInstance(string sessionId = defaultSesionId)
   {
      EnsureCache();

      TModelType returnValue;
      if (!cache.TryGetValue(sessionId, out returnValue))
      {
         returnValue = Activator.CreateInstance<TModelType>();
         cache.Add(sessionId,returnValue);
      }
      return returnValue;

   }

   /// <summary>
   /// Disposes the content for the session
   /// </summary>
   /// <param name="sessionId">The session to dispose the content for (optional)</param>
   public static void Dispose(string sessionId = defaultSesionId)
   {
      TModelType itemToDispose;

      if (cache != null && cache.TryGetValue(sessionId, out itemToDispose))
      {
         itemToDispose.Dispose();
         cache.Remove(sessionId);
      }
   }

   /// <summary>
   /// Disposes the entire content of the cache
   /// </summary>
   public static void DisposeAll()
   {
      if (cache != null)
      {
         cache.Dispose();
         if (cache.Count > 0)
               cache.Clear();
      }
   }

   /// <summary>
   /// Ensures the existance of the cache
   /// </summary>
   private static void EnsureCache()
   {
      if (cache == null)
         cache = new DisposableDictionary<string, TModelType>();
   }
   #endregion

   #region IDisposable

   /// <summary>
   /// Disposes the instance
   /// </summary>
   public void Dispose()
   {
      Dispose(true);
      GC.SuppressFinalize(this);
   }

   /// <summary>
   /// Disposes the instance
   /// </summary>
   /// <param name="disposing">Disposes managed objects</param>
   protected virtual void Dispose(bool disposing)
   {
      if (disposing)
         autoDispose.Dispose();
   }
   #endregion

   }
}

View
Voor communicatie vanuit de businessrules naar de UI hebben we een 2-tal simpele call mechanismen in een standaard View interface gegoten waarmee een eenvoudig bericht of een validation result naar de UI doorgegeven kan worden. De UI bepaalt op welke manier dit weergegeven wordt, afhankelijk van het platform waarop gewerkt wordt.

/// <summary>
/// The MVP view base
/// </summary>
public interface IViewBase
{
   /// <summary>
   /// Shows a message
   /// </summary>
   /// <param name="messageText">The message text</param>
   /// <param name="icon">The message icon</param>
   void ShowMessage(string messageText, ShowMessageIcon icon = ShowMessageIcon.Information);
   /// <summary>
   /// Shows the validation result
   /// </summary>
   /// <param name="validationResult">The validationreuslt</param>
   void ShowMessage(ValidationResult<ValidationMessage> validationResult);
}

Presenter
Voor de presenters hebben we in het framework een base class gemaakt die het BaseModel kan managen en initialiseren. De presenter zorgt zelf dat hij steeds de juiste data voor de huidige session paraat heeft staan als hij een call ontvangt.

/// <summary>
/// Base Presenter class
/// </summary>
/// <typeparam name="TView">The view corresponding to the presenter</typeparam>
/// <typeparam name="TModelType">The type of the model</typeparam>
public class PresenterBase<TView, TModelType>
where TView:IViewBase
where TModelType:BaseModel<TModelType>
{
  /// <summary>
  /// The view corresponding to the presenter
  /// </summary>
  protected TView View
  {
    get;
    private set;
  }
  /// <summary>
  /// The model for the presenter
  /// </summary>
  protected TModelType Model
  {
    get;
    private set;
  }
  /// <summary>
  /// The session ID
  /// </summary>
  protected string SessionId
  {
     get;
     set;
  }
  /// <summary>
  /// Constructor
  /// </summary>
  /// <param name="view">The view corresponding to the presenter</param>
  public PresenterBase(TView view)
  {
    View = view;
  }
  /// <summary>
  /// Initializes the presenter and gets the Data class instance for the session
  /// </summary>
  /// <param name="sessionId">The session ID to get the Data class instance for</param>
  /// <param name="baseClass">A baseclass to work with (optional, not used at the framework level)</param>
  public virtual void Init(string sessionId, IBaseClass baseClass = null)
  {
    SessionId = sessionId;
    Model = BaseModel<TModelType>.GetInstance(sessionId);
  }

 

De combinatie van deze drie vormt een krachtig middel om ècht platform onafhankelijk het MVP concept te gebruiken.

Ons eigen development framework bevatte al langer de ActionAudit class die gebruikt werd om dergelijke audits bij te houden. Dat deed hij in principe goed, maar het bleef de taak van de developer om op het juiste moment de juiste data via de ActionAudit te loggen. Zou het niet handig zijn als dit automatisch ging, met een minimale performance impact?

Met dit in het achterhoofd ben ik aan de slag gegaan en niet zonder resultaat al zeg ik het zelf.

In ons framework hebben we een eigen ORM implementatie. We genereren dus typed classes tegen de tabellen in de database die een hoop logic en datahandling van de developer overnemen. Voor de datahandling worden automatisch stored procedures gegenereerd. In de ORM generator kunnen we vanalles instellen, uiteenlopend van dataformats tot lookups en zelfs de captions die in de UI voor een veld gebruikt worden.

Sinds gisteren hebben we daar een optie bij: Is Logged. Het enige dat een developer nu nog hoeft te doen om een volledige change audit te realiseren, is die optie inschakelen. Er hoeft verder niets aangepast te worden. Het begint gelijk te werken.

Generator - Tabelinstellingen

Op het moment dat een developer deze optie inschakelt, wordt er naast de tabel een _log tabel geplaatst die dezelfde velden bevat als de tabel die gelogd moet worden, plus nog een aantal gegevens zoals: de soort mutatie, de datum/tijd van de mutatie en wie de mutatie heeft uitgevoerd.  Verder worden de insert,update en delete stored procedures die voor de tabel gegenereerd worden, uitgebreid zodat ze in een moeite door ook direct een audit regel in de bijbehorende _log tabel schrijven. De log tabel bevat geen indexes of constraints om hem zo light-weight mogelijk te maken. Zero-impact bestaat niet, maar we proberen natuurlijk wel weg te laten wat niet strikt noodzakelijk is.

Log

 Op deze manier is met maximale performance toch precies te volgen wat er wanneer door wie gemuteerd is, zonder dat er door de developer in code iets aangepast hoeft te worden.

Omdat onze huidige RAP web-applicatie (die gebouwd is met webforms) niet meer helemaal aan de huidige wensen voldoet, mogen we deze geheel opnieuw gaan ontwikkelen. Tijdens ons bezoek aan de DevConnections in Las Vegas zijn we goed geïnformeerd over de mogelijkheden van MVC in combinatie met het Entity Framework. Dus de keuze File – New – Project – ASP.NET MVC3 WebApplication was snel gemaakt… Binnen enkele seconden heb je een compleet werkende applicatie om mee te starten. Voeg hier nog een class library met een Entity model voor de database aan toe en je kunt vooruit.Een van de eerste uitdagingen waar we tegen aan gelopen zijn, wil ik hier wat verder uitdiepen. We willen voor de navigatie gebruik maken van een hoofdmenu, bestaande uit iconen en meerdere submenu‘s, met iconen en een korte tekst.

RAP Menu MVC

HTML helpers

Voor het genereren van HTML wordt in MVC gebruik gemaakt van Html helpers. Er worden geen helpers mee geleverd om hyperlinks te maken voorzien van een afbeelding, dus die hebben we zelf geschreven. Gelijk maar in een class library geplaatst, omdat we verwachten dat er nog wel meer bij zullen komen en zodoende deze ook in toekomstige projecten hergebruikt kunnen worden.
Nog even gekeken of we de TagBuilder zouden gebruiken danwel XElements, maar met XElements genereer je pure XML en dus geen HTML, wat nou juist de bedoeling is.

Sitemaps

Met onze eigen HTML helpers kunnen we nu eenvoudig de gewenste menu’s toevoegen aan de (master)View, die gebruikt wordt voor de layout van de pagina’s. Echter hebben we dan statische menu’s en we willen graag dynamische menu’s hebben door gebruik te maken van SiteMaps zoals dit ook in de huidige applicatie gedaan wordt. Helaas is dit mechanisme in MVC standaard  niet voorhanden.
Op CodePlex hebben we een ASP.NET MVC SiteMap provider gevonden die precies doet wat we willen en ons een HTML helper geeft voor het genereren van een menu. Door het maken van  DisplayTemplates voor het hoofdmenu en de submenu’s kunnen we e.e.a, eenvoudig koppelen aan bovenstaande helpers voor de hyperlinks.

<mvcSiteMap xmlns="href="http://mvcsitemap.codeplex.com/schemas/MvcSiteMap-File-3.0" enableLocalization="true">
    <mvcSiteMapNode title="SitemapRootDummy" clickable="false" changeFrequency="Always" updatePriority="Normal" key="SitemapRootDummy">
        <mvcSiteMapNode title="Start" controller="EmployerHome" action="Index" icon="Home" changeFrequency="Always" updatePriority="Normal" />

        <mvcSiteMapNode title="Extra" controller="EmployerHome" action="Extra" icon="Other" changeFrequency="Always" updatePriority="Normal">

            <mvcSiteMapNode title="Cvdr export"   controller="EmployerExtra" action="CvdrExport" icon="SmallOther" />

            <mvcSiteMapNode title="Portaalbeheer" controller="EmployerExtra" action="Admin"      icon="SmallOther" />

            <mvcSiteMapNode title="FAQ/Support"   controller="EmployerExtra" action="Support"    icon="SmallOther" />

        </mvcSiteMapNode>

    </mvcSiteMapNode>

</mvcSiteMap>

Op deze manier kunnen we elk gewenst menu maken zonder de layout pagina aan te hoeven te passen.

Sprites mvc

.LargeGlassIcons_SearchOpen-png {

width:48px;

height:48px;

background-image:url(sprite0.png);

background-position:-1078px -0px; }

.LargeGlassIcons_SearchOpen-png {

width:48px;

height:48px;

background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAAK~

…

~/) no-repeat 0% 0%; }|

Een veel gehoorde vraag is: Waarom helemaal daarheen? Waarom gaan jullie niet gewoon naar de DevDays?
De reden om sowieso jaarlijks naar de DevDays te gaan en in bijzondere gevallen ook naar een major event in het buitenland is tamelijk eenvoudig:

De DevDays is in mijn ogen met name erop gericht om mensen te laten weten wat er is, wat eraan komt en om ze aan de hand van pakkende voorbeelden te triggeren om eens wat dieper in de techniek te duiken. Dat is voor ons de reden om daar ook echt jaarlijks heen te willen. Je wil geen bruikbare technieken over het hoofd zien, of achter de feiten aanlopen.Major events zoals de VSLive! en de DevConnections hebben voor een deel dezelfde strekking, maar voor het overgrote deel gaan ze nèt dat stapje verder. Een stukje ‘outside the comfort zone’ van wat een technologie out-of-the-box kan. Als die geweldige nieuwe techniek (waarvan ons op de DevDays is verteld dat hij out-of-de-box de hele applicatie ongeveer voor je schrijft) in bepaalde gevallen onbruikbaar blijkt voor de wat grotere business processing applicaties, dan hoor je dat op deze events. En dat niet alleen: Er wordt ook uit de doeken gedaan hoe het dan wèl zou moeten of kunnen werken.

Mensen als Scott Guthrie, Brian Harry, Billy Hollis, developers uit het Visual Studio team, de team lead van het C# compiler team, UI guru Mark Miller (DevExpress) en nog veel meer vak idioten waarvoor dit dagelijkse kost is, staan voor je klaar. Niet alleen tijdens de sessies, maar ook daar buiten zijn ze te porren voor een bakkie of een lunch.

In oktober 2007 waren we ook al in Las Vegas te vinden op de VSLive! waar we ons hebben vastgebeten in UI design, quality assurance en application lifecycle management met Team Foundation Server. De resultaten hiervan maken nu deel uit van onze dagelijkse werkzaamheden. De manier van samenwerken, de hoge kwaliteit en de manier waarop we Team Foundation Server ‘uitnutten’ komt voor een groot gedeelte vanuit de VSLive!.

Waar we ons op de DevConnections 2010 mee hebben laten doorweken zijn in grote lijnen de do’s and dont’s van Silverlight, Windows Phone 7 development, MVC 3.0 en het Entity Framework.
Eerste resultaat: De nieuwe versie van onze RAP applicatie zal gebaseerd zijn op MVC 3.0 in combinatie met het Entity Framework.

Patrick heeft nog een aantal Microsoft Lync sessies bijgewoond, met als resultaat dat er nu op onze bureaus telefoons staan met een USB kabel in plaats van een telefoonstekker. Onze uitdaging is natuurlijk om hier uiteindelijk een koppeling op te maken vanuit onze software…

Gekkenhuis dus; Wanneer gaan we weer?!?

Op persoonlijke titel zou ik nog nog wel eens naar de Microsoft PDC willen. Daar doet Steve Ballmer himself de keynote .
Dat staat bij mij op hoog mijn persoonlijke ‘things to definitely do’ lijstje. Wie weet…

Een ander scenario is dat zulke schetsen in samenspraak met collega’s op een whiteboard worden geschilderd. Nadat je met elkaar eruit bent gekomen maak je een foto van het whiteboard en hang je de foto in TFS bij het product backlog item (ja ik weet het, we hebben nog een ‘poor-mans’ smart-board, wij maken er foto’s van ).

Toevallig liep ik vorige week bij het zoeken van mooie apps voor op mijn iPad, tegen een geweldige tool aan. Hij heet Balsamiq Mockups en de tagline is ‘so freaking good’. Nou, ik moet je zeggen, dat pakket is echt heel erg goed. Het is een simpel pakket om heel eenvoudig mock-ups van schermen te maken. Het ziet er echt als schets uit (dus geen programma schermpjes of zo), en het werkt werkelijk super snel. Je hebt het vlug onder de knie en het is heel makkelijk te gebruiken. Voortaan gooien we bij dat schetsen gewoon de beamer aan en doen we het digitaal op de muur! Wie heeft er nu nog een smartboard nodig, das zo 2009….

www.youtube.com/watch?v=zLysy3IPfFI

De gelukkige die hier mag komen werken valt daarbij meteen met zijn neus in de boter. Naast natuurlijk zulke fijne collega’s (kuch), mag hij/zij ook direct mee naar de DevConnections 2010 in Las Vegas. Lijkt me een prima reden om direct te solliciteren.

De advertentie kun je hier vinden.

Uitpakken van nieuwe PC's

De specs van de nieuwe machines liegen er niet om:

• Intel Core i7 860 (op een gigabyte mainboard met SATA3 en USB 3.0)
• 4GB Intern Memory
• 2x SSD 80GB Intel X25-M Postville (Raid-0)
• 2x 1TB Samsung HDD (Raid-0)
• 2x VGA card van Club 3d om 3 schermen aan te sturen
• en al dit moois in een kast van Antec met een superstille voeding

De SSD disks halen een doorvoer snelheid van meer dan 500MB per seconde! De Visual Studio IDE is in elk geval een heel stuk sneller geworden met de machines onder Windows 7. Ten op zichte van de vorige machines halen we een tijdsbesparing van 25% bij het builden van de applicaties en het draaien van de unit tests. We kunnen in elk geval weer een paar jaar vooruit!

Nieuwe developer PC's op een rijtje

De oude machines krijgen een mooi plekje als testservers. Met de in Raid-0 geschakelde disken en de dual core processors kunnen ze nog heel mooi dienst doen als SQL server in onze testfarm.

Secondly is the software itself. Of course creating the software should ensure the client’s problem no longer exists, but the software shouldn’t create a new problem. This is where high quality solutions are expected.

When creating software solutions I keep the following criteria in mind.

• High quality software: Software of low quality will contain bugs and bugs cost money and result in unsatisfied end users.
• User friendly software: Software with bad user experience will not be used and is a waste of money.
• Multi-tier architecture: Bad architecture may cause early or unfixable bottle-necks, in the worst case leading to scrapping the solution entirely, with the inevitable cost.
• Quick or good delivery: Software that is released too soon has the potential of having bugs or  corner-cutting. This could eventually lead to spending more time developing/bug-fixing after the first release.

High quality software
By using technologies like unit-testing, test driven development, code analysis and agile development, I can meet the higher expectations of sturdy and stable software. ‘Quick and Dirty is not an option’ is the motto I use when developing software.

Unit-testing is the process of writing code to test your code. In other words, every little piece of code gets tested by several unit-tests making sure all scenarios this particular code block can handle will get handled with success. The size of the application grows but the tested scenarios increase as well, making sure that every block of code keeps working as expected.
Since these tests exist in code and not by some test-script a human-tester needs to follow, thousands of tests can be run on a daily basis so the developer can detect flaws at a very early stage.

Test driven development is a technique where the developer writes the unit-tests for a code block before the code block is created. This helps the developer to better understand the code he is supposed to write and helps the developer improve architecture of the code before the code is written.

Code analysis is the use of strict coding rules and guidelines used and improved by .NET developers around the world. By building code according to these rules and guidelines, knowledge is used from developers worldwide who have experienced bad coding practices and written the rules or guidelines to ensure other developers don’t fall into the same trap.
Agile development lets the client (or user) get involved in the development process. By showing the development progress to the end user in a two to four week cycle the user can

1. Better understand the application when they start to use it;
2. Change the course of the development process as the application is growing (in this way the end product is exactly what the end user expected).
3. Achieve a better understanding of how the build progresses.

User friendly software
The success of an application doesn’t necessarily depend on how ‘clever’ it can be but more so on how ‘cleverly’ the user can use it.
If the software has lots of buttons, checkboxes, settings and highly complicated calculation capabilities, then the user often backs away and hardly dares to touch it. Whereas applications that have a friendly and simple look-and-feel have more chance of being used.
Why build a over complicated and flexible application if nobody knows or wants to use it?

Multi-tier architecture
The larger software solutions mostly aren’t run on one computer and aren’t used by one user. The more complex software solutions will be used by many  users with more than one role and will most likely run on different computers in different locations. By using multi-tier technologies these solutions can be built.

Two-tier applications are application where there is a client application running on the user’s pc and a server application running on the server handling the data the users provide.

Three-tier applications have a separate application running on a server which in general is used for ‘number crunching’ that could eat up the entire server capacity. These number crunchers shouldn’t be run on a client pc or data server because it could freeze the client application.

These technologies are used to balance the workload of the software over several computers so the user-interface on the client machine keeps responding, and the data server can keep up with handling the data changes.

Quick or good delivery
There is a very thin line between delivering a software solution too soon or too late.

If a tight deadline is set in advance, there is a bigger chance of active bugs in the final product because of cutting corners. But if the developer keeps building, testing and improving the software, the development process could end up in an endless loop of recreating and redesigning the software. The software is becoming too expensive to build.

Agile development helps in finding the right time for deployment of the software solution and ‘going-live’, even if there is a strict deadline or has strict functional requirements.

Om dit te laten functioneren moeten er enkele velden worden toegevoegd aan de bug workitem template. Sinds enkele weken is de beta van Power Tools voor TFS 2010 beschikbaar. Ik heb nog geen tijd gehad om te kijken wat er nu echt allemaal nieuw en verbeterd is, maar ik heb wel gelijk de eerste bug te pakken. Gelukkig stond het mijn test van onze TFSBugFarm service niet in de weg, omdat ik de noodzakelijke velden gewoon toe kon voegen. De minimale vereiste voor de TFSBugFarm service is een veld voor de username, en een veld om een reply te kunnen geven aan de user.

Wat is de TFS Bugfarm Service?
In essentie bestaat onze TFS Bugfarm Service uit een WCF service die verbonden is met Team Foundation Service en een base client met een Windows en een Web wrapper eromheen. Via de Windows wrapper is het voor de gebruiker mogelijk om zelf items  in te schieten in Team Foundation Server en om de afhandeling van deze items te volgen. Ook kan een Windows applicatie bij een crash zelf een screenshot maken en deze vervolgens, samen met de exception en de call-stack automatisch inschieten.

Via de Web wrapper kunnen onze portal sites (Payroll Portal en RAP) exceptions automatisch loggen in Team Foundation Server, zodat hiernaar gekeken kan worden. Via de Team Foundation Bug list kunnen items eenvoudig aan een sprint gekoppeld worden om opgelost te worden.

De Windows wrapper vind ik zelf wel erg leuk werken.  Hier zitten enkele standaard componenten in die je eigenlijk maar op een form hoeft te slepen. Vervolgens specificeer je alleen nog het TFS Bugfarm service URL en het TFS Project.

De componenten bestaan uit een issue list waarmee de voortgang van items kan worden bekeken en een submit form control om issues in te sturen. Die laatste bevat ook gelijk de mogelijkheid om attachments toe te voegen, en om screenshots direct vanaf het clipboard als attachment toe te voegen, zonder ze eerst op schijf op te hoeven slaan. Deze attachment zitten dan in TFS netjes als File Attachment aan het work item gekoppeld.

Als er zich een onverwachte exception voor doet, wordt dit scherm gestart. Automatisch wordt er een screenshot als attachment toegevoegd, en de exception message en call-stack worden in het bericht gezet. De gebruiker kan het item eventueel nog bewerken en hoeft vervolgens alleen maar op versturen te klikken.

Ik heb een paar screenshots gemaakt van de TFS Bugfarm client in Invio, een van onze Windows applicaties.

TFS Bugfarm opties in Invio

TFS meldingen bekijken in Invio

Een nieuw incident insturen in Invio