TechEd Europe 2012, de vrijdag

Vandaag is het de laatste dag op de TechEd. Net als een achtbaan komt het vandaag met een schok ten einde, de laatste sessies zijn aan de beurt.

Deze vrijdag begin ik met een sessie van Peter Provost. Iedere dag heeft ons team wel van hem mogen genieten, dus het is echt de verslaving aan een dagelijk dosis Provost.

Vandaag gaat het over het testen van ‘untestable code’. Een uitdagig dus.

Dus de voorbeelden van deze week worden nog even aangehaald. Zo is er een unittest die de systeemklok wilt terug zetten. Wat zijn de neveneffecten? En daar is nog de test die een bestand op schijf wilt aanmaken. Hebben we daar rechten voor?

Provost haalt nog even SOLID aan. Dit geldt ook voor unittests.

De oplossing is een combinatie van:
– wrap exteren calls
– Use patterns zoals IOC

Dus Peter demonstreert hoe hij een Fake genereert van bepaalde systeem DLLs. Dit zijn gewoon lege klassen met dezelfde interface als de systeem klassen.

Via delegates/lambda wordt de output van methodes vervangen met eigen code. Refactor dus naar interfaces.

In dit voorbeeld injecteert hij een andere implementatie van een afhankelijkheid om de oorspronkelijke code toch te kunnen testen. Hij heeft controle over de dependency.

De Microsoft fakes zijn overigens geen Mocks maat stubs. Bij mocking wordt ook gemeten of bepaalde code wel of niet uitgevoerd is (zijn bepaalde methodes wel/niet aangeroepen). Wellicht was hier nog een oplossing van.

Maar als je niet kunt refactoren, er is een dependency naar bv. een website sessie object, dan heb je een probleem.

Maar Shims kunnen dit oplossen. Hij kan b.v. De DateTime.Now aanroepen vervangen via een ShimDateTime.NowGet = () =>;;;;;;;;;;;;; new DateTime(2000,1,1);

Iedere aanroep naar DateTime.Now wordt naar onze delegate omgebogen, zolang deze aanroep in de bijbehorende ShimContect (een omarming zoals using(ShimContext.Create()){…}) valt.

Peter raad aan de context binnen iedere test te houden en niet enkel aan te maken voor een hele groep aan tests.

Grappig detail: in een ViewModel heeft hij de aanroep naar DateTime.Now ook achter een interface gezet. Deze is dus te injecteren 🙂

In een volgend voorbeeld neemt hij de werking van een DispatchTimer over. Hij override de start methode en hij kan zelf de ticks aftrappen met eigen eventargs. Als hij de werking van een ViewModel test dan zie je dat de ViewModel op onze eigen ticks reageert. Dit is echt een reden om over te stappen naar VS2012 als je MVVM toepast en onderhoudt maar je mag de te testen code niet aanpassen (om interfaces te injecteren). Denk ook eens aan 3e partij componenten…

Dit heeft ook wel Monkey Patching.

Shims is dus erg krachtig maar ook een Code Smell. Gebruik shims alleen voor code die je niet kunt refactoren. De refactor heeft echt de voorkeur. Het is ook trager en je hebt heel veel kennis nodig van het te shimmen systeem.

Het genereren van de Fakes is ook nog te reguleren. In een XML setupbestandje is bv. aan te geven dat je alleen stubs wilt, en geen shims. En het aantal classen kan beperkt worden (bv. alleen DispatchTimer en geen DateTime). Dit scheelt ook tijd bij het aanmaken van de stub (bv. na een update van de originele code).

Zet ook eens Diagnstics op True en Verbosity op Noisy 🙂 Zo krijg je meer info en bestandjes in de obj.debug map. Hier zie je de echt gegenereerde code 😮

Er is ook nog een stub observer. Hiermee is evt. de aanroep naar de stubs en shims te controleren. Dan wordt het toch een soort van mocking.

De volgende sessie ging over MVVM testen voor Phone7. Deze sessie werd gegeven door Andy Wigley.

Ook hij is ooit begonnen met code-behind maar dat wordt al snel heel complex en de MVVM is hierbij de oplossing in de vorm van een goed architectuur.

Deze sessie gaat verder in op MVVM en hoe dit te testen valt.

Hij begint met was unittesten eigenlijk is. Het plaatje rond de kosten van bugs die (te) laat gevonden worden wordt even getoond.

Grappig is dat hij een NIET te testen applicatie toont. Het is de tutorial van Microsoft om branfstofkosten te meten. Het is een code-behind applicatie. En een Xaml pagina is niet of nauwelijks te testen. Je krijgt problemen met resources etc.

Met MVVM kies je voor ‘seperation of concerns’.

De Xaml roept je viewmodel aan en je viewmodel roept andere interfaces aan, bv. je model. En die ViewModel is wel te testen waarbij je de controle hebt over de injecteren implementaties van de interfaces.

Voor de Xaml is het viewmodel gewoon een instance die als resource beschikbaar is. En de visuele controls lezen en reageren (binden) aan de properties op de Viewcontrol. dit is dus gewoon een list of een string. En knoppen worden aan methodes gekoppeld (Commands). Er is wel 1 vereiste vanuit Xaml perspectief: De Viewmodel moet IPropertychange implementeren. Iedere wijziging op de properties van het ViewModel gaat een seintje geven dat de er specifiek iets gewijzigd is.

Services kunnen geinjecteerd worden als bv. dataservices od sessionservices. Deze services kunnen ook langer dan bepaalde viewmodellen leven en gedeeld worden. En deze zijn eenvoudig te mocken.

Grappig is dat hij naast de command voor de Viewmodel ook nog de buttonclicks gebruikt naar de codebehind. De reden is dat de codebehind voor hem gewoon extra UI logica is. Meer stopt hij er niet in. Echte functionaliteit gaat ALTIJD in de viewmodellen.

Daarna volgde een demonstratie met MVVMLight. Hierbij werd een service buiten de viewmodellen aangemaakt en op afroep geinjecteerd via een IOC oplossing.

Na de pause was het tijd voor het echte werk. Wat is er nieuw in WCF4.5?

Dit is inmiddels de 5e WCF versie. De vorige versie was al veel simpelder te configureren. Zo was er vooraf standaard gedrag, je moet alleen je eigen wensen nog configureren.

Deze versie maakt het gebruik nog simpelder. Zo is er de Contract First oplossing. En de WSDL wordt plat. En ASync zit er nu goed in.

In 4.5 hoeft alleen nog maar een service reference toegevoegd te worden en dat genereert al de gewenste configuratie. En in de config wordt via tooltips ook uitgelegd wat de elementen betekenen.

Als je start met een WSDL dan moet je via Svcutil /sc . Dit is prima voor Interop.

En WCF krijgt de aanvraag http://adres?singleWsdl dan worden alles in 1 WSDL gepropt waar vroeger voor iedere namespace aparte bestanden werden gemaakt.

En nu kan WCF ook Task Based Async gebruikt worden. Dit werkt samen met async/await aanroepen.

Advertentie

TechEd Europe 2012, Donderdag

Na een leuk avondje voetbal en lopen over de grasmat van Ajax kwam er weer een nieuwe dag op de TechEd.

Vandaag begon ik met een sessie rond Deep dive into TFS Agile tools. Waar we gisteren vooral oveerviews zagen, was het nu tijd voor wat diepgang.

Per medewerker in het Scrum team kan de workload per dag opgegeven worden. Hiermee wordt de overbelasting van medewerkers vastgesteld.

Microsoft heeft geen directe relatie gelegd tussen Effort (geschat met planning poker) van een story en de daadwerkelijke workload van de gecombineerde taken achter de story. Vanuit Scrum oogpunt is dit ook hoe het moet.

Wat ook leuk was, was de distributie van de story prioritering. Als de prioriteiten te dicht op elkaat stonden, dan werd er automatisch gehernummerd met gaten ertussen. Dit is praktisch.

Ook werd gedemonstreerd hoe de onderdelen van TFS aan elkaar gekoppeld werden. Dit werd steeds getoond via de achterliggende XML waar TFS de regels uithaalt. Er werd gevraagd of deze basale XML functionaliteit ook met visuele tooling ondersteund zou worden. De spreker gaf aan dat het op de backlog staat.

De wijzigingen zijn beperkt tot het team project waar je mee bezig bent. Of je moet de process template bijwerken en nieuwe projecten uitrollen.

De Agile process template kan dus helemaal bijgewerkt worden. Het werd met een leuke demo vergezeld, heel TFS kreeg een Dungeons and Dragons thema. De task werd een quest, etc.

Het area pad is inmiddels veranderd van functionaliteit. Het wordt nu gebruikt om userstories onder teams te hangen. Wil je een story aan een ander team vergeven, dan moet simpel het pad aangepast worden.

Vertrekkende collega’s uit een team met toegewezen taken, krijgen gewoon een lage capaciteit (0, oftewel hij kan geen bijdrage meer leveren). Voor de rest lijken deze oud-collega’s wel genoemd. De planning blijft overeind staan. Maar dit kan op de lange duur met een komen en gaan van collega’s wel vreemde effecten geven (wie is collega X en wie is die Y???).

De sprintkeuze wordt bepaald door de toegewezen start- en einddatums. De tijdzone op de server is hierbij leidend.

En helaas custimization kan alleen in de eigen TFS plaatsvinden. Dit is niet beschikbaar in de cloud…

Bugs zijn user stories, geen taken. Ze krijgen een effortschatting en zijn direct active.

De volgende sessie ging over ontwikkelen vor Azure. Hoe moet ik mijn Asp.Net voor Azure geschikt maken. Sayed I Hashimi is onze gastheer.

Azure betekent:
– websites (er is een optie voor 10 gratis wewbsites en een sql database)
– Cloud services (data, workflow, etc..)
– virtual machines

Een website is zo opgezet, zelf een manager (Luc) moet dit kunnen. En de Azure SDK is ook zo opgehaald. makkelijk.

Er was een demo om met Code First even snel een model en database aan te maken vanuit code. En dit werd in een Asp.Net MVC omgeving aangeroepen. Deze werd even lokaal uitgevoerd.

Die site werd naar Azure gebracht. Eerst moest in Azure een (lege) website met database bepaald. Een naam, regio waar je klantwen zitten, de subscription en een database type moest bepaald worden. De database kan overigens afgeschermd worden zodat alleen jouw site er bij kan.

Daarna was het tijd voor publiceren. VS2012 wist eigenlijk alles al wat er ingesteld was in Azure. Je kon de codefirst ook weer uitzetten. Dit voorkomt ongewenst wissen van de data of de complete database. De preview van de acties op de Azure site gaf een veilig gevoel.

En toen was de site zo uitgerold. Perfect.

Maar wat als de database veranderd? Of als schermen veranderen?

Hij gebruikte een bepaalde Nuget packege om database wijzigingen te faciliteren. Er werd voor iedere wijziging een UP en een DOWN in code ondersteund. Ik moet die package nog achterhalen.

En de publish gaf nu in de preview een aantal updates aan. En na de nieuwe publish was alles bijgewerkt. Prima.

Ik weet alleen niet hoe dit in een OTAP situatie moet gaan werken… Hoe laat ik de buildserver een automatisch een testversie uitrollen?

Er is eerst een commandline versie van de publish gedemonstreerd.

Daarna werd TFS Online getoond. In VS2012 werd het project daarin geplaatst. En Nuget Package Restore werd aangezet.

Erg gaaf. Doordat de Azure website, TFS Online en VS2012 aan elkaar gekoppeld zijn, kan nu bij iedere check-in een uitrol plaatsvinden na een succesvolle build. Maar een echte continuous build lijkt me een dure zaak. Persoonlijk zou ik een aantal build opsparen om de kosten te beperken. Tenzij het heeeeel goedkoop is, natuurljik.

Een lokale build kan wel degelijk ook direct deployen. Ergens in een schermpje moet een regeltje tekst ingetypt worden. 🙂 (te beginnen bij Build definitions; Process; ???)

OTAP zou ondersteund kunnen worden door verschillende builds (een continuous build en bv. een gold build) en die release naar een test site danwel de productie.

Hoe zit het met Cloud services zoals bv. worker roles en Azure queues. Hiervoor is de nieuwe Azure Services project bedacht. Haal eerst even je Azure certificaat lokaal. En in Azure moet een (lege) Azure service beschikbaar gemaakt worden. Hieraan wordt door het (lokale) project gerefereerd.

Storage is ook typisch iets van Azure. Er zijn een aantal smaken (SQL, blob, tables, queues).

Voor blob heeft een account meerdere containers (als in folders) en daarin de blobs zelf. Blogstorage kent geen state en het bespaart je computing cycles.

De volgende sessie ging over Debuggen in VS2012: going beyond F11.

Sinds VS2010 SP1 zijn er een aantal zaken veranderd. Zo zijn Phone7 en Azure nog belangrijker geworden. En met VS2012 moet ook Win8 ondersteund worden.

De VS2012 Express versie is nu beschikbaar voor Windows8, Web en alsnog voor de overige desktop applicaties.

Debugging is stiekem ook verder geevolueerd. Daar ging de sessie over.

Ten eerste bevat VS2012 een quick launch als aanvulling op het menu. Je kunt nu naar alle menu’s via tekstinvoer.

En zet dan in de options|debug even Enable Only my code even uit. Je krijg meer ruis maar je kunt nu ook dieper de stack in (voorbij External Code). Met source stepping kun je dan zelfs nog dieper en in delen van het .Net framework duiken. Ook hier is ook een vinkje voor. De symbols komen dan van Microsoft af via het web.

Er kwamen een paar basis debugging dingetjes voorbij. Breakpoints kunnen conditioneel gemaakt worden, je kunt ze labelen en groeperen om aan en uit te zetten (dan hoef je niet steeds de punten aan te maken en later weer te verwijderen) en importeren en exporteren (handig als je er een heleboel labels, condities aan gehangen hebt).

Variabelen kunnen ook gepint worden. Dan zie je zonder ‘hoveren’ de waarde tijdens het debuggen.

Remote debuggen zit nu ook in de express editie voor Win8. Het gaat ook op ARM werken. En anders werkt het vanaf de professional versie. En het mooie is dat het nu eenvoudig uit te rollen is en het werkt ook over WIFI.

Er moet op de doel machine gewoon “Remote tools” geinstalleerd worden. Het staat op de ISO en daarin op de remote tools folder. De firewall wordt wel even aangepast. Start dan een gecompileerde versie van de applicatie op gelijk aan de VS2012 versie. En attach nu VS2012 aan de draaiende applicatie op de doelmachine.

Voor Win8 Metro applicaties is er een simulator beschikbaar voor arm tablets. dit geeft een simulatie van een tablet met verschillende resoluties, basic touch en geo locatie. De simulator is ook praktisch om naast VS2012 een app te debuggen. Win8 apps draaien namelijk fullscreen.

De profiling is nu ook beschikbaar voor VS2012 Express Win8 editie. Profiling meet executietijden van methodes. Ik heb het zelf ook wel eens gebruikt en is best handig. Maar ik pak het meestal pas als ik de code verdacht langzaam vind. En de CPU sampling werkt op zich goed genoeg. Dit is dan ook de aanbevolen manier van profilen.

De pieken in de rapportage achteraf zijn het interessantste, dat is de ‘langzaamste’ code. En daarna refactoren daarna.

PDB’s bevatten de symbols die naast de code een complete debug versie vormen, ook na release. In TFS kun je een symbolserver opgeven die je symbols veilig stelt voor later gebruik.

Intellitrace kan uit een (debug) sessie de flow tonen maar ook heen en terug spoelen. Het is dus een soort van mediaplayer (voorheen videorecorder) van de flow. En er kunnen ook breakpoint in geplaatst worden. Intellitrace staat standaard aan, als het in je VS versie zit. Je krijgt dan ook een extra tabblad die de flow door de app toont. En je kunt terug gaan naar een eerdere versie om even opnieuw de flow door te lopen, in dezelfde sessie.

Een tracepoint lijkt op een breakpoint en wordt in Intellitrace opgenomen maar breakt de code niet.

Intellitrace werkt niet direct remote maar er is een Intellitrace Everywhere… Het is een mini VS2012 en die verzamelt de diagnostiek.

Na een kleine presentatie rond Phone 8 (komt niet op de lumia 800 en 900, sorry) op naar de Asp.Net Web Api sessie.

Het is niet de eerste poging rond Rest maar nu is het bovenop MVC gezet.

Ze hebben flink gewinkelt in de mogelijkheden van MVC zoals routing, binding validatie en filters, etc.

Web Api is inmiddels onderdeel van de MVC solution dus starten is eenvoudig. Maar out-of-bound komen binnenkort nog updates, het is tenslotte een open source project!

Dus bij het starten van een MVC4 solution, kan naast een aantal andere keuzes ook voor webapi gekozen worden. Na de benodigde installatie en het laden van nuget packages, staat daar opeens een (Api)Controller met een setje get, post, put en delete methodes.

Dit wordt via routing (Api is de differentiatie) als Rest opdrachten gezien en hoeft dus niet voorzien te worden van HTTPGet etc. De service snapt ook of deze JSon danwel Xml terug moetgeven (content negotiation).

Content Negotiation is via een extension method geregeld. Dit bespaart flink wat lastige code.

Een Entity Framework context kan ook eenvoudig als Rest aangeleverd worden. Hier is een aparte controller voor beschikbaar. Er zit ook een wizard voor beschikbaar maar die voegt niet zoveel toe. Nu wordt voor iedere entiteit (zeg Klant) een GetKlant, PostKlant, etc. aangemaakt. Zo kan heel eenvoudig een database of andere EF bron via het web beschikbaar gemaakt worden.

En we hebben nog steeds de beschikking over een ModelState.IsValid om de entiteiten te valideren. In de demo werd dit door Sayed Hashimi met Fiddler een Post samengesteld. Een Post was in de response met een Location Url en een primaire sleutel verrijkt.

Er zijn ook filters voor actions, authorisatie en exception.

En dan OData ondersteuning. Door een set van object als IQueryable te retourneren in een GET met daarop het attribuut [Queryably], is de GET een OData service geworden. Gaaf!

De Api is ook zelfbeschrijvend met de IApiExplorer. het is mogelijk om documentatie op te vragen over de methodes en deze zijn ook te verrijken met voorbeelden voor b.v. Xml en Json.

Hosting kan in IIS over via Selfhosting. Er werd een demo gegeven maar voor Unittests waarbij een API geinstancieerd werd, in memory. zag er wel spannend uit!

Uiteindelijk kwam er ook nog een HttpSelfHostingapplication voorbeeld naar voren. Self Hosting is lichtgewicht en heeft een performance voordeel als er geen visuele schermen aangemaakt moeten worden.

Web Api werkt voor MVC4 en hoger.

En dan eindelijk de door mij langverwachte OData sessie. Die werd gegeven door Paul Yuknewwicz. Het draait hierbij om het aanmaken en consumeren van OData, hopelijk.

OData is een eenvoudig formaat voor het serialiseren van data over het lijntje, met een query syntax om zoekopdrachten te verwerken en met metadata om de data zichzelf te laten beschrijven. OData is dus een service om data te openbaren en om data in op te slaan.

De demo van de GET met een aantal aardige filters was een NetFlix demo die al enkele jaren meegaat 😦 Maar de boodschap is nog steeds goed: de consument van de service kan een vraag stellen in de vorm van: geef mij alle films met de tekst ‘evans’ in de titel.

De output kan zowel het verbose XML als het zeer lichte JSon zijn. Dit werd met Fiddler aangetoond. Iedere taal of omgeving die met HTTP kan omgaan, is een potentiele consument.

Let wel even op de versie van de server, OData heeft een aantal versies, versie 2 is momenteel het meest gangbare. controleer dit dus even, anders krijg je niks of iets anders terug.

Van Microsoft producten die OData aanleveren werden genoemd oa. Excel Powerpivot, LightSwitch2011, SharePoint, Azure Marketplace en Azure zelf.

De volgende demo was erg leuk. Hij ontsloot de processen op een pc in Redmond. Dat is dus live data, geen gevulde database or zo. Vervolgens werd die met LightSwitch geconsumeerd in een visualisatie.

En hij kon ook in de gevisualiseerde data, een grid de read/write data aanpassen. In dit geval kreeg een service een andere naam.

LightSwitch kan ook OData produceren. Alles wat LightSwitch consumeert, wordt ook weer geproduceerd! Dus LightSwitch kan er een aardige MashUp van maken.

Azure DataMarket is data-as-a-service. Zo is er een air-carrier delay service om vertragingen van vliegtuigmaatschappijen op te zoeken. Dit werd met PowerPivot geconsumeerd.

Je produceert dus met:
– WCF Dataservices (voeg aan een standaard project een dataservice item template in VS2012 toe)
– Web Api – wordt steeds uitgebreider
– OData Library – ruw om eigen implementatie te maken
– LightSwitch

Er werd een Dataservice gebouwd rondom een Azure database. Dit is prima als je breed (alles) wilt vrijgeven of dit daarna wilt gaan beperken.

In versie drie wordt oa. Geo spatial data ondersteund en de Json is nog lichter gemaakt in JsonLight.

Daarna werd een service via WebApi aangeboden. Deze is zeer specifiek over wat je vrijgeeft. Begin met weinig en kan groeien.

Het voordeel van WebApi is dat deze alleen nog maar geinteresseerd is in IQueryable listen, geen datacontext meer. De data kan nu dus overal vandaan komen.

De laatste demo was een javascript voorbeeld.

En OData is gestandaardiseerd. Overheden kunnen hier dus gewoon gebruik van maken zonder dat ze voor Microsoft kiezen.

Update: PluralSight niet voor Europa?

Update: Goed nieuws! Microsoft heeft inmiddels voor maar liefst 25 PluralSight wereldwijd toegang laten geven als je over een MSDN account beschikt. Kijk op http://pluralsight.com/training/MsdnOffer/Courses voor een compleet overzicht. Het is een gevarieerd programma met tientallen uren video en het geeft ook een goed indruk van wat PluralSight voor jou kan betekenen. Het abonnement zal een jaar lang toegang geven tot alle presentaties, maar let er op dat je jouw account vóór 11 december activeert! Activeren kan op http://pluralsight.com/training/msdnoffer met jouw MSDN nummer.

Dank je wel, Microsoft en PluralSight!

Ik kreeg zojuist de volgende melding van de MSDN in mijn email box.

“Announcing a Special Limited-Time Training Benefit to MSDN Subscribers
Microsoft has teamed with Pluralsight to create a free, custom 12-month training subscription for U.S. MSDN subscribers. The Pluralsight Starter Subscription for MSDN contains 20 of Pluralsight’s most popular online training courses. To take advantage of this offer, simply redeem your benefit before September 15, 2012.”

De titel was veel belovend. Ik heb al vaker PluralSight video cursussen bekeken en gevolgd.

De op het net beschikbare gratis MVC3 cursus van hen heb ik ook veel (junior en senior) collega’s aangeraden want het is zeer efficiente cursus om over te stappen naar Asp.Net MVC3.

Dus ik was blij verrast, eindelijk een volwassen video cursus voor het grijpen en een prima hulpmiddel om mijn manager te overtuigen van het nut ervan.

Maar helaas, dit aanbod geldt alleen voor de ontwikkelaars in de US van A. Helaas vallen andere regio.’s hier buiten.

Het is een aangename constatering dat Microsoft soms kies om een externe partij te betrekken bij het groot maken van hun .Net platform. Ik ben al jaren vervent gebruiker van de CodeRush Express editie als aanvulling op VS2010. Dit maakt mij meer productie en ik vind dit een goede zet. Het is een win-win voor beide partijen.

Lieve Microsoft, mogen wij de volgende keer ook weer mee doen?

TechEd Europe 2012, Woensdag

Deze dag begon met een rustige start. We hadden een goed plekje gevonden bij de keynote welke voornamelijk in het teken van Windows 8 stond.

Windows 8 is voorbereik op een veranderende wereld. Onze wereld gaat draaien rond mobility, connectivity, content, people en touch. En de scheiding tussen thuis en op kantoor verdwijnt. Microsoft speelt hier op in.

Windows 8 pakt dit op door een nieuwe, vloeiende UI en apps. Volgens Microsoft is het zelfs beter dan Windows 7!

Het lockscreen geeft bv. al wat informatie over ongelezen mail of batterijstatus. En het picturepassword is een aardige feature, log niet in met een nummer maar met bepaalde gestures op een plaatje.

Win8 is ook ontdaan van chroom. MS heeft geprobeert alles weer functioneel te maken en de tierelantijntjes zijn weggelaten. De New Belgium Brewery app was een leuk voorbeeld van een simpele intuitieve applicatie met bing maps integratie en een kalender (leek net html zonder CSS).

Navigatie gaat ook zonder touch, de muis en keyboard worden ook nog ondersteund. Maar je moet wel beseffen welk gedrag gekoppeld is aan bepaalde lokaties op het scherm. Een klik links is iets anders dan linksboven.

En Semantic zoom is bv. via CTRL+ en CTRL- opgelost.

De bekende Windows 7 desktop is er natuurlijk ook nog steeds maar het ontging mij hoe ik er snel naar toe kon springen. Er was wel een tile voor. Dat de tiles als eerste getoond worden vind ik niet relevant. Als ik mijn pc opstart, dan wil ik meestal eerst even mail etc. controleren en dan zijn die apps snel beschikbaar.

De systeem search of all je apps is ook interessant. Je kunt nu direct detail info benaderen zonder eerst die apps op te starten.

De store is ook aardig. Alle navigatie die je verwacht, zit er in. Ik zag gelukkig ook “Top Free”.

Daarna kwam Virtualisatie aan bod. Win8 bezit een HyperV manager. Er werd ook direct vanuit Win8 een map uit een virtual harddisk benaderd door deze te openen vanuit de Win8 filemanager. Dat is erg handig en bespaart veel tijd.

Windows 8 kan ook vanaf een stick gestart worden, onder Windows 7! Je bedrijfs pc neem je dus op USB mee. De Win8 is dan volledig van je eigen Win7 gescheiden. En als je de stick er per ongeluk uit trekt, heb je 60 seconden om de stick weer terug te plaatsen. Win8 bevriest even maar crasht niet!

Hierna ben ik samen met Frankwin Faber naar de sessie Introducing the new Visual Studio 2012 Unit Testing Experience gegaan. Deze sessie werd gegeven door Peter Provost.

Deze sessie gaat over testen van je code terwijl je de code schrijft. Hij geeft ook een sessie op vrijdag over testen van ontestbare code.

MSUnit heeft een belabberde start gemaakt. Het was traag, ondersteunde geen C++ en het miste de nieuwste features. Het leek ook meer voor testers gemaakt te zijn en daardoor was het niet geschikt voor TDD.

Maar nu hebben we Vs2012…

Het testproject was er nog steeds. Maar de demo’s draaiden om XUnit. Het zit in Nuget en ik vond het wel verfrissend om eens geen MSUnit te zien. Als het maar door TFS Build ondersteund wordt…

Er wordt ook NUnit, QUnit en al enkele anderen ondersteund. En er is ook unittesting beschikbaar voor bv. javascript.

Er is nu een Test Explorer waardoor we ons niet meer door alle losse schermen hoeven te slepen. Let wel even op de te download VS2012 extension voor XUnit integratie (buiten Nuget om).

TFS build ondersteunt ook de 3de partij unittests en ook code coverage en ook de fakes. En het werkt ook allemaal in de Hosted Cloud build.

Microsoft draait voor VS2012 wel 65000 tests binnen 8 minuten.

MSTest is wel verbeterd: snelheid, Je kunt direct ASync (await) testen, er is ondersteuning voor 64bit en .Net multitargetting. En MSTest zit in de Visual Studio Express edities!

XUnit ondersteunt ASync, NUnit wellicht snel.

Dezelfde bestaande MSunittests zijn onderling uitwisselbaar tussen VS2010 en VS2012.

Fakes zijn er nu voor isoleren van je code. De Stubs lijken het meeste op mocking. Maar Shims werkt met runtime interception en kan daardoor leuke dingen doen.

Shims werd gedemonstreerd door een DateTime.Now na te bootsen. De System.4.0.0.0 DLL werd daarvoor geshimt naar System.4.0.0.0.Fakes, er werd een lege schil voor aangemaakt. De System.Fakes.ShimDateTime nam de aanroep van de Now over met een lambda aanroep naar NowGet. Hierbij moest wel een ‘tijd’ scope opgegeven worden. De shim mag niet vor eeuwig blijven werken.

Dit is voor een gedeelte overgenomen van Pex en Moles. Maar er is geen directe overlap en migratie is nog niet mogelijk.

Stubs werd niet echt gedemonstreerd maar het lijkt er op dat we geen interfaces hoeven te genereren voor stubs. Ze kunnen ook van reguliere klassen gegenereerd worden. Even testen dus 🙂

Maar Shims is een code smell. Is het echt nodig of kan je terugvallen op de nette Stubs.

Codecoverage is ook bijgewerkt en is nu veel eenvoudiger geintegreerd (een eenvoudige rechterklik). En de colour coding van wat wel en niet geraakt wordt, is ook netjes. Het is helaas niet voor alle VS versies beschikbaar 😦

TFS build ondersteunt ook de 3de partij unittests en ook code coverage en ook de fakes. En het werkt ook allemaal in de Hosted Cloud build.

Helaas moet nog steeds VS2012 op de TFS server uitgerold worden. Microsoft wilt hier graag feedback over ontvangen.

Compiling wordt pas builden als je overstapt op continious building. Dit geldt ook voor continuous unit testing. Er is nu een knop: Run tests after build, binnen VS2012. De (succesvolle) build en de test draait nu echt helemaal op de achtergrond dus je kunt bouwen en testen tegelijkertijd. Hou die testen op groen! De build is nu echt snel geworden; Frankwin constateerde droog dat we nu minder koffie kunnen gaan halen.

Er komt binnenkort ook een Test emulatie voor SharePoint.

Daarna stond de volgende sessie op het programma. Helaas waren er twee sessies over TFS automation tegelijkertijd. Ik ben naar de sessie van Neno Loje gegaan. De andere sessie kijk ik wel op Channel 9.

Delivery is erg lastig en kost veel tijd. Zelfs in een Scrum sprint van twee of drie weken kost een dag uitrollen veel te veel. We moeten dus automatiseren. En dat geldt ook voor kwaliteit. We moeten de tijd om de kwaliteit te controleren beperken.

Dus bepaal eerst, wanneer is je code klaar?Dit is de Definition of Done DoD. En kwaliteit is onderhevig van wanneer het getest is. Streef naar een constante kwaliteit. Aleen dan kun je ook estimaten want je weet wat je opgeleverd hebt en wat je nog mist.

Daarna volgde een demo met een build. Builds kunnen nu ook gepauseerd worden voor een latere uitvoering. In de Build, controleer altijd even de workspace. Hierin wordt vastgesteld wat naar de buildserver verstuurd moet worden. Dit kan meestal een stuk efficienter.

TeamExplorer is ook wat handiger, deze toont altijd de buildstatus van je favoriete builds.

Continuous build is prima voor kleine teams. Grotere teams kunnen Gated Checkin gebruiken. Hele grote teams kunnen zelfs buildopdrachten laten samenvoegen met een maximum.

Ook werd even een unittestproject gedemonstreerd. Unittesten werd automatisch een onderdeel van de build omdat de projectnaam de tekst TEST bevatte. Dit werkt ook voor andere merken tests zoals XUnit. Maar neem de extra testrunner adapter en specifieke dll’s op voor de buildserver in een mapje met dependencies.

Codecoverage werd getoond. Dit is nu heel eenvoudig aan te zetten. Helaas is dit alleen voor VS2012 Premium gebruikers beschikbaar. En je hebt een extra licentie nodig voor de build server.

We kunnen nu eenvoudig de output uit meerdere solution in aparte mappen laten droppen. Dit was niet beschikbaar in de vorige versie van TFS.

Shimes en fakes werd ook hier gedemonstreerd maar helaas met dezelfde demo als in het vorige uur. Pech, ik had gehoopt dat er afwisseling zou zijn. Is het zo moeilijk om verschilende voorbeelden te bedenken voor zo een belangrijke technologie?

Ook static code analysis is gedemonstreerd. Dit is een standaard onderdeel van de TFS Build. Je kunt eventueel je eigen rulesset samenstellen. Gewoon toepassen dus, een must have. Je kunt zelfs definieren dat warnings hieruit als builderrors worden beschouwd.

De layer diagram was ook heel aardig. Dit zit alleen in de Ultimate versie van VS2012. Even laagjes tekenen en de klassen er in plaatsen. Op de buildserver moet je de diagram checkbox aanzetten voor een layer check.

Labmanagement ondersteunt nu ook een eenvoudige testserver. Dit heet de standaard environment. Er is dan alleen geen snapshot mogelijkheid.

Op naar de volgende sessie. Vandaag is het echt een TFS dagje. Deze sessie gaat over het toepassen van scrum in VS2012.

Eerst wordt de Agile manifesto nog even aangehaald. En het sprint plaatje komt voorbij. Priotiseren van de backlog is belangrijk. De klant moet zich bewust zijn van wat er eerst gebouwd moet worden. De acceptatie criteria zijn bij de userstories ook van belang, pas dan mag je de items opnemen.

De nieuwe TFS backlog kan makkelijk priotiseren door drag en drop. En aan een backlog item kan een storyboard via Powerpoint aangemaakt en gekoppeld worden. Ook is er ruimte voor een acceptatie criterium. Items kunnen trouwens ook genest worden.

Het viel me op dat ik eigenlijk geen verschil heb gezien tussen TFS op premise en TFS in Azure. Erg mooi dus.

Van een productbacklog kunnen de items voorzien worden van Effort. dit gebeurt via planning poker (niet meegeleverd).

Dat kunnen de items aan sprints gekoppeld worden, afhankelijk van de velocity en de somatie van effort. En natuurlijk de hoogste prioriteit eerst.

In de sprint wordt iedere story van echte taken voorzien. En taken worden aan collega’s toegewezen. TFS toont al snel of collega’s te zwaar belast worden, lees: te veel uren aan taken moet spenderen.

Pas dan kan de sprint gaan beginnen.

De burn down chart kwam helaas maar heel even ter spraken en ik zag er geen TFS voorbeeld van. Het zal toch wel tussen de rapportages zitten?

Wel kwam het sprintbord in beeld. Ah, rechtsboven zie ik een BDC 🙂 Weer drag en drop van items. Prima, dit wordt een mooi aanraakscherm op kantoor voor de standup!

Dit scherm werkt samen met de MyWork explorer. daar zie ik de aan mij toegekende taken en ik kan ze ook op hold zetten of als Klaar markeren. Dit zou ik graag in actie willen zien! Het lijkt wel redelijk aan te sluiten op mijn manier (wens) van werken.

Er was nog een unittest demo maar die is de afgelopen sessie al vaker beschreven (zie boven).

Ook de Code Clone demo was wel interessant. Dit legt een vinger op de copy/paste wond.

Gaaf, als ik een taak aan het uitvoeren ben, dan kan ik onder die taak alle wijzigingen shelven. Dan kan ik netjes een andere bug of taak uitvoeren en later weer verder gaan met de ‘suspended’ taak. En later zal er een merge plaatsvinden vanwege de bugfix of andere taak.

Nu krijgen we dus vat op de velocity in TFS. Nu kan ik de forecast aanzetten in TFS en dan krijg ik een overzicht van hoeveel sprints ik nog moet uitvoeren. Dit is de waarheid, er is niks van gelogen. Komt het de klant niet uit? Dan moet er geschoven worden met resources. Helaas houdt de forecast geen rekening met vakantieperiodes en afwezigheid van collega’s. Er moet dus een correctie met de kalender in de hand gedaan worden.

De take aways:

TechEd Europe 2012, de dinsdag

De TechEd is de uitgelezen kans om kennis te tanken in het Microsoft ontwikkel- en beheerdomein. Ik krijg wel eens te horen dat er niet echt iets nieuws te melden is of dat de informatie ook op andere manieren verkregen kan worden. Maar ik vind de TechEd juist waardevol omdat ik in vier dagen alle informatie uit de gekozen sessies kan wegen en keuzes kan maken over welke technieken ik de komende, zeg, twee jaar wil gaan onderzoeken en gaan toepassen. En de rest laat ik gewoon vallen, dat is dan te licht bevonden. en die krijgen dan ook weinig aandacht tot het tegendeel bewezen is.

Dus, wat heb ik vandaag vernomen en heeft mijn aandacht getrokken?

Ten eerste was er de keynote. Deze kan je zelf ook herbeleven op channel 9.

Hoogtepunten waren oa.

• Ook de RAI kan geen WIFI regelen voor 6000 maal 2 draadloze devices
• Er werd een virtuele harddisk van 64Tb gedemonstreerd, samen met 100Gb virtueel werkgeheugen
• Er was veel aandacht voor de Azure Cloud en private cloud en combinaties daarvan
• De huidige capaciteit van Azure is gelijk aan tien Mb per inwoner van China en dan blijft er ook nog iets voor Nederland over
• Een Azure website kan door een manager nar de cloud gebracht worden
• Een Azurwe website kan vanuit TFS bijgewerkt worden met de laatste bits bij iedere continuous build
• OData is hot. het werd meerdere keren genoemd, ook met SAP in de hoofdrol
• Lightswitch kan nu ook in HTML5 gegenereerd worden

kortom. genoeg te zien. Daarna ben ik nog naar een aantal sessies geweest. Hieronder zal ik een impresie geven van de Alm teamsport sessie. Deze werd gegeven door Brian Keller, senior technical evangelist.

het was een overview van verschillende disiplines, dev, ops, test en overhead (management).

Het draaide om contnious value delivery: define, develop, deliver. Scrum ondersteuning lijkt prima, maar houdt rekening met succesvolle oplevering en de mogelijke problemen

Zo werd storyboarding met powerpoint gedemonstreerd. Hiervoor was er een extra tabblad. Mooi, maar wat moet ik doen om dit ook te krijgen? ook was er een handige en leuke screenclipping voor bestaande schermelementen. En er waren shapes ook vanuit gallerij. Zo kun je samen met de klant de buitenkant samenstellen zonder echt te coderen.

En iedereen heeft in TFS een gepersonaliseerde portaal met zijn eigen daschboard.

Estimation/forecasting is nu ook mogelijk: je kunt al meerdere sprints vooruit plannen. Je kunt ook zien of medewerkers niet teveel werk op hun bord krijgen als een medewerker meer of minder beschikbaar is. Aardige planning dus.

En er was een sprint board met virtuel postits, tap and go. Het was ook per medewerker te bekijken voor standup.

Je kan ook feedback requests uitzetten bij medewerkers/klant met evt. een taak om uit te voeren. De klant kan dit niet meer ontkennen. En de klant hoeft geen TFS licentie te hebben. Heel handig, maar wat krijg je terug?

• notes
• microfoon opname
• screencapture
• screenshots met annotaties
• ratings
• attachments

De feedback response kan aan bug/taak/workitem gekoppeld worden. En de uitvoerende dev heeft gelijk de feedback erbij, efficient dus.

Nu development: het gaat om in de zone blijven en niet teveel afleiding: team explorer toon nu ook openstaande taken (my work). De ontwikkelaar kab focus houden en qualiteit behouden. Je kunt je huidige werk suspensen en.later resumen (luxe shelven).

De dependency graph is erg gaaf en wordt op de achtergrond aangemaakt. graph.dgml file.

Vs2012 detecteert nu ook wijzigingen op schijf in de windows explorer.

En je kunt een code review aanvragen. Je gaat dan een DIFF aan een collega beschikbaar stellen. Dit staat dan in zijn mywork enhiiij geeft accept/decline. De file div is nu eindelijk handig en is erg uitgebreid. de reviewer zet de wijzigingen op de code. Dit is een mooi voorbeeld van zero email binnen vs2012.

branching/merging visualisatie zit al in vs2010. weinigen weten er van. maakt mergen visueel en je kunt zelfs enkele bestanden uitkiezen en verslepen naar release

Unittesten ondersteunt ook nunit en xunit, naast msunit via unittesting adapters. C++ heeft nu ook eindelijk unittesten. en dit alles werkt ook op de buildserver. Microsoft heeft mocks nu ook ondersteund maar het is tot fakes hernoemd.

Er is ook de code clone analysis en het werkt fuzzy. het is eeb mooie gelegenheid om refacteren te ondersteunen. Het vindt ook matching clones. Dan zoek je naar specifieke regels in hele solution om toepassing ervan te controleren.

Intellitrace mag aan/uitgezet worden op productie en werkt ook in development. Via powershell commandline kan de sysopt het configureren. De trace maakt een bestandje aan en dat speelt op vs2010 de acties na in de code. Ik zie hierbij ook locale informatie van de server. Je weet in ieder geval hoe ver je gekomen bent.

Ga zeker naar Tfspreview.com. Het werkt nu zonder invite code en is nu gratis. Er het blijft een GRATIS versie naast een betaalde versie. I heb gehoord dat hier ook een buildserver achter zit en het is DE gelegenheid om een migratie te testen.

En er is TFS Express voor max 5 gebruikers. Heb je meer gebruikers, stap dan over op de exterprise editie.

dev344 is een aardige vervolgsessie

Aan het einde van de dag was er een aardige bijeenkomst om onder genot van een biertje of twee de standhouders eens te verwelkomen. De eerste dag is dus prima geslaagd.

“Don’t shoot me, I’m just the In Process messenger”

In need of an English translation? Please drop me a note.

Voor ons huidige project zochten we naar een goed ontkoppeling tussen de user interface en de communicatie met hardware. Omdat het een WPF applicatie is en we gebruik maken van MVVM draait alles in hetzelfde applicatie.  De hardware willen we real time uitlezen en reageren op het gedrag.

Er werd dus nagedacht over het gebruik van Events. Dat is een prima oplossing voor “Loose coupling”. Maar hierbij is de ontkoppeling maar één kant op. De ‘luisteraar’ kent de verstrekker van de gebeurtenissen want hij moet zich daarop abonneren.

Omdat we MVVMLight gebruiken kregen we de mogelijkheid om nog verder te gaan met ontkoppeling. MVVMLight bezit namelijk ook een Messagebus.

De messagebus kennen we vooral vanuit SOA en Enterprise architectuur:

Maar hier hebben we te maken met messsages die In Process verstuurd worden. Hierbij zijn de volgende klassen te herkennen:

1. De boodschap, de Message
2. Diegene die ‘m verstuurt, de Sender
3. Diegene die zich abonneert op dit type bericht, de Target of algemener, de Receiver
4. De Messenger

Bij MVVMLight is dit opgelost met een aantal objecten die globaal beschikbaar zijn en via locking threadsafe zijn gemaakt. Hierdoor wordt het mogelijk om overal in de applicatie boodschappen te verzenden en eventueel te ontvangen.

Een boodschap is in het algemeen een overerving  van MessageBase, een standaard klasse beschikbaar in MVVMLight:

public class DeviceMessage : MessageBase
{
  public DeviceMessage(string message)
  {
    Message = message;
  }

  public string Message { get; private set; }

  public override string ToString()
  {
    return "Device message: " + Message;
  }
}

Hier hebben we een DeviceMessage die één property genaamd Message bezit.
Een message wordt verstuurd via de Send methode op de static Messenger:

Messenger.Default.Send<DeviceMessage>
    (new DeviceMessage("Time on device: " + DateTime.Now.ToString()));

Meer is er niet nodig om een boodschap op de Messagebus te zetten. In dit voorbeeld kan ik berichten met een datum/tijd verwachten. Zo kan ik ook vanuit een ViewModel juist een start- of stopcommando doorgeven aan een bepaald apparaat (of beter: een instanciering van iets wat de interface van dat apparaat implementeert). Ik heb geen kennis van de luisteraar, ik weet niet eens of die wel bestaat.

Hoe wordt het bericht ontvangen? Via een constructor of initialisatie heeft een andere partij zich geabonneerd op deze berichten:

Messenger.Default.Register<DeviceMessage>
  (this, true, m => {   Message = m.Message; });

In dit geval wordt de boodschap in op een ViewModel de m.Message uitgelezen en op het scherm getoond (via een bindable property).

Maar er is ook een bonus. De MessageBus is globaal beschikbaar en iedereen kan zich abonneren op berichten. MVVMLight biedt de mogelijkheid om met een Message ook een filtertoken op te nemen.

Messenger.Default.Send<SwitchMessage>
  (new SwitchMessage(this, "AnotherDevice"), "DeviceSwitchToken");

In dit geval kunnen meerdere partijen zich abonneren op een SwitchMessage. Maar door de meegestuurde “DeviceSwitchToken” zal wellicht niet iedereen de SwitchMessage verwerken, ze wachten op zo’n bericht vergezeld met een ander token.

En het is ook mogelijk om zich juist op een scala van berichten te abonneren. Het is mogelijk om alle overervingen van een baseclass te ontvangen:

public class LogProvider : ILogProvider
{
  public void Initialize()
  {
    // log all messages
    Messenger.Default.Register<MessageBase>(this, true, m =>
    {
      Debug.WriteLine(
        String.Format(
           "At {0} we received: {1}", DateTime.Now.ToShortTimeString(), m));
    });
  }
}

Hier heb ik een logger geabonneerd op alle overervingen van MessageBase.

Door de totale ontkoppeling van de zenders en ontvangers kan je het overzicht verliezen. Maar juist door deze logger heb ik een mooie tijdslijn van wat er onderling verstuurd is en kan ik analyseren wat er mis is gegaan. Daarom implementeer ik ook de ToString() zodat ik de messages hun eigen te loggen boodschap kan laten beschrijven.

Ik kan ook als een soort van watchdog een pulse afgeven. Als ik niet de gewenste antwoorden ontvang kan ik ‘alarm slaan’. En dit kan ik doen zonder dat ik de daadwerkelijke implementatie van de te controleren instanties niet ken.

Er zijn in MVVMLight nog een aantal andere boodschappen mogelijk. Ik wil er nog één aanstippen.

MVVMLight kent ook een generic message. Deze bevat standaard een Content property waarin een andere klasse gestopt kan worden. In bovenstaande voorbeelden is steeds gebruik gemaakt van een MessageBase overerving met extra properties. Met de generic oplossing kunnen die properties in de Content geplaatst worden. De Content zier er dan zo uit:

public class SwitchContent
{
  public SwitchContent(int id, string message)
  {
    ID = id;
    Message = message;
  }

  public int ID { get; private set; }

  public string Message { get; private set; }
}

De message wordt een stuk eenvoudiger:

public class GenericSwitchMessage : GenericMessage<SwitchContent>
{
  public GenericSwitchMessage(SwitchContent switchParameter)
        : base(switchParameter)
  {
  }

  public override string ToString()
  {
    return String.Format(
      "Switch message: sender{0}; target={1}", Sender, Target);
  }
}

Het te verzenden bericht wordt nu gecombineerd met de context:

Messenger.Default.Send<GenericSwitchMessage>
  (new GenericSwitchMessage(new SwitchContent (1, "Hallo")));

En het uitluisten ziet er ook wat rustiger uit:

public class LogProvider : ILogProvider
{
  public void Initialize()
  {
    // log all messages
    Messenger.Default.Register<GenericSwitchMessage>(this, true, m =>
    {
      // m.Content.ID
      // m.Content.Message
    });
  }
}

Conclusie:

De MVVMLight Messenger biedt een fraaie oplossing voor de totale ontkoppeling. Er zijn ook andere implementaties beschikbaar (iedere MVVM implementatie lijkt er wel één te bieden) dus het is eenvoudig om er aan te komen en om het eens uit te proberen.