software development network · getronics consulting doet mee aan de extreme mobility challenge!...

Nummer 104 februari 2010 SDN Magazine verschijnt elk kwartaal en is een uitgave van Software Development Network

www.sdn.nl

IN DIT NUMMER O.A.:

Regaining Control ofYour Applications <

nServiceBus: de servicebus voor puristen? <

DotNetNuke Community Update <

Modulaire applicaties in Silverlight <

SOFTWARE DEVELOPMENT NETWORK

MAGAZINE

104

GETRONICS CONSULTING DOET MEE AAN DE EXTREME MOBILITY CHALLENGE!

Wij zijn altijd op zoek naar nieuwe manieren om onze klanten beter te laten presteren. Het in de

praktijk aantonen van het nut van nieuwe technologieën werkt daarbij vaak het beste. Tijdens deze

challenge bewijzen we dat mobiel werken, zelfs onder extreme omstandigheden, altijd en overal

mogelijk is.

Ben jij benieuwd wat er allemaal mogelijk is en welke rol SharePoint hierbij speelt?

Kijk dan vanaf 1 maart op tweakers.net/itchallenge.

getronicsconsulting.com

GETRONICS CONSULTING DOETONSULLTING DOET MEE AAN DE EXTREME MOBILITY CHALREME MOBILITY LENGE!HAL

.elijk ismog

ewijze beenghallc

onenaktijk aantpr

Wij zijn altijd op z

eerkt mobiel we daen w

t nut van nieuwn van he

e manieoek naar nieuw

eme oxtrs onder efelzn,

erkt dogieën whnolece t

en bee klanten om onzer

altijdtandigheden,oms

.ett besdaarbij vaak he

en.ertesen prte laer tte

alerven o

ezTijdens de

t in de He

Kijk dan vanaf 1 m

d wBen jij benieuw

/t.nesereakt op twmaar

elijemaal mogt er allaw

.eenghallcit

ePol Share relkk is en w oint hierbij speelt?P

onicsconsultitreg com.ng

http://www.tweakers.net/itchallenge

magazine voor software development 3

ColofonUitgave:Software Development NetworkAchtiende jaargangNo. 104 • februari 2010

Bestuur van SDN:Remi Caron, voorzitterRob Suurland, penningmeesterJoop Pecht, secretaris

Redactie:Remi Caron ([email protected])

Aan dit magazinewerd meegewerkt door:Maurice de Beijer, Anko Duizer, PaulGielens, Christiaan Heidema, Marcel vanKalken, Stefan Kamphuis, Marcel Meijer,Mirjam van Olst, Joop Pecht, Sandrade Ridder, Maarten van Stam, Bob Swart,Marianne van Wanrooij en natuurlijk alleauteurs!

Listings:Zie de website www.sdn.nl voor eventuelesource files uit deze uitgave.

Vormgeving en opmaak:Reclamebureau Bij Dageraad, Winterswijkwww.bijdageraad.nl

©2010 Alle rechten voorbehouden. Niets uitdeze uitgave mag worden overgenomen opwelke wijze dan ook zonder voorafgaandeschriftelijke toestemming van SDN. Tenzijanders vermeld zijn artikelen op persoonlijketitel geschreven en verwoorden zij dus nietnoodzakelijkerwijs de mening van het be-stuur en/of de redactie. Alle in dit magazinegenoemde handelsmerken zijn het eigen-dom van hun respectievelijke eigenaren.

AdverteerdersGetronics 2Sybase iAnywhere 7Microsoft 11Bergler 19Avanade 28Sogeti 324DotNet 43VNU Media 44Barnsten/Embarcadero 47Oosterkamp training/consultancy 51Macaw 68

Adverteren?Informatie over adverteren en de adverten-tietarieven kunt u vinden op www.sdn.nlonder de rubriek Magazine.

voorwoordVan de hoofdredacteur,

Rob Willemsen is er per 1/1/2010 gestopt als hoofdredacteur. Langs deze weg wil ik hembedanken voor zijn jarenlange tomeloze inspanning om keer op keer een kwalitatiefhoogwaardig magazine te produceren. Wat geen eenvoudige klus is naast je werk, menigblad heeft een fulltime hoofdredacteur en die maken lange dagen om een blad teproduceren. Rob ontzettend bedankt voor je bijdrage de afgelopen jaren we zullen je missenals hoofdredacteur en gewaardeerd SDN medewerker.

Voor u ligt de eerste versie van het gewijzigde SDN magazine. We zijn bezig metveranderingen door te voeren in de inhoud van het blad. Het aantal pagina’s blijft gelijk maarwe stappen af van het louter publiceren van “lange” artikelen. Iedere track owner levert 1 a 2“lange”artikelen per editie, aangevuld met korte artikelen (krantenstijl). Hiermee kunnen we uvoorzien van meer in depth artikelen en actueel nieuws vanuit de tracks die u boeien.

Deze transitie is al merkbaar in dit magazine, maar het vinden van de “juiste” modus zal 1 a2 edities in beslag nemen. Nieuw is het digitale magazine waaraan koortsachtig wordt gewerktterwijl u dit gedrukte exemplaar leest. Een digitaal magazine is niet helemaal nieuw.We hebben zoals u wellicht weet met groot succes het digitale DIWUG/SDN SharePointmagazine gemaakt rondom het SharePoint event in januari. Information Worker track ownerMarianne van Wanrooij heeft daar ontzettend veel moeite in gestoken en vervolgenswereldwijd succes mee geoogst.

Het uitbrengen van een digitaal magazine is iets waar we al langer over gesproken hebbenbinnen de SDN. Maar in december vorig jaar hebben we de knoop doorgehakt en zullenwij in 2010 naast het gedrukte magazine u gaan verblijden met een digitaal magazine.Het streven is om tussen 2 hardcopy exemplaren met een digitale versie te komen. Hetgedrukte exemplaar blijft uiteraard ook gewoon te downloaden in PDF vorm.

Zoals u ziet is er veel beweging rondom het magazine of eigenlijk magazines. We zijn dan ookzeer benieuwd naar uw reactie op al deze wijzigingen. Commentaar, ideeën en positievegeluiden zijn van harte welkom en we nemen uw input mee om de magazines verder teverbeteren. [email protected] is het adres voor uw reacties en ik zie ze met belangstellingtegemoet.

De meeste van u kennen mij als de voorzitter van SDN en voor 2010 heb ik ook het hoofd-redacteurschap op mij genomen. Het vinden van een nieuwe hoofdredacteur is geeneenvoudige exercitie en om die dan ook direct op te zadelen met alle wijzigingen die we metde track owners hebben besloten hebben, leek het ons een onmogelijke taakstelling. Ik heber zin in en hoop u een plezier te kunnen doen met alles wat we dit jaar aan magazineszullen produceren. Voor de website en de onze events staan ook een groot aantalwijzigingen op stapel. Daarover bent u reeds deels geïnformeerd, maar er zal op dit vlak zekernog meer volgen.

Remi G.J Caron •

Inhoud03 VoorwoordRemi Caron

04 Inhoudsopgave

04 Agenda

05 Regaining Control of Your ApplicationsPeter Mollins

08 Excel Servicesin ad hoc beslissingsprocessen

Dennis Rosenbrand

12 Creating a More ManageableDevelopment Environment

Cary Jensen

16 Requirements & InterfacesVincent Verweij, Karen van GernerenWoroud Abdul Hussien

20 nServiceBus:de servicebus voor puristen?

Roy Cornelissen

29 Strings of TStringBuilder?Peter van der Sman

33 Avatar,reuse and model driven development

Sander Hoogendoorn

36 User Stories, een verhaal apartDennis Doomen

40 DotNetNukeCommunity Update

Stefan Kamphuis

45 Testen met Visual Studio 2010Ultimate Edition, een absolute prestatie!

Hassan Fadili & Ewald Hofman

49 Shifting TFields in DataSets Bound to DBGridsCary Jensen

54 De Kick Ass development reeks deel 2:Kennisgebieden voor developers

Maarten Metz & Freek Leemhuis

58 Modulaire applicaties in SilverlightTimmy Kokke

66 SharePoint out of the boxTaxonomie in SharePoint 2010

Willem Oosterhof

Mix 2010 USA, Las Vegas,

www.mix2010.com . . . . . . . .15-17 maart

SDN Event –

Architecture & User eXperience .16 maart

Microsoft DevDays 2010, Den Haag,

www.DevDays.nl . . . . . . . . . .30-31 maart

SDN Digital Magazine #1 . . . . . . . .2 april

SDN Event –

Launch Visual Studio 2010 . . . . . .20 april

SDN Magazine Nr. 105 . . . . . . . . .14 mei

SDN Event . . . . . . . . . . . . . . . . . .18 mei

Delphi Developer Days -

Marco Cantu & Cary Jensen

Londen, UK . . . . . . . . . . . . . . .26-27 mei

www.delphideveloperdays.com

Frankfurt, D . . . . . . . . . . . . .31 mei-1 juni

European Day of DotNetNuke, Parijs,

www.dayofdotnetnuke.eu . . . . . . .28 mei

TechEd USA, New Orleans . . . . .7-11 juni

SDN Digital Magazine #2 . . . . . . . .25 juni

SDN Magazine Nr. 106 . . . . .28 augustus

SDN: Software Development

Conference 2010 . . . . . . . .25-26 oktober

Genoemde data onder voorbehoud

Agenda 2010

CORESYSTEMS

Peter Mollins

A major cause of this situation is the sheer complexity of the applica-tions that you maintain. They have been modified over the course ofyears or even decades. They stretch across multiple languages andenvironments. The original developers have generally moved on toother roles and the documentation that the team depends on isseldom current. As a result, it can be difficult for developers to knowwhere changes must be made to their applications. As well, they maystruggle to ensure that their planned modifications do not destabilizethe application portfolio. This paper will summarize several options forovercoming the complexity of your applications and help you torededicate resources to new and innovative projects.

Confronting Complexity through InsightComplexity threatens to overwhelm analysts and developers, as theycannot fully understand their massive applications. An effectiveapproach is to document the systems. However, documentation israrely complete and is typically outdated by the time it is completed.There are automated documentation tools that are commerciallyavailable. The most comprehensive of these solutions provide solidtooling that addresses this complexity.

Detailed Technical VisualizationsDevelopers can understand their applications faster when they havecurrent, complete, and accurate documentation. They are even moreeffective when they can navigate through the documentation to focuson just elements that are important to the task at hand – and abstractthe complexity of the rest of the portfolio. This can mean visualizationsthat illustrate artifacts and their various interrelationships. For instance,how data flows through a system. Or, documentation may be usefulto view from multiple perspectives. This could be synchronized viewsof code, a tree view, diagrams, and other views that place thedocumentation into its proper context. It could also be to allow you tonavigate through documentation to locate which artifacts that mustbe changed for a given request.

Inventory Reports and QueryingAfter all, as these systems have been built and added toover many years, new elements are added and oftenuntracked. Analysis tools often will have the ability to listall elements in your portfolio. More sophisticated toolswill also point out orphaned elements that are referred tobut not included in the analysis. This helps to ensurecompleteness. Analysis tools will sometimes includequerying capabilities – including a library of queries andthe ability to construct your own queries. This helpseliminate complexity by allowing you to quickly locateartifacts that need to be changed. For instance, thiscould be by finding all references to a particular variable.

Impact AnalysisDevelopers must avoid unintended effects, as they canhave a severe impact on application up-time. Buttracing how a proposed change will affect the rest of theapplication portfolio is no simple task. Some analysistools provide the ability to trace impacts. Developersshould ensure that this capability permits backward andforward analysis as well as the ability to summarizeanalysis just to end-points to avoid unnecessaryinformation.


Regaining Controlof Your ApplicationsYour development team is under more pressure than ever. You have fewer resources availableto execute needed changes to your application portfolio. Yet, the requests from business usersare arriving at an accelerated rate. As a result, your development queue continues to grow.It is no longer a surprise that analysts estimate that 80% of IT budgets are dedicated to ‘lights-on’ activities and not on new development initiatives.

Fig. 1: Viewing applications from multiple perspectives providesmore complete understanding for development team members

A major challenge is simply to knowwhat’s in your portfolio

MAGAZINE6

CORESYSTEMS

Fig. 2: Libraries of queries should be available to uncover elementsof interest for development teams

Business DocumentationTechnical diagrams are useful for executing technical activities. Butwhen managers seek to understand how their operations are instan-tiated in an application, they must be able to view them from a higherlevel. Development teams should look for tools that can provide busi-ness filters on their applications. This could be from glossaries that linktechnical and business terms, or by uncovering and organizing busi-ness rules embedded in the applications, or by abstracting views onthe application via concepts like business process, geography, etc. –providing a business perspective on technical documentation.

Fig. 3: Visualize application code from the perspective of variousbusiness viewpoints, like business process, geography, or project

Application Portfolio ManagementA further way in which managers can overcome complexity is byfocusing development effort on activities that matter most to the busi-ness. This can be achieved by collecting technical and businessmetrics that identify where value, cost, and risk reside within thetargeted applications. Managers can then spot where inefficienciesand complexities exist, and they can prioritize development andmodernization tasks accordingly.

Confronting Complexity by Renovating ApplicationsA complementary approach is to attack the root of the problem. Thatis, by eliminating complex elements within application code. In thissection we’ll explore several options for doing so specifically by lookingat complexities in COBOL code. We chose COBOL because of itspervasiveness in large, mission-critical systems.

Fig. 4: Generate dashboards of business and technical metrics thathelp managers to monitor where complexities and opportunities forimprovement exist

Remove Dead and Obsolete CodeApplications are living entities that are constantly in-flux. As a result,there will often be large portions of the application portfolio that are nolonger necessary. This may be due to programming changes, forexample when a branch of code is supplanted by another that is bet-ter suited for the purpose. Or, it could be for business reasons, suchas when a line of business is eliminated then the code that supportedthat line is now obsolete. Maintaining this unnecessary code is was-teful.Some analysis tools can uncover code that is unreferenced byother parts of the portfolio. Because there are no logical paths to reachthe code, it can be safely excised from the application. Additionally,analysis tools may sometimes be used to assess the business logic ofan application. Through the business documentation described above,managers can quickly spot elements of the application portfolio thatare no longer relevant for the business and can be eliminated.

Consolidate Duplicate CodeA similar issue stems from multiple sets of code that perform the samefunction. This could be a simple process, like a day of the week check.Developers will often cut and paste these functions into their applica-tions to reuse the capability. Or, it could be a more sophisticatedprocess like employee vacation management.Many companies, especially those that have been through mergers,likely have a significant amount of duplicate functionality. This can beburdensome and complex as teams are forced to maintain multipleinstances of the same set of code.

Componentize Code for ReuseWithin your applications are business processes that have beenproven over time. This logic is often buried deep within existing codeand tightly interwoven with other artifacts. Your team would be moreefficient and flexible if it could decouple this logic from the monolithicapplication. Essentially this amounts to tracing the flow of a piece oflogic through a system and isolating that logic into a standalonecomponent. Development teams will often do so to increase reuseand to make core functions accessible to external applications in aservice-oriented fashion.

Many companies likely have a signifi-cant amount of duplicate functionality

www.AdvantageDatabase.comwww.Sybase.com/delphi

Easiest Migration of Desktop Databases(e.g. BDE/Paradox/DBF)to Client/Server or .NETTrue TDataSet Descendant for Delphi:

• Features native VCL components similar to TTable, TQuery…• No need for BDE / BDX

.NET developers benefit from serverside control:• Pessimistic Locking; Filters; Ranges (scopes)• Updating records directly on the server• etc.

Interested? Take us for a test drive…

Kontakt:Tel. +49(0)7032 [email protected]

ADVANTAGE DATABASE SERVER

CORESYSTEMS

Improve Alignment with StandardsOver time, the adherence of code to accepted internal and industrystandards tends to erode. This often occurs as pressures to respondto business demands mount. While violations of standards may helpa project to be executed faster, it can also lead to poor performingapplications. This can have a direct impact on the consumption ofhardware resources, and lead to more complex and less maintainablecode.

A simple example of a non-standard piece of COBOL code:

IF condition1

Statement1

ELSE IF condition2

Statement2

ELSE IF condition3

Statement3

END-IF

END-IF

END-IF.

This could be changed to the following simpler construct.

EVALUTE TRUE

WHEN condition1

Statement1

WHEN condition2

Statement2

WHEN condition3

Statement3

END-EVALUATE

ConclusionTo keep your applications maintainable, efficient, and adaptable youneed to confront their inherent complexity. Through insights into theapplication portfolio via automated and current documentation, visu-alizations, libraries of queries you can overcome this complexity andprovide the users that need information with the right level of insight.You should also use this insight to uncover inefficiencies, non-standard code, and opportunities for reuse that can lead to morenimble architectures that are simpler to adapt. •

Peter Mollins

Peter Mollins is director of productmarketing for the application port-folio management solution at MicroFocus. In that role he guides the po-sitioning of a range of technologiesthat generate business and techni-cal insight into existing applications.He has published numerous articlesin this space and spoken widely.

He has held increasingly strategic marketing roles with Netscape,iMediation, Togethersoft, and Relativity Technologies.He holds aMaster of International Management from Thunderbird andworked in Poland and France.

http://www.advantagedatabase.com

INFORMATIONWORKER Dennis Rosenbrand

Maar wat te doen als er een afwijking gevonden wordt die niet zomaarop basis van ervaringen van eerder genomen beslissingen genomenkan worden? Wat als er een afwijking gevonden wordt die verklaard engeanalyseerd moet worden op basis van gegevens die niet vast zijngelegd in de business intelligence omgeving, of helemaal niet zijngeregistreerd in een applicatie?Op dat soort momenten gaat Excel weer een belangrijke rol spelen inde informatievoorziening. Maar dat brengt ook een aantal risico’s metzich mee.

In dit artikel wordt een fictieve business case beschreven waarin eenuitzonderlijke beslissing genomen moet worden. Daarbij zal Excel alsbusiness intelligence tool ingezet moeten worden waarbij gegevenshandmatig worden ingevoerd. Normaliter zullen de meeste gegevensdie in dit beslissingproces nodig zijn onderdeel uitmaken van debusiness intelligence omgeving. In dit artikel wil ik echter laten zienhoe eenvoudig het is om informatie in SharePoint te delen zonderkennis te hebben van queries, databases, ETL procedures etc.Het enige dat nodig is is standaard Excel kennis.De nadruk van de procesbeschrijving wordt gelegd op het beschikbaarstellen van de informatie op basis waarvan de beslissing genomenmoet worden en de toegevoegde waarde van het toepassen van ExcelServices.

Business CaseBinnen een organisatie wordt er vanuit de sales organisatie vastgestelddat er een snel groeiende vraag is naar de dienstverlening rondomxRM. Aan het begin van 2010 is het economische klimaat nogonzeker en het is nog niet duidelijk welke kant het op gaat. Datbetekent dat er een terughoudende houding is ten aanzien van hetaannemen van vaste medewerkers. Men wil echter snel kunneninspelen op markttrends. Als de markt tekenen van structureel herstelvertoont, zullen snel nieuwe medewerkers moeten kunnen wordenaangetrokken. Periodiek wordt de marktsituatie beoordeeld en wordter een beslissing genomen op welke manier de potentiële projectenbezet gaan worden.

Het uitgangspunt van deze business case is dat deze beslissing maar1 keer genomen hoeft te worden. Hierdoor is het automatisch updatenvan informatie in Excel vanuit de bronbestanden niet belangrijk.Er wordt nadat de beslissing genomen is niets meer gedaan met dezeinformatie, dus het snel beschikbaar stellen van de informatie isbelangrijker dan het up to date houden.

Vastleggen van de business caseHet startpunt van het beslissingsproces is het vastleggen van debusiness case met daaraan gekoppeld de beslissingen die genomenmoeten worden. Uitgaande van de business case zijn onder andere devolgende (combinatie van) scenario’s mogelijk:• Extra personeel aannemen• Personeel inhuren• Project niet aannemen• Gewenste starten einddatums van projecten beinvloeden voor

betere spreiding van de inzet van resourcesOm tot een goede beslissing te komen zijn er twee dingen belangrijk:1. De juiste personen moeten betrokken zijn in het proces2. De juiste informatie moet aanwezig zijn.

Informatie behoefteDe verwachte omzet is één van de belangrijkste parameters voor hetberekenen van de toekomstige inzet. Deze gegevens zullen aangevuldmoeten worden met ervaringsgegevens die zijn verzameld in voor-gaande projecten en de huidige beschikbaarheid van medewerkersper rol.

Fig. 1: Basis informatie voor informatievoorziening

Projectgegevens:Uit bovenstaande lijst kun je de volgende gegevens halen:• Aantal fte per project per maand• Aantal fte per rol per maand• Onderverdeling aantal fte strategisch / niet strategisch per project

per maandMet behulp van bovenstaande kengetallen kan in overleg met depersoneelsafdeling besloten worden welke vacatures uitgezetmoeten worden en hoeveel fte ingehuurd moet worden. Het uit-gangspunt is hierbij dat strategische rollen in de projecten niet worden

Excel Servicesin ad hoc beslissingsprocessen

Een gestructureerde business intelligence omgeving is ingericht om de strategische en opera-tionele gang van zaken te monitoren. De business intelligence omgevingen zijn ingericht omafwijkingen te vinden. Hiervoor wordt deze omgeving opgebouwd uit drie lagen: een scorecard,dashboards en de rapportages. Het analysepad vanuit de scorecard door het dashboard naareen rapportage geeft inzicht over de reden waarom een kengetal afwijkt van de norm.Het gebruik van Excel in deze omgeving is alleen gewenst als Excel puur het venster is van dedata. Dit betekent dat Excel wel informatie toont maar dat er geen data is opgeslagen in Excel.

MAGAZINE8

INFORMATION

WORKER

ingehuurd, voor deze fte’s moeten zo snel mogelijk medewerkersworden aangenomen of omgeschoold.Personeelgegevens:• Beschikbare fte’s per rol per maand• Benodigde fte’s per rol per maand• Strategische waarde per fte per rol per maand• Status van lopende sollicitaties en verwachte startdata

Architectuur van de informatievoorzieningHet kenmerk van de aan te leveren informatie in dit beslissingprocesis dat het ad-hoc informatie betreft. Een deel van de benodigde infor-matie ligt vast in de gestructureerde business intelligence omgeving,zoals bijvoorbeeld het aantal medewerkers met een bepaalde functie.Een ander deel bestaat echter uit ad-hoc informatie die niet beschik-baar is via de structurele business intelligence omgeving. Aangeziendeze informatie alleen nodig is in dit proces, is het handmatig invoe-ren van de gegevens het meest efficient. Het risico van deze aanpakis dat er een Excel hel in het klein ontstaat. Iedereen heeft dan zijneigen bewerkte Excel sheet. Het is dan onmogelijk om te bepalenwelke versie de waarheid bevat. Door de Excel bestanden op te slaanin een document library in een SharePoint Decision Meeting Work-space worden de bestanden gedeeld. Dit levert het voordeel op dateen Excel bestand centraal wordt aangepast zodat de gerelateerdeExcel bestanden ook automatisch worden bijgewerkt.

Verzamelen van projectinformatieHet Excel sheet dat door de sales organisatie is aangeleverd heeft eenaantal extra berekeningen nodig. De verwachte doorlooptijd van deprojecten en de omzet vormen samen de basis voor het berekenenvan de gemiddelde inzet per dag per project. Daarna kan op basisvan de starten einddatum vastgesteld worden in welke maanden deinzet gerealiseerd moet worden.

Fig. 2: Toegevoegde gegevens aan projectlijst

Om vast te stellen welke verwachte rolverdeling er bestaat bij deprojecten wordt er door een projectmanager een Excel bestandopgeleverd met daarin de procentuele verdeling van de rollen over deprojecten.

Fig. 3: Procentuele verdeling rollen over projecten

Het projectbureau maakt in overleg met de projectmanager een derdeExcel sheet waarin de verwachte omzet, de procentuele verdeling ende verwachte inzet worden gecombineerd. Ook wordt in overleg nogvastgesteld welke rollen strategisch zijn. Op basis van dezeinformatie kan de directeur naar de hrm afdeling om daar verder teoverleggen.

Beschikbaar stellen van de projectinformatieHet probleem dat nu is ontstaan is dat er drie Excel sheets zijngemaakt, die aan elkaar gerelateerd zijn. In twee sheets zit informatiedie bij voorkeur eenvoudig geraadpleegd moet kunnen wordenzonder dat er twee bestanden geopend moeten worden. De mede-werkers die betrokken zijn geweest bij het opzetten van de Excelsheets weten precies waar welke informatie staat, de overigemedewerkers hebben dit inzicht niet.Op dit moment gaat Excel Services een toegevoegde waardeleveren. Excel Services maakt het mogelijk om een object in een Excelbestand te publiceren in SharePoint. Hierdoor kan er op een zeereenvoudige manier een dashboard gemaakt worden in SharePoint.Een voorbeeld hiervan is opgenomen in figuur 4.

Fig. 4: Dashboard projecten resourceplanning

Verzamelen van personeelsinformatieNu bekend is op welk moment welke resources nodig zijn kan de hrmafdeling aan de slag met het opleveren van de informatie. Ten eerstezal vastgesteld moeten worden hoeveel fte per rol beschikbaar is permaand. Deze informatie wordt handmatig in het Excel bestand in figuur5 gezet.

Fig. 5: Beschikbaar aantal FTE's per maand per rol

Per project per rol per strategische waarde per maand kan nu vast-gesteld worden of er een tekort bestaat aan resources in een bepaaldemaand. Tijdens de besprekingen in het proces is de eis gesteld datmedewerkers met een strategische rol in een project niet ingehuurdworden. Een overzicht van het tekort aan medewerkers per stratischeof niet strategische rol biedt het basisinzicht over de uit te zettenvacatures, danwel de in te huren medewerkers.

Beschikbaar stellen van de HRM informatieDe overzichten die door de HRM afdeling zijn gemaakt bieden eenbeter inzicht in de verwache tekorten. Deze zijn ook hier weer door demedewerkers die de Excel bestanden gemaakt hebben makkelijkterug te vinden maar niet door de overige projectleden. Daarom speeltook hier Excel Services weer een rol in het beschikbaar stellen van deinformatie. Ook voor de HRM informatie is een dashboard paginagemaakt met daarop de belangrijkste informatie.


Fig. 6: Dashboard HRM in te huren en aan te nemen FTE’s per rol

What If AnalyseDe informatiebehoefte die aan het begin van het proces vastgesteld isis nu opgeleverd. Dit betekent niet dat er eenvoudig door de directeureen beslissing genomen kan worden.Er zijn een aantal belangrijke parameters die bepalend zijn voor dekeuze die gemaakt moet worden:• De verwachte omzet per project.

Deze heeft een directe relatie met de verwachte inzet vanresources op het project

• De verwachte startdatum en einddatumDeze heeft een directe relatie met de inzet in de maanden vande resources en de doorlooptijd is bepalend voor het gemiddeldaantal FTE dat per dag ingezet moet worden

• De procentuele verdeling van de rollenDeze heeft een directe relatie met het aantal FTE per rol permaand. Daarnaast zijn bepaalde rollen per definitie strategisch.

Op de bovenstaande parameters heeft de organisatie in meer of min-dere mate invloed. Zo kan men bijvoorbeeld beslissen om een projectlater op te starten. Hierdoor zal de verwachte inzet van fte’s per maandverschuiven. Deze parameters kunnen aangepast worden in deverschillende Excel bestanden. De directeur zal echter zijn weg nietgoed weten te vinden in de verzameling van de Excel bestanden.Daarnaast is het aan te bevelen om een what if analyse los tekoppelen van de brondata die met zorg is verzameld door de ledenvan het projectteam. Ook is het gebruikersvriendelijk om de parame-ters aan te kunnen passen in dezelfde sheet waar de resultaten van dewhat if analyse worden getoond.

Fig. 7: Online What if analyse

In de what if analyse wordt er gebruik gemaakt van de rekenregels dieook worden toegepast in de andere Excel bestanden. De parametersdie niet veranderd kunnen worden zijn gebaseerd op de daadwerke-lijke getallen die op dat moment gelden in de bron Excel bestanden.Indien er in de bron dan nog iets wordt aangepast zal dit doorgevoerdworden naar de what if analyse.

Sinds Excel Services 2010 is het mogelijk om in een gepubliceerdExcel object data te veranderen of toe te voegen. Indien gewenstkunnen zelfs de formules aangepast worden.Voor wat betreft de what if analyse hoeft het document dus niet eerstgeopend te worden in een Excel sheet om vervolgens een parameterte wijzigen. In SharePoint kan een parameter aangepast worden enop basis van deze aanpassing worden de overige cellen berekend.

De beslissingOp basis van de what if analyse besluit de directeur uiteindelijk omHRM de opdracht te geven om een aantal sollicitaties met meer spoedaf te handelen. Daarnaast worden er ontwikkelaars ingehuurd die depiek in de vraag opvangen.

Achter de genomen beslissing zit een visie. Deze visie zal gedeeltelijkzacht zijn en dus niet meetbaar maar een deel zal ook meetbaar zijn.Voor de tijd na de genomen beslissing is het van belang dat degevolgen van de genomen beslissing gemonitord worden.In deze business case betekent dit dat op korte termijn de xRMgerelateerde omzet zal stijgen, maar dat de daaraan gerelateerdekosten ook stijgen aangezien de inhuurkosten toenemen. Op middel-lange termijn zal een groei in het personeelsbestand verwacht mogenworden waardoor de xRM omzet na de piek op een stabiel, maarhoger niveau terecht komt en de daaraan gerelateerde kosten zullendalen aangezien de inhuurkosten zullen dalen.•

Dennis Rosenbrand

Dennis Rosenbrand werkt sinds1999 als business intelligence con-sultant. De afgelopen 5 jaar heeftDennis zich gespecialiseerd in demogelijkheden die het Microsoftplatform biedt voor business intelli-gence en besturingsvraagstukken.

Binnen Macaw werkt Dennis als principal consultant. In dezefunctie coacht hij zowel klanten als consultants tijdens businessintelligence projecten.

MAGAZINE10

INFORMATION

WORKER

http://www.devdays.nl

GENERAL Cary Jensen

restored, will perform very nicely, those incremental images you’vebeen making along the way each contain some of the “gunk” that hasbeen eating away at your performance. Restore from one of those andyou’re starting with a non-optimal setup (and you will still need a dayor so to get things really back to where you need them).

A Possible SolutionOver the past year I have been playing with an idea that is not so ori-ginal. Most of us use products like VMWare Workstation or Virtual PCto create virtual installations of guest operating systems. Most often weuse these guest OSes to install beta software, so that it can run in aclean environment, without having to worry about it doing somethingugly to our primary OS (host operating system). Once testing is done,we simply delete the guest operating system and go about our way.

Well, sometime last year I bought a copy of Windows XP Pro, andinstalled it as a guest OS under VMWare. I then installed Delphi 2007,as well the various support tools that I use. I used this guest tocompare how Delphi (and then other tools) worked under XP versusVista (which I was using as my host OS).

This was all very educational, until at one point something weirdhappened to my Delphi 2007 installation under my host (personally,I blame the Internet Explorer 8 installation, but I’ll leave that specula-tion for another article). At the time I was on the road, working for 10days at a client’s site. And, I didn’t have my RAD Studio 2007 instal-lation disks with me. Fortunately, I was able to load the guest OS, andcontinue developing without missing a beat. I simply retrieved a cleancopy of the source code from the version control system, and offI went.

A colleague of mine and I talked about what had happened at length,and came to the same conclusion. Maybe I should isolate my devel-opment environment from the host operating system as a matter ofpractice. Furthermore, maybe I should isolate each of my differentdevelopment environments from each other. Maybe, I thought, thiswould decrease (I wanted to say eliminate, but that would be blatanthubris) the “gunk,” and reduce the opportunity for incremental decayof performance.

Creating a More ManageableDevelopment EnvironmentI recently bought a new laptop, something that I do every year or so. And the recent release ofWindows 7 gave me a good excuse to do so. But this new purchase also gave me anotheropportunity to do something that I’ve been thinking about for a while, the opportunity to set upmy machine in a fashion that will improve my ability to maintain my development environment.Here’s the problem. Over time, in some cases in as little as three or four months, my computerperforms noticeably slower than when it was first configured. Eventually it gets so bad that I needto reinstall my operating system and all of my software and tools. For me, this can take days.

Part of my problem is that I need quite a few different versions of anumber of different programs. For example, I currently support anumber of applications written in Delphi 7, Delphi 2007 (both Win32and Delphi for .NET), Delphi 2009 and Delphi 2010, Visual Studio 2008(including Delphi Prism). (I am also asked to teach classes in other ver-sions of Delphi, such as Delphi 2006, or even Delphi 5.) In addition,I use a variety of database servers, including Advantage DatabaseServer and SQL Server, and these must be installed as well. And thenthere are the various tool sets, set as third-party component sets forthe various applications I support, source code control, utilities, andthe list goes on and on.

Actually, it’s much worse than it sounds. Let’s take Delphi 2007, forinstance. Once you install Delphi 2007 and it’s help files, and registerit as a legitimate copy, you must also download and install the variouspatches. I think that the total time, from start to finish, to get Delphi2007 installed is something on the order of 5 hours.

And don’t get me started on Visual Studio 2008. In addition to thecore development environment, there were several service packs, aswell as updates such as Silverlight 3, and so forth. These needed tobe downloaded and installed. VS 2008 must have taken a total of 8hours. Believe me, I’ve gotten pretty good at configuring my system,but this is a waste of time. Why can’t I just install it all once and bedone with it.

I’ve tried to solve this problem in the past. One of my approaches wasto carefully install everything I needed, and then make a good, cleanimage using something like Acronis True Image or Norton Ghost. Andwhile this works, somewhat, it isn’t perfect. After restoring from animage, there is still a lot to do to get a system back into shape.

The fact is, that “clean” image you create early on isn’t perfect. Itdoesn’t have all the nifty tools you’ve picked up in the interveningmonths since you created the image. Nor does it have the latest third-party components that you have added to some of your more recentdevelopment projects.

Incremental images are not the answer, either. Once you start usingyour system, things get progressively worse, performance-wise. As aresult, while that pristine, original image that you created, once

MAGAZINE12

GENERAL

The Virtual Road is Paved With Good IntentionsHere is what I did. I bought a fast computer with loads of memory.This machine runs an Intel Core 2 Quad Q9000 CPU running at 2 GHz.(Importantly, this chip supports hardware virtualization.) The machinealso has 8 GB of DDR 3 RAM. Plenty of memory, plenty of cores,I was good to go. From here, I installed onto my host operatingsystem, which was Windows 7 64-bit Home Premium, just that stuffthat an ordinary computer user needs, and nothing else. I’m talkingabout basic stuff, like a word processor, an email client, antivirus,backup/restore software, a Twitter client, iTunes, and most importantly,virtualization software, which in this case, was VMWare Workstation7.0. Once all of this was installed, and any available updates applied,I made a nice clean image of this base.

Next, I went to work on the guest operating systems. And I was verysystematic about this. First, I created a guest OS with the absolutebasics: Windows 7 64-bit Ultimate and antivirus. After installing all up-dates, I made a full cloned of this guest OS. Onto the clone I installedmy very basic stuff that I need in all of my development environments,including version control software, various utilities (like SysInternalsSuite), as well as Advantage Database Server and SQL Server (hey, I’ma database guy. No matter what I’m doing, I’m going to need a data-base). Let’s refer to this virtual machine as “Database Base.”

Now I’m ready for the big time. I cloned Database Base, and installedonto this clone a copy of Delphi 2010. I created a second clone ofDatabase Base and installed Visual Studio 2008 (that took an entireday). In all, I’ve got about seven of these development environmentsso far. I also have a nice, 500 GB, portable, external eSATA drive (thislaptop supports eSATA, which is about three times faster than USB2.0). I backed up the image of my host OS, as well as all of the nicenew guest OSes, to this drive. Despite the limitations, which I’ll sharewith you in a moment, this is a pretty nice setup. First of all, since Idon’t actually develop in the host, and have only limited softwareinstalled on it, I gain two benefits. First, the host is small, and really, ifI had to install it from scratch, it would take hours, not days. And, sinceI have a nice, clean image of the host, I can actually restore it in amatter of minutes, if necessary. The second benefit is that there is littlegoing on in the host. Sure, I end up installing necessary evils such asGoto Meeting, Adobe Air, and other stuff like that, but it’s limited, sinceI am not developing in the host. And, so far (it’s been a couple ofmonths now), the host is showing little signs of slowing down.

And it’s working out fairly well with the virtual machines, so far.Performance is nice I’m allocating 3 GB of RAM to each virtualmachine, and this give them some room to stretch, while permittingme to run two of them simultaneously without choking the host OS(though, frankly, things do get slow when the host has only 2 GBs toplay on, so I try not to run two guests at a time). And here’s the greatthing. Since I’ve got the individual VMs backed up on the eSATA drive,I can restore them as well. In fact, if my idea works as planned, I shouldbe able to migrate these VMs to my next machine, meaning that I maynot have to install RAD Studio 2007 ever again. (I wish it were true, butI know in my heart that it is a lie. I know I’ll have to install RAD Studio2007 again, but just not as many times as I would had I not taken thisparticular route.)

There are two additional, and compelling, advantages that I now have.First, if something awful happens to one of my development environ-ments, I’ve got a quick solution. For example, if, when testing a newroutine that removes an old key from the Windows registry I acciden-tally delete every ProgID, no worries. I simply copy the backed upguest VM file from my eSATA drive (which, of course, I have backedup to another storage drive as well), and I’m cooking with gas (thismeans that I’m back to work quickly).

The second advantage is this. When I get to the point of shipping aproduct (or hit a major milestone, or whatever), I can make a backupof the VM that I used, and I’ll have that exact environment forever. If Iever need to return to the precise installation of service packs,updates, component sets, and the like, that was used to create thatspecial build, I’ve got it, right there, in that virtual machine that I’vesaved (and backed up, of course).

But It’s Not PerfectI wish I could say that I’m completely satisfied with this solution, but Icannot. There are problems, and some of them are not trivial. Theyare not horrific, either. In other words, while there are benefits to thisapproach, I’ve realized some serious limitations, even though I’m onlya few months into this experiment. The first issue is, honestly, a prettyminor one: It takes a little bit longer to get up and running, as far asdevelopment goes. In short, I have to wait for two OSes to load (thehost and a guest) before I can get to work. Fortunately, these OSes,being Windows 7, do load quickly, so its only a minor inconvenience.

The second issue is more complicated. I run square into a major issueinvolving software updates. You know, those annoying message youget from our fine friends at Microsoft that inform you that updates arebeing installed (actually, I don’t get those, because I refuse to letMicrosoft decide when to install updates. I get to choose when.) Well,each of the individual VMs have this problem, which means that rightnow I don’t install one update, I install eight (host plus seven guests).And, Java and Adobe, and every other bloke on the block who wantsto make sure that their bugs don’t destroy my system(s), want toinstall updates as well. You get the picture, and it isn’t pretty.

Ok, if you only work in one development environment, say VisualStudio, this will not be an issue. Most of us, though, must support avariety of environments. So if you take the road I did, creating aseparate guest OS for each, you're going to have to face this issue(which may be to ignore updates altogether, with the exception ofmajor service packs). There is another, related issue. What if I find agreat new tool (for example, the best merge tool that you’ve ever seen,one that flawlessly and perfectly merges two different versions of thesame source file). Or, what if I realize, after creating all of my swell VMs,that I failed to install one of my more useful utilities. Well, at present,I have to install these things separately in each VM. A time consumingtask if taken all at once, or an annoyance if done piecemeal each timeI discover the missing utility in a particular VM.

I was hoping that a feature of VMWare Workstation, called linkedclones, was the answer (it’s not). A linked clone is where you create aclone that is based on an existing VM. When I first started looking intolinked clones, I thought my problems were solved. But after readingmore closely, the VMWare Workstation help makes it clear that alinked clone is associated with a particular snapshot of an existing VM,and that subsequent changes to the cloned VM do not appear in theclone. I was really hoping that I could create a linked clone to a baseVM, like Database Base, and then perform maintenance only toDatabase Base. For example, if a Windows update is released, I washoping I could update only Database Base, and all the linked clonescreated from it would automatically have the updates. That’s not howit works. Even with linked clones, the individual clones need Windowsupdates (Oh, the humanity!).While there is a slight performance decrement when using linkedclones (not really an issue; we're not trying to run games on thesesystems), there is a benefit. Specifically, the individual linked clones,while requiring that you keep around a copy of the original VM thatyou cloned, take up much less disk space than full clones.For example, one full clone I have takes up 19 GB, while a compara-ble linked clone consumes 6.5 GB of disk space. This makes thelinked clone much more convenient to backup and restore.


DELPHI TIP:SOAP Client IP?Als we in Delphi for Win32 een SOAP Web Service maken, danis het soms nuttig om te kunnen zien wat het IP-adres is van declient die de web service aanspreekt. Dat kan door gebruik temaken van de GetSOAPWebModule functie, via welke we bijhet Request kunnen komen waar dan RemoteAddr het IP-adresvan de client bevat. In Delphi code kan dat als volgt:

implementation

uses

WebBrokerSOAP;

function GetClientIP: String;

begin

Result := GetSOAPWebModule.Request.RemoteAddr

end;

GENERAL

Cary Jensen

Cary Jensen is President of JensenData Systems, Inc., a training andconsulting company that won the2002 and 2003 Delphi InformantReaders Choice Awards for BestTraining. He is an award-winningauthor of 20 books, including

Advantage Database Server: A Developers Guide (2007, Sybase),Building Kylix Applications (2001, Osborne/McGraw-Hill), JBuilderEssentials (1998, Osborne/ McGraw-Hill), and Delphi in Depth(1996, Osborne/McGraw-Hill).For information about onsite training or consulting services, youcan contact Cary at [email protected] or visithis web site at www.JensenDataSystems.com.

MAGAZINE14

What’s The Solution?As I said, this approach has some serious benefits, but it doesn’t solveall of the problems, either. Is there a perfect solution? I don't know.Some developers I've talked to have used a system like this, andreport that they are very pleased. In those cases, however, they hadonly one guest OS to maintain. And, either they only needed onedevelopment tool, or they installed all of their development environ-ments on the single guest OS. While that might work, these guestOSes tend to get very large, and increase the likelihood that one tool(Visual Studio, for example) may introduce issues with another (sayEclipse). Other developers I know accept the predictable cycle of re-installation of the OS and all tools. Of these, one or the more compel-ling approaches involved not only installing all tools and developmentenvironments, but also installing all installation CDs and DVDs to adirectory or partition on the system. In addition, each time they installa service pack, they first download it to a folder along side theinstallation disk images. So long as you a good image of your baseoperating system, a backup of your installation images, and keep ahandy record of your serial numbers, registration keys, and the like,re-installation goes much faster. It still takes time (days?), but it takesmuch less time than when using disks.So, although my current setup is ok, I'm still looking for somethingbetter. I’d like to hear what you think, and what you’ve done to addressthese issues. If you've got a solution, email me at [email protected], using the subject line "Development Environment."It might make for a nice follow-up article some time. •

IS HET NIEUWE LINKEN!TAGGENDoor Tom Rovers en Laurens Frijters van Sparked.

Mobile tagging wint de laatste maanden in Nederland aan interesse. Demoderne barcode komt steeds vaker voor en maakt het mobiele internettoegankelijk voor grote groepen mobiele gebruikers. Het ontbreken van eenstandaard reader technologie vertraagd de adoptie, maar een ding wordtduidelijk; het mobiele internet wordt in rap tempo volwassen.

Eind vorig jaar gaf RTL nieuws aandacht aan mobile tagging in het nieuws-item; “Taggen, het nieuwe linken” http://www.youtube.com/ watch?v=pzfaM2mRiEA. Deze nieuws aandacht is interessant maar ook opmerkelijk,temeer omdat de technologie van de QR code (quick reference) inmiddels almeer dan 15 jaar oud.

Waar komt deze interesse ineens vandaan?De oorzaak hiervan ligt volgens ons in twee zaken; Allereerst is de adoptie vanmobiele internet de laatste 2 jaar verdubbeld en wordt er steeds meermobiel gebrowsed. De telefoon wordt meer en meer een volwassen kanaalvoor communicatie met doelgroepen. Zo blijkt driekwart van de mensen huntelefoon mee naar de slaapkamer te nemen. Het mobiel is daarmeepersoonlijk en bovendien relevanter geworden. De tweede reden is dat deQR code het mobiel internet toegankelijk maakt voor grote groepengebruikers.Wie gaat er immers browsen en zoeken naar de juiste url via zijnmobiele telefoon? Mobile tagging biedt gebruikers direct en makkelijktoegang to de juiste mobiele webpagina.Sparked voert momenteel projecten uit voor organisaties in de media, cultuur,retail, openbaar vervoer en evenementen sector. Hierbij integreert Sparkedhet tagging platform van Microsoft met haar eigen mobiele platform.Organisatie kunnen zo tagging snel en effectief mobiel in zetten voorverbetering van hun bedrijfsvoering. De doelstellingen van deze organisatieslopen vaak uiteen, echter de rode draad is gelijk; doelgroepen effectiefbereiken en verbinden tegen een juiste prijs/kwaliteit verhouding. Meer enmeer ontstaat de vraag om naast informatie ook transactieafhandeling, zoalsbijvoorbeeld navigatie en betalingen, te ondersteunen. Hiermee lijkt hetmobile internet in een rap tempo de zelfde ontwikkeling door te maken alshet huidige web.

ToekomstvisieHet mobile internet groeit hard en heeft de potentie om groter te worden danhet huidige web. Met de nieuwe generatie aan mobieltjes en ontwikkelingenals augmented reality en beeldherkenning is tagging volgens ons eeninteressante tussenstap naar visuele search en matching. Via ons bloghouden we je graag op de hoogte. Meer weten over mobile tagging of heb jezlef een leuk scenario? Bezoek ons blog en lees de faq-lijst opblog.sparked.nl of neem contact op met Sparked op 020-4420620.

Met de aanduiding R2 op de bestaande naam “SQL Server 2008” lijkt het alsofhet hier een minor upgrade betreft. Het tegendeel is echter waar, grote onderde-len zijn aan de huidige versie toegevoegd en verschillende onderdelen zijn sterkverbeterd. Hetzelfde hebben we gezien bij de nieuwe versies van Windows

Server die middels hetzelfde mechanisme zijn vernieuwd en het R2 label kregen.De thema’s waar het deze keer om draait zijn: “Betrouwbaar en SchaalbaarPlatform”, “Efficientie voor IT en Ontwikkelaar” en “Managed Self-Service BI”.Met de R2 release van SQL Server 2008 moet het mogelijk zijn om de systemenop te schalen naar de grootste beschikbare x64- en Itanium hardware (tot 256logische processoren). Ook de virtuele wereld is niet vergeten met de onder-steuning voor virtualisatie met Hyper-V met Live Migration in Windows Server2008 R2.SQL Server 2008 R2 gaat de strijd aan te gaan met de grootsten en is met dezeversie schaalbaarheid een groot goed geworden. Er wordt getracht om de data opeen veilige en betrouwbare manier te distribueren onder de gebruikers gebruikmakend van zogenaamde Line Of Business (LOB) toepassingen. Ten behoeve vande IT en ontwikkelafdeling biedt SQL Server 2008 R2 nieuwe gereedschappenvoor het onderhoud en beheer van grote multi-database omgevingen waarbijtevens wordt gelet op een gestroomlijnde ontwikkeling en uitrol van datagedreven toepassingen. De BI zelfbediening wordt in deze versie aangeboden inde vorm van SQL Server PowerPivot voor Excel waarbij het mogelijk moetworden om BI toepassingen te ontwikkelen met weinig of geen hulp van uw ITafdeling. IT behoudt uiteraard de mogelijkheid om de toepassingen te monitorenmaar de gebruiker is in staat om zelfstandig zijn toepassing te beheren en teonderhouden.

Visual Studio 2010Visual Studio 2010 is al een geruime tijd in Beta 2.Vele ontwikkelaars over de wereld hebben dezeversie gedownload en hun commentaren gegeven.De originele launch van Visual Studio 2010 zou zijnop 22 maart 2010 en is verschoven naar 12 april2010. Dit betekent dat de Release Candidate ooklater zal komen, de verwachting is nu medio februari.

Officiële datumSQL Server 2008 R2


Op 19 januari 2010 is door Microsoft bekend gemaakt dat SQL Server 2008 R2 vanaf mei dit jaar op de planken zalverschijnen. Bijna is het zover, maar u moet nog een paar maanden wachten. Bij deze release verbindt Microsoft zich inverdere mate aan Business Intelligence (BI) en zogenaamde mission criticle workloads.

Cloud NewsSQL Azure en Windows Azure zijn nu ook geland in Europe. Voor beide kun je naast deAmerikaanse locaties uit de CTP ook kiezen een locatie North Europe en Azie. Let op jeCTP account voor zowel Windows Azure en SQL Azure, deze zullen afgesloten worden.Vanaf februari is het Microsoft Cloud platform officieel en gaat gebruik in rekeninggebracht worden. Als je een MSDN account hebt, dan kun je je PDC account migreren entegen een gereduceerde prijs gebruik blijven maken van Windows Azure en SQL Azure.

Daarnaast heeft de Service bekend onder de naam ".NET Services" een naamsverande-ring ondergaan en heet nu AppFabric. Windows Server AppFabric en Windows Azure Plat-form AppFabric moet het bouwen en beheren van Cloud applicaties eenvoudiger maken.Windows Azure platform AppFabric gaat ontwikkelaar helpen om lokale applicaties te

verbinden met applicaties in de Cloud.Dit kunnen applicaties zijn die draaienop Windows Azure, Windows Server enop andere platforms zoals Java, Ruby,PHP etc. De Service Bus biedt mogelijk-heden om te verbinden over netwerk enorganisatie grenzen. Windows Azureplatform AppFabric is nog in CTP.Een andere nieuwe Cloud service isCodename Dallas. De marktplaats voorhet aanbieden en delen van Cloud ser-vices. Met deze service is het mogelijkvoor ontwikkelaars en information wor-kers om te zoeken in beschikbare data,plaatjes and web services.

ARCHITECTURE Vincent Verweij, Karen van Gerneren Woroud Abdul Hussien

Wat is een interface?Er bestaan vele vormen en definities van interfaces. Een veelomvat-tende definitie is de volgende:

Bij deze definitie kan onder systeem ook een mens worden verstaan.Zo is een beeldscherm een voorbeeld van een interface tussen eencomputer en een gebruiker; het beeldscherm zet de digitale informa-tie van de computer om in een voor de gebruiker begrijpbaretekstuele of grafische vorm.

Een interface kan echter ook een intermediair zijn tussen tweeinformatiesystemen. In dit artikel wordt uitgegaan van deze variant.In de context van dit artikel wordt daarom de volgende definitiegehanteerd:

Het systeem dat de dienst beschikbaar stelt wordt ook wel ‘provider’genoemd, het systeem dat van de dienst gebruikt maakt wordt‘consumer’ genoemd.

Onderstaand wordt een voorbeeld van een dergelijke interfacegegeven. Ter illustratie maken we gebruik van de online sportwinkel“Websports”: op de website van deze webwinkel (de consumer)kunnen klanten zelf hun klantgegevens registreren. Om dezegegevens te registreren in het klantregistratiesysteem van de BackOffice (de provider) wordt gebruik gemaakt van de klant interface en

Requirements & Interfaces

de service ‘Registreren klant’ (zie figuur 1).

Fig. 1: klant Interface

Vaak worden de begrippen interface en service door elkaar gebruikt.Bovenstaande definitie geeft het verschil aan tussen deze begrippen:een service is een dienst van een provider die functionaliteit biedt welkedoor een interface beschikbaar wordt gesteld aan andere systemen

Een interface kan dus nooit los worden gezien van een service en eenservice niet van een interface. Zonder service biedt een interfaceimmers geen waarde voor een consumerend systeem en vice versa.

Waarom worden interfaces gebruikt?Er zijn verschillende redenen waarom interfaces door organisatiesworden gebruikt. Een aantal belangrijke redenen zijn:• Kostenverlaging• Minder kans op fouten• Snel in kunnen spelen op veranderingen

Voorbeeld kostenverlaging en minder kans op fouten:Door het gebruik van interfaces wordt de gegevensverwerking verdergeautomatiseerd en zijn hierdoor minder medewerkers benodigd.

Het eerder genoemde voorbeeld van online sportswinkel “Websports”laat zien dat het registreren van klantgegevens met behulp van eeninterface door de klant zelf uitgevoerd kan worden. Doordat de onlinesportwinkel gebruik maakt van een interface worden de gegevens diede klant invoert realtime opgeslagen in het klantregistratiesysteem.

Interfaces vormen een belangrijk onderdeel in elk systeemontwikkelingtraject en worden met desteeds verdergaande integratie van systemen, alleen maar belangrijker. Daarnaast leidt deimplementatie van interfaces vaak tot problemen en worden ze daarom als een risicobeschouwd. Waarom worden interfaces gebruikt als het zo vaak tot problemen leidt? En totwelke problemen kan dit leiden? Hoe kunnen de uitdagingen van de implementatie vaninterfaces, vooral op het gebied van requirements, goed worden gemanaged en door wie?Dit artikel biedt een antwoord op deze vragen door de meest voorkomende problemen metinterfaces te benoemen, hun oorzaken en gevolgen in kaart te brengen en handvatten aan tereiken waarmee een succesvolle implementatie wel mogelijk is. Om tot een antwoord te komenmoeten we een helder beeld zien te krijgen van het begrip interface.

Een intermediair maakt het voor tweesystemen mogelijk met elkaar tecommmuniceren

Interface; een mechanisme dat alsintermediair tussen twee systemenacteert en zodoende het ene systeemtoegang biedt tot één of meerderefunctionaliteiten en diensten (services)van het andere systeem’

MAGAZINE16

ARCHITECTURE

Hierdoor is voor deze activiteiten geen medewerker meer benodigdin de Back Office. De vermindering van het aantal handmatige actiesleidt tot een reductie van het aantal fouten en daarmee op zijn beurtweer tot een snellere en goedkopere verwerking.

Voorbeeld snel in kunnen spelen op veranderingen:Het ontsluiten van functionaliteit middels interfaces leidt tot hergebruiken hiermee kostenreductie. De betreffende functionaliteit hoefttenslotte niet elke keer opnieuw te worden ontwikkeld. Bovendien stelthet hergebruik organisaties in staat nieuwe systemen sneller teimplementeren en hierdoor sneller in te spelen op veranderingen in demarkt.

Een voorbeeld hiervan is iDEAL. iDEAL is een betaalmethode,ontwikkeld door een aantal banken, om de betaling van onlineproducten en –diensten gemakkelijk, betrouwbaar en veilig te maken.Klanten worden hierbij tijdens de betaling direct doorverwezen naarhet internetbankierprogramma van hun eigen bank. Door hunsystemen aan te sluiten op de interface van iDEAL kunnen webwinkelshun klanten snel en makkelijk voorzien van een online betaalmethodezonder zelf een dergelijk product te hoeven ontwikkelen.

Figuur 2 illustreert het gebruik van iDEAL. Via iDEAL kunnen klantenhun bestelling direct afrekenen. Als een klant een bestelling heeftgeplaatst (1) en hiervoor heeft betaald (2), krijgt de webwinkel hiervandirect bericht via email (3). De webwinkel kan dan direct overgaan tothet uitleveren van de artikelen (4).

Fig 2: voorbeeld gebruik van iDEAL interface

Deze voorbeelden tonen aan dat interfaces een belangrijke rolhebben in de systeemontwikkeling. Toch leidt de implementatie vaninterfaces zoals eerder aangegeven vaak tot problemen. Wat gaat erdan mis en hoe komt dit?

Veel voorkomende problemen, oorzaken en gevolgenVeel voorkomende problemen met interfaces zijn:• Onbekende of verborgen Requirements: een voorbeeld hiervan

is de eigenlijke aanroep van een interface in een stap van eenUse Case terwijl deze interface niet expliciet is benoemd. Eenander voorbeeld is de output van de interface in de vorm vanverschillende error meldingen waarop het systeem verschillendmoet reageren. Bij de uitwerking hiervan kunnen nieuwe(onverwachte) requirements in beeld komen.

• Onduidelijke werking van de interface: als bijvoorbeeld de inputen de output van de interface niet bekend zijn dan kunnen erproblemen ontstaan bij het aanroepen van de interface en bij hetcorrect verwerken van het resultaat van de interface.

• De werking van de interface is niet volgens specificatie: eenonjuiste specificatie van de interface zal bijna altijd leiden tot eenonjuiste implementatie. Veelal worden deze problemen

veroorzaakt doordat niet alle interfaces zijn geïdentificeerd ofdoor incorrecte, onvolledige of zelfs ontbrekende documentatie.

Dit kan tot vervelende gevolgen leiden zoals:• Onvoorziene vergroting van de scope: wanneer tijdens de

realisatie blijkt dat er additionele interfaces benodigd zijn kande scope van het project onvoorzien groter worden. De scopevergroting kan bijvoorbeeld worden veroorzaakt doordat nieuweservices moeten worden gebouwd om te communiceren met degevonden interface.

• Rework van reeds gebouwde functionaliteit: wanneer tijdens detestfase blijkt dat de interface niet werkt zoals verwacht, zal ditdeel opnieuw gebouwd moeten worden.

• Vertraging tijdens de ontwikkelfase: ontwikkelaars moetenwachten tot de requirements van de interface helder zijn of gaanzelf uitzoeken hoe de interface zou moeten werken.

Al deze gevolgen kunnen van grote invloed zijn op de planning en hetbudget van het project.

De oplossingOnderstaand hebben we een verzameling van best practices neerge-zet om de bovengenoemde oorzaken eerder te tackelen waardooreen groot deel van deze problemen voorkomen kunnen worden.

Onderkennen van interfaces als requirementsOndanks het feit dat tegenwoordig veel systemen gebruik maken vaninterfaces onderkennen veel ontwikkelmethodieken, zoals RUP,interfaces niet expliciet als requirements. Zo biedt RUP geen bestpractices en templates & guidelines voor het beschrijven vaninterfaces. Door de services die een interface biedt te onderkennenals een requirementstype zullen de hieronder beschreven activiteitenook voor interfaces een onderdeel van het gebruikelijke requirementsmanagement proces worden.

Expertise binnen het projectHet is dus belangrijk dat de juiste expertise aanwezig is binnen hetproject, in dit geval op het gebied van requirements management.Een voorbeeld hiervan is de rol System Analyst binnen de RUPsysteemontwikkelmethode. Deze persoon is verantwoordelijk voor hetidentificeren van alle requirements voor het te realiseren systeem.Wanneer interfaces ook als type requirement zouden worden erkend,dan zou het identificeren van de interfaces ook onder de verantwoor-delijkheid van deze persoon vallen.

Afbakenen scopeNet als voor de andere requirementstypen, is het van belang in eenvroeg stadium inzicht te krijgen in de interfaces van het systeem. Ditkunnen zowel interfaces zijn waarvan het systeem gebruik zal makenals interfaces die het systeem aan zal bieden. Door de interfaces ex-pliciet te benoemen en te controleren in hoeverre er specificaties zijnen wat de kwaliteit hiervan is, kunnen eventuele verrassingen later inhet traject worden voorkomen.

Beschrijven interface requirementsDe exacte werking van de service achter de interface is voor de con-sumer altijd een blackbox. Voor de consumer is het niet noodzakelijkprecies te weten hoe de service zijn werk doet. Wel is het belangrijkom te weten wat exact de services zijn die een interface biedt, hoedeze services aan kunnen worden geroepen en wat de input en out-put is. Een goede beschrijving van deze informatie is essentieel enwordt vastgelegd in een Service Definition document. Daarnaast is hetvan belang vast te leggen hoe het consumerende systeem de gege-vens moet aanleveren aan de service en hoe het systeem de ontvan-gen gegevens dient te interpreteren en te gebruiken. Deze gegevensworden vastgelegd in een Service Mapping document.


Traceability van en naar interfacesNu de interfaces als requirements type zijn geïdentificeerd kunnen zeworden opgenomen in het traceability overzicht. Het tracen van inter-faces is aan te raden omdat hiermee zowel de herkomst als hetgebruik van de interface in andere requirements, zoals Use Cases,wordt vastgelegd.

Hiermee blijft het uiteindelijke doel van het gebruik van de interfaceduidelijk en kan de impact van eventuele wijzigingen in de interfacesnel op waarde worden geschat.

Een ander voordeel van de trace relatie tussen interfaces en UseCases is dat de relatie inzicht biedt in de complexiteit van een UseCase. Het onderkennen van interfaces is dus niet alleen waardevolvoor het afbakenen van de scope maar ook om een beeld te krijgenvan de omvang van het systeem.

Fig. 3: het tracen van interfaces

Requirements FrameworkRequirements specialisten van Capgemini hebben een frameworkopgezet voor Requirements management, IRMA (Integrated Require-ments Management Approach). Dit framework ondersteunt debovenstaande best practices met een complete set templates &guidelines voor alle requirements deliverables waaronder ook templa-tes & guidelines voor het beschrijven van de interface requirements.

Door gebruik te maken van deze best practices, templates & guide-lines is het mogelijk om de risico’s met betrekking tot het gebruik vaninterfaces aanzienlijk te verminderen.

ConclusieWanneer we bovenstaande lezen, zien we dat het vooral belangrijk isom interfaces te onderkennen als een apart type requirement. Hetonderkennen van interfaces als type requirement heeft als resultaatdat interfaces al in een vroeg stadium in kaart worden gebracht, datze worden opgenomen in de scope van het project en dat er afspra-ken dienen te worden gemaakt over de specificatie van de interfaces.Daarnaast worden interfaces opgenomen in het traceability overzichtwat bijdraagt aan een verbeterd inzicht in de complexiteit en deomvang het te realiseren systeem.

Het lijkt voor de hand liggend, toch worden interfaces vaak vergetenen zijn daarmee het ondergeschoven kindje van een project. Hettoepassen van een requirements framework binnen de gekozenontwikkelmethode geeft een goede basis om een project tot eensucces te maken. Wanneer deze ontwikkelmethode interfaces niet

onderkent als requirements, is het belangrijk het framework uit tebreiden zodat het ook interfaces ondersteund.. Zo’n uitbreiding isonmisbaar voor projecten waarbij gebruik gemaakt wordt vaninterfaces. Een succesvol project begint met goede en volledigerequirements.Bron: Interface quote •

Vincent Verweij

Vincent Verweij is een ervaren sys-tem analist bij Capgemini. Hij is alssystem analist werkzaam geweestbinnen enkele grote maatwerk im-plementaties en is werkzaam binnenhet Capital Markets en Risk domein.Vincent is bereikbaar via [email protected]

Karen van Gerner

Karen van Gerner is werkzaam bijCapgemini als RUP System Analist.Zij werkt hierbij voornamelijk in pro-jecten voor nieuwbouw applicaties.Op incidentele basis geeft mevrouwzij trainingen voor CapgeminiAcademy aan medewerkers die snelaan de slag willen als requirementsspecifier.

Woroud Abdul Hussien

Woroud Abdul Hussien is werkzaambij Capgemini als RequirementsSpecifier. Woroud heeft de afgelo-pen jaar verschillende rollen vervultbij het ontwikkelen van een hypo-thekensysteem op analyse endesign vlak om Requirements teverzamelen en vast te leggen.

MAGAZINE18

ARCHITECTURE

http://www.berglerco.nl

.NET Roy Cornelissen

Het begrip SOA is veelomvattend en te groot om in dit artikel tebehandelen. Ik ga in dit artikel uit van de interpretatie van SOA die isgehanteerd bij het maken van nServiceBus. Aan het eind van ditartikel vind je een link naar de architectuurprincipes van nServiceBusen de interpretatie van SOA dat Udi Dahan hierbij voor ogen heeft.

Fig. 1: De Service Bus speelt een centrale rol in een SOA

De Service BusWat is eigenlijk een service bus? Waar men het in ieder geval overeens is, is dat de Service Bus ervoor zorgt dat alle services in eenarchitectuur met elkaar kunnen communiceren op een eenduidige engestructureerde manier. In Figuur 1 zien we een traditionele weergavevan de Service Bus in een voorbeeldarchitectuurplaatje: een centraleeenheid waaraan alle services zijn verbonden en waarmee zecommuniceren. De architectuur in Figuur 1 is die van een fictieveverzekeraar. De invulling van het begrip blijkt in de praktijk voor veleinterpretaties vatbaar, uiteenlopend van een compleet product totslechts een concept.

Een Service Bus als product, vaak “ESB” of “Enterprise Service Bus”genoemd, heeft het imago van een magische doos, die door dureconsultants moet worden geïnstalleerd en geconfigureerd. Zo’n ESB

vervult vaak ook een rol als process engine, waarbij processturing(workflow, BPM) en routering allemaal door het product wordeningevuld. Het gevaar ligt op de loer om bij een ESB als eerste tedenken aan een dergelijk product.

In mijn ervaring en optiek is dit niet wat een Service Bus zou moetenzijn. Met name als er ook aan processturing en routering wordtgedaan, dan komt er ineens wel heel veel business logica en kennisin die bus te liggen. Services zijn dan ook ineens erg afhankelijk vande bus om dingen gedaan te krijgen. Liever spreken we in dezegevallen van een Broker in plaats van een Bus. Zo’n Broker kan eenvolstrekt valide pattern zijn in bepaalde architecturen, maar niet persé in een SOA. Aan de andere kant van het spectrum wordt deService Bus slechts als concept gehanteerd. Dat klinkt ongrijpbaarmaar dergelijke uitwerkingen zijn vaak vrij pragmatisch: servicescommuniceren onderling via peer-to-peer verbindingen (bijvoorbeeldWCF), waarbij de Service Bus diensten als locatietransparantie (het“Locator” pattern) en een gedeeld en gemeenschappelijk schema(“Canonical Schema”) invult. Een Service Bus als concept betekentdan dat er enkele bouwblokken en principes worden gehanteerd endat daaromheen de SOA applicatie wordt gebouwd. Deze interpreta-tie van de Service Bus is er een die ikzelf al meerdere malen hebtoegepast in SOA implementaties en die mijns inziens prima werktdoordat de bus geen doel op zich is en je je kunt focussen op het rea-liseren van de services en de processen die de services aansturen.

nServiceBus zit ook in die laatste categorie: de Service Bus is vooraleen concept en biedt een paar diensten en vooral principes die hetmogelijk maken om een SOA op te bouwen uit zelfstandig opererendeservices. Ironisch genoeg is nServiceBus wel een “product” dat jemoet downloaden en het biedt ook de nodige infrastructurele zakenvoor de onderlinge communicatie van de services.

In een Service Oriented Architecture (SOA) speelt de Service Bus een belangrijke rol. Voor deinvulling van die Service Bus zijn uiteenlopende oplossingsrichtingen mogelijk. In dit artikel gaik in op de oplossing die nServiceBus biedt. nServiceBus is een open source initiatief van deIsraelische architect Udi Dahan, die aan de slag is gegaan met zijn ideaalbeeld voor eenSOA in een .NET wereld. Inmiddels hebben anderen zich bij hem aangesloten om het productverder uit te bouwen. nServiceBus is gratis en kan worden gedownload vanafhttp://www.nServiceBus.com.

nServiceBus:de servicebus voor puristen?

Een Service Bus als product, vaak“ESB” of “Enterprise Service Bus”genoemd, heeft het imago van eenmagische doos

MAGAZINE20

.NET

Communicatie tussen servicesIn een SOA hebben we te maken met verschillende communicatie-patronen waarin services met elkaar communiceren. Grofweg zijn dater drie.• Request/Response: een client (eindgebruikersapplicatie of

service) geeft een opdracht aan een service, of vraagt omgegevens en de service geeft daarop antwoord. Een pureRequest/Response implementatie werkt vaak op eenRPC-achtige (Remote Procedure Call) manier: je roeptfunctionaliteit aan op een service en je wacht op het antwoordof totdat de operatie klaar is. nServiceBus geeft hier een eigendraai aan, zoals we zullen zien.

• Fire/Forget: een client stuurt gericht een bericht naar eenbepaalde service, maar is niet geïnteresseerd in het antwoorddaarop. Bijvoorbeeld: in een geautomatiseerd offerteproceswordt een offerte naar een printstraat gestuurd.

• Publish/Subscribe: ook hier verstuurt (publiceert) een serviceeen bericht terwijl het niet geïnteresseerd is in een antwoord.Het verschil met Fire/Forget is dat het hier gaat om een berichtdat op een centrale plek wordt gepubliceerd en door meerderesubscribers kan worden afgenomen. Het is dus niet gericht aanéén specifieke ontvanger. Het dient om een gebeurtenis(business events) kenbaar te maken aan iedereen die daarin isgeïnteresseerd.

Bij Fire/Forget en Publish/Subscribe praten we over éénrichtings-verkeer ofwel zogenaamde One Way Messaging. Bij Request/Response komt er ook een antwoord terug. In een gemiddeldeSOA-implementatie zijn over het algemeen alledrie de genoemdecommunicatiepatronen wel vertegenwoordigd. Bij one way messagingkunnen we te maken hebben met twee verschillende scenario’s,namelijk dat een verzender en ontvanger allebei online zijn en er eendirecte verbinding is, of dat de ontvanger op het moment van verstu-ren niet online is. In het laaste geval vindt de verwerking dus later(asynchroon) plaats. Om deze situatie te kunnen opvangen hebbenwe op de service bus een dienst nodig: Store & Forward. De gedachteachter Store & Forward is dat het bericht wordt afgeleverd op eenbetrouwbare plek (store) en dat het daadwerkelijk afleveren van hetbericht (forward) los daarvan plaatsvindt. Dit geeft een ontkoppelingvan de verzender en ontvanger. Dit concept kennen we ook wel alseen Queue.nServiceBus is geheel gebaseerd op het principe van One WayMessaging, waarbij Store & Forward een belangrijke rol speelt.nServiceBus is hier behoorlijk puristisch in. Udi Dahan heeft ditgedaan om verschillende redenen:

• Beschikbaarheid: als de ontvanger van het bericht langzaam is,of gecrasht is, dan heeft dat geen effect op de snelheid enstabiliteit van de verzender. In de praktijk: een website kan’s nachts nog wel gegevens ontvangen en publiceren naar deback-end services, terwijl die misschien in onderhoud zijn ofdruk met batchverwerkingen. De applicatie als geheel is nog welbeschikbaar terwijl enkele onderdelen dat niet hoeven te zijn.

• Performance: de gedachte hierbij is dat het afleveren van eenbericht in een queue zeer snel gebeurt omdat het een goedkopeactie is. Zodra het bericht gedropt is in de queue, heeft deverzender alle resources weer beschikbaar voor verdereverwerking en hoeft het niet te wachten tot het berichtdaadwerkelijk de ontvanger heeft bereikt.

• Betrouwbaarheid: het schrijven naar en lezen uit een queue kunje transactioneel maken. Dit heeft een belangrijk effect: als detransactie voor het verwerken van een bericht niet lukt en wordtteruggedraaid, dan kun je ook het bericht weer terug in dequeue plaatsen om het later nog eens te proberen.

Met andere woorden: er gaan geen gegevens verloren doordat eenservice de fout in gaat. In een “traditionele” web service implementa-

tie zal je er zelf voor moeten zorgen dat een mislukte aanroep opnieuwwordt geprobeerd, of dat er in de logging voldoende informatiebeschikbaar is om het proces weer op gang te helpen zonder dat erdata verloren gaat.

Dat met nServiceBus alleen One Way Messaging mogelijk is, betekentwel dat je met een bepaalde mindset je implementatie moet vormge-ven. De services moet je dan beschouwen als zelfstandig draaiendeprocesjes waar volledig asynchroon berichten uitgaan en binnen-komen. Een bedrijfsproces voltrekt zich dan door een opeenvolgingvan berichten en de verwerking daarvan door de diverse services.Hoe dit vorm krijgt met nServiceBus zal ik in de volgende paragrafenlaten zien.

One Way Messaging met nServiceBusIn nServiceBus is het communicatiemechanisme geïmplementeerdmet het concept van een message queue. Ik noem het bewust eenconcept, want het daadwerkelijke transportmechanisme is zelf tekiezen. Standaard is dit Microsoft Message Queueing (MSMQ), maarer is bijvoorbeeld ook een implementatie op basis van een WCFnetTcpBinding beschikbaar. In feite is deze queue de Service Bus inhet land van nServiceBus: een plek waar de berichten worden opge-slagen om verder te worden opgepakt. Met nServiceBus gebruik jedoorgaans meerdere queues waarnaar messages worden gepubli-ceerd en waarop je je kunt abonneren. Een nServiceBus implementa-tie is dus meestal een stelsel van queues. De service definieert zelfmet welke queues hij interacteert. Naast de queues voor berichtuit-wisseling hebben we nog een aantal infrastructurele queues, zoals deerror queue, waar berichten naartoe worden verplaatst die – na eenaantal keren opnieuw proberen – niet kunnen worden verwerkt. EennServiceBus-oplossing gebruikt voornamelijk Publish/Subscribe. Maarook Fire/Forget en Request/Reply zijn mogelijk, zij het met eennServiceBus smaakje. Ik zal nog laten zien hoe dat werkt. De belang-rijkste gedachte achter nServiceBus is dat RPC-achtige communica-tie teveel blokkerende service-calls oplevert en de performance enstabiliteit negatief beïnvloedt. Om deze reden is gekozen voor eennon-blocking, one way communicatie via een queue.

Een subscriber meldt zich bij een publisher om aan te geven dat hetgeïnteresseerd is in een bepaald bericht. Zodra de publisher eenbericht publiceert, raadpleegt de nServiceBus infrastructuur deabonnementen en wordt het bericht bij alle subscribers afgeleverd.Lukt dit niet, dan kan het bericht worden vastgehouden in een“outgoing” queue, vanwaaruit nServiceBus zal blijven proberen om hetbericht af te leveren. Hoe vaak dat opnieuw wordt geprobeerd kun jeconfigureren. Ondertussen gaat de publisher door met de verwerking.Subscribers kunnen zich at runtime aan- en afmelden. Abonnemen-ten voor publish/subscribe kunnen binnen nServiceBus op verschil-lende manieren worden bijgehouden: in memory, via een durableMSMQ queue of in een database. De storage zelf wordt geabstra-heerd door het framework. De durable queue is de standaardkeuzevoor opslag als je zelf niets anders kiest. Door de nadruk opPublish/Subscribe en asynchrone verwerking gaat een nServiceBusoplossing al snel richting een bijzondere vorm van SOA: een EventDriven Architecture (EDA).

nServiceBus gebruikenOm nServiceBus te kunnen gebruiken zullen we een aantal dingenmoeten regelen:

Ontkoppeling van Verzender enOntvanger, concept heet ookwel Queue


MAGAZINE22

.NET

• Definieer berichten• Onderken en implementeer de publishers: welke service

produceert welke berichten?• Onderken en implementeer de subscribers: welke services nemen

ook berichten af en welke berichten zijn dat?Het is gangbaar dat een service zowel berichten consumeert alsproduceert. Laten we deze stappen nader bekijken door verder detechniek in te duiken.. Om de voorbeelden te kunnen gebruiken moetje nServiceBus downloaden vanaf de website. Je krijgt dan desources, scripts om de sources te compileren, documentatie en voor-beelden. Met een batch file richt je je machine in zodat deze geschiktis om nServiceBus te gebruiken. Dit bestaat uit het aanmaken vanenkele message queues en het configureren van de Distributed Trans-action Coordinator (DTC). Vervolgens is er een batch file waarmee jede sources van nServiceBus kunt compileren. Dit levert een keurigefolder op met alle binaries die je nodig hebt. De DTC wordt o.a.gebruikt bij operaties op de subscription store als je daarvoor eendatabase gebruikt. Om berichten te definiëren moet je een referentiezetten naar NServiceBus.dll en voor het implementeren van eenpublisher of een subscriber moet je daarnaast nog een referentiezetten naar NServiceBus.Core.dll en NServiceBus.Host.exe. Dezelaatste is een executable, waarin de generic host is geïmplementeerden waarin wat hosting logica is opgenomen die je kunt gebruiken. Ikkom hier later op terug.

Berichten definiërenBerichten definiëren we in een aparte class library, waarnaar we laterin de publisher / subscriber implementatie laten verwijzen. Het defi-niëren van de berichten in nServiceBus kun je op twee manieren doen.

1: Maak een class en markeer deze met de IMessage interface, zoalsin Listing 1.

[Serializable]

public class AanvraagOfferteIngediend: IMessage

{

public Guid EventId { get; set; }

public DateTime Tijdstip { get; set; }

public string Achternaam { get; set; }

public string ProductVorm { get; set; }

}

Listing 1: Definitie van een bericht als class

Het bericht in het voorbeeld is simpel, maar je kunt er ook complexerestructuren mee maken.De class is gemarkeerd met het Serializable attribuut. Dit is nodig zodatnServiceBus de berichten kan serialiseren en in de queue kan plaat-sen. Hiervoor wordt niet de DataContractSerializer van WCF gebruikt,maar een custom XML Serializer die kan omgaan met classes, inter-faces en dictionaries. Ik heb echter gemerkt dat classes die zijngedecoreerd met DataContract en DataMember attributen ook netjesworden geserialiseerd. Een werkwijze die ik vaak hanteer is datmessages worden gemodelleerd in XSD en dat daarvan C# classesworden gegenereerd. Over services heen deel je dan alleen de XSD’sbij wijze van Canonical Schema. Deze werkwijze kan ook bij nServi-ceBus worden toegepast, als je er maar voor zorgt dat de IMessageinterface op die classes wordt gezet. Eenmaal geserialiseerd is hetbericht uitwisselbaar tussen services. Bijna conform een van de

basisprincipes van SOA: “services delen contract en schema, maargeen types”, met als aanmerking dat er wel een interface uit denServiceBus DLL’s wordt gedeeld (IMessage).

IMessage is slechts een marker interface. Je hoeft er geen methodsof properties voor te implementeren, maar het dient voor nServiceBusom generiek met messages om te kunnen gaan. De reden waarom hetgeen base class is, heeft te maken met de tweede manier waarop wemessages kunnen definiëren, namelijk:

2: Definieer een interface en leid deze af van IMessage, zie Listing 2.

public interface IAanvraagOfferteIngediend: IMessage

{

Guid EventId { get; set; }

DateTime Tijdstip { get; set; }

string Achternaam { get; set; }

string ProductVorm { get; set; }

}

Listing 2: Definitie van een bericht als interface

Met deze interface hebben we ook een bericht gedefinieerd. De redenom te kiezen voor een interface heeft te maken met de extra moge-lijkheden die je hiermee krijgt. Door interfaces te gebruiken krijg je eensoort “multiple inheritance” cadeau, wat handig kan zijn bij versioningvan berichten, of het samenstellen van nieuwe berichten uit meerderebestaande berichtdefinities.

Als je gebruik maakt van interfaces als berichtdefinities, dan kun jevoor het genereren van de berichtinstanties gebruik maken een IoCcontainer (IoC = Inversion Of Control). Net zoals je kunt kiezen voor hettransportmechanisme voor berichten is nServiceBus is zo opgebouwddat de IoC container naar keuze kan worden verwisseld. Standaardwordt Unity gebruikt, maar evengoed kun je er bijvoorbeeld Autofac ofStructuremap onder schuiven. Wat een IoC container is, valt buitenhet bereik van dit artikel.

De Publisher implementerenNu we een bericht hebben gedefinieerd, willen we deze kunnenpubliceren. Hiervoor gaan we een publisher maken.Om een publisher te maken moeten we een zogenaamd Messa-geEndpoint implementeren. We moeten nServiceBus dan wel vertel-len dat het gaat om een publisher. Dit doen we door eenEndpointConfig class te implementeren. Zie Listing 3 voor een simpelvoorbeeld.

class EndpointConfig : IConfigureThisEndpoint,

AsA_Publisher,

ISpecify.ToUseXmlSerialization,

ISpecify.ToRun<VerkoopEndpoint>

{

}

Listing 3: Configuratie van een endpoint

Let eens op de syntax waarmee dit gebeurt. De naamgeving van deinterfaces die we op deze class zetten is zodanig gemaakt dat dit eruitziet als natuurlijke taal. Achtereenvolgens lezen we: “I configure thisendpoint as a publisher, I specifiy to use XML serialization and I

De belangrijkste gedachte achternServiceBus is dat RPC-achtigecommunicatie de performance enstabiliteit negatief beïnvloedt

Basisprincipes van SOA: “servicesdelen contract en schema,maar geen types”


.NET

specify to run VerkoopEndpoint”. Ofwel: dit endpoint is een publisherdie XML serialization gebruikt voor de berichten en het endpoint is declass VerkoopEndpoint.

nServiceBus heeft hieraan genoeg om te weten welk endpoint moetworden geïnstantieerd en aangeroepen. De configuratie in het voor-beeld is zo’n beetje het minimale dat je moet configureren. Hier heb jeechter nog veel meer geavanceerde opties. Dit gaat voorbij aan descope van dit artikel.

De VerkoopEndpoint class is te zien in Listing 4.

public class VerkoopEndpoint : IWantToRunAtStartup

{

public IBus Bus { get; set; }

public void Run()

{

Console.WriteLine("VerkoopEndpoint started.");

Console.WriteLine("Press 'Enter' to publish a mes-

sage.To exit, Ctrl + C");

bool useInterface = true;

while (Console.ReadLine() != null)

{

var eventMessage = useInterface ?

Bus.CreateInstance<IAanvraagOfferteIngediend>() :

(IAanvraagOfferteIngediend) new AanvraagOfferteIn-

gediend();

eventMessage.EventId = Guid.NewGuid();

eventMessage.Tijdstip = DateTime.Now;

eventMessage.Achternaam = "de Vries";

eventMessage.ProductVorm = "ZorgverzekeringPlus";

Bus.Publish(eventMessage);

Console.WriteLine("Published event with Id {0}.",

eventMessage.EventId);

useInterface = !useInterface;

}

}

public void Stop()

{

}

}

Listing 4: Implementatie van een MessageEndpoint

De class VerkoopEndpoint implementeert IWantToRunAtStartup. Voordeze interface moet je twee methods implementeren: Run en Stop.Deze methods worden aangeroepen door nServiceBus op hetmoment dat de service in de lucht komt en weer wordt gestopt.Doorgaans zal je hier alleen wat initialisatie en opruimwerk in doen,zoals het subscriben en unsubscriben van message handlers. In hetvoorbeeld heb ik alle logica van de service in de Run method gestopt.

In de voorbeeldcode zijn de twee manieren om met messages om tegaan ook gedemonstreerd: afwisselend wordt een zelf geïnstantieerdbericht verstuurd (AanvraagOfferteIngediend) of een bericht gegene-reerd door nServiceBus (Bus.CreateInstance<T>()). Deze laatstemaakt gebruik van de IoC container van jouw keuze.

Het publiceren van het bericht is zo simpel als het aanroepen vanBus.Publish(). De VerkoopEndpoint class heeft een public property

van het type IBus. In OnStart wordt deze gebruikt, maar hij wordt ner-gens geïnitialiseerd. Dat ziet eruit als magie, maar dat valt mee.Dit doet namelijk het nServiceBus framework voor je via DependencyInjection.

Het implementeren van een SubscriberNu we een publisher hebben gemaakt, kunnen we een service gaanbouwen die het bericht OfferteAanvraagIngediend wil afnemen. Hiermoeten we hetzelfde paradigma volgen. Eerst maken we een End-pointConfig, zie Listing 5.

class EndpointConfig : IConfigureThisEndpoint,

AsA_Server,

ISpecify.ToUseXmlSerialization

{

}

Listing 5: Subscriber endpoint configuratie

Dit endpoint wordt als een server geconfigureerd. Er is nog een derdeoptie en dat is AsA_Client. Het verschil in configuratie zit hem in demanier waarop de queue wordt geconfigureerd: een server en eenpublisher krijgen een transactional queue en gebruiken impersonation,een client niet. Daarnaast zien we in dit voorbeeld dat we niet per seeen MessageEndpoint hoeven op te geven. Dit endpoint zal automa-tisch alle gevonden message handlers subscriben. Je kunt dit ookhandmatig doen. In de lijst van interfaces op de EndpointConfig geefje dan op: IDontWant.ToSubscribeAutomatically, om aan te geven datje dit zelf wilt regelen. Met Bus.Subscribe() en Bus.Unsubscribe() meldje een subscriber aan en af. In Listing 6 laat ik zien hoe je een Messa-geHandler implementeert. Een MessageHandler is een class die wordtaangeroepen zodra NserviceBus een bericht oppikt waarop deze han-dler is geabboneerd. De OfferteMessageHandler implementeert deIHandleMessages<T> interface, waarbij het typeargument aangeeftwelk bericht deze handler afhandelt. De handler moet een Handle()method implementeren. Hier zou je het bericht kunnen opvangen,misschien wat vertalingen kunnen doen en vervolgens de interneservice logica aanroepen. In het voorbeeld tonen we in de Traceinformatie enkele velden uit het bericht. Hiermee hebben we eensimpele subscriber geïmplementeerd.

public class OfferteMessageHandler :

IHandleMessages<AanvraagOfferteIngediend>

{

public void Handle(AanvraagOfferteIngediend message)

{

Trace.WriteLine(string.Format("Subscriber 1 received

AanvraagOfferteIngediend message with Id {0}.",

message.EventId));

Trace.WriteLine(string.Format("Message time: {0}.",

message.Tijdstip));

Trace.WriteLine(string.Format("Client name: {0}.", mes-

sage.Achternaam));

}

}

Listing 6: Implementatie van een message handler

In de message handler van Listing 6 wordt als af te handelen bericht-type een specifieke class opgegeven. Als je echter werkt op basis vaninterfaces voor messages, dan kun je meer generieke message han-dlers maken. Je kunt ook meerdere handlers in een service hebben enje kunt nServiceBus vertellen in welke volgorde deze handlers moetenworden aangeroepen. In Listing 7 is te zien hoe je dat doet.

MAGAZINE24

.NET

public class EndpointConfig : IConfigureThisEndpoint,

ISpecify.MessageHandlerOrde-

ring

{

public void SpecifyOrder(Order order)

{

order.Specify(First<H1>.Then<H2>().AndThen<H3>().AndThen<H4

>()); // etc.

}

}

Listing 7: Message handler volgorde opgeven

De voorbeelden in de Listings bestaat nu uit niet meer dan enkelelosse classes die wat interfaces implementeren. Om dit allemaal metelkaar te laten werken hebben we een host nodig. Hiervoor zijnverschillende opties: zelf een host schrijven, hosten in IIS/WAS of dehosting logica van nServiceBus zelf. De nServiceBus host heet deGeneric Host.

De Generic HostDe Generic Host is een executable die deel uitmaakt van de nServi-ceBus binaries: NServiceBus.Host.exe. Zoals de naam al aangeeft, isdit een generiek hostproces dat publisher- of subscriberlogica kanhosten. Alle infrastructuur voor het subscriben op queues, communi-ceren van berichten, etc. wordt door deze host afgehandeld.Je kunthem als losse executable starten, maar hij kan ook als WindowsService worden geregistreerd op het systeem. Business services dieop deze manier zijn geïmplementeerd kunnen dan via de Service Con-trol Manager van Windows worden gestart, gestopt en gemonitord.Het draaien van onze publisher of subscriber in de generic host doenwe door NServiceBus.Host.exe bij de library van de service tedeployen en vervolgens via configuratie aan de host te laten wetenwat hij moet doen. De Host is zelf zo slim om op zoek te gaan naarlibraries met implementaties van interfaces zoals IConfigureThisEnd-point, IHandleMessages, enzovoort. Voor een publisher zou een con-fig file eruit kunnen zien zoals in Listing 8.

<configuration>

<configSections>

<section name="MsmqTransportConfig"

type="NServiceBus.Config.MsmqTransportConfig, NService-

Bus.Core" />

<section name="UnicastBusConfig" type="NServiceBus.Con-

fig.UnicastBusConfig, NServiceBus.Core" />

</configSections>

<MsmqTransportConfig

InputQueue="messagebus"

ErrorQueue="error"

NumberOfWorkerThreads="1"

MaxRetries="5"

/>

<UnicastBusConfig

DistributorControlAddress=""

DistributorDataAddress=""

ForwardReceivedMessagesTo="">

<MessageEndpointMappings>



</MessageEndpointMappings>

</UnicastBusConfig>

</configuration>

Listing 8: Configuratie van een publisher

We zien een config file waarin is aangegeven dat we gebruik makenvan MSMQ als transportprotocol. Berichten die deze publisher gene-reert worden op een queue genaamd “messagebus” gepubliceerd.We zien ook dat er in nServiceBus een stukje fouttolerantie is inge-bouwd. Mocht er iets misgaan bij het afleveren van een bericht, danzal dit tot 5 keer opnieuw worden geprobeerd. Lukt het dan nog niet,dan wordt het bericht op de “error” queue gepubliceerd. Gegevensgaan daardoor nooit verloren. Verder kun je nog invloed uitoefenen ophet aantal worker threads dat de generic host gebruikt. Voor subscri-bers zou je kunnen denken aan meerdere threads voor de verwerkingervan. De configuratie van de subscriber is in Listing 9 te zien.

<configuration>

<configSections>

<section name="MsmqTransportConfig"

type="NServiceBus.Config.MsmqTransportConfig, NService-

Bus.Core" />

<section name="UnicastBusConfig" type="NServiceBus.Con-

fig.UnicastBusConfig, NServiceBus.Core" />

</configSections>

<MsmqTransportConfig

InputQueue="worker"

ErrorQueue="error"

NumberOfWorkerThreads="1"

MaxRetries="5"

/>

<UnicastBusConfig>

<MessageEndpointMappings>

<add Messages="Messages" Endpoint="messagebus" />

</MessageEndpointMappings>

</UnicastBusConfig>

</configuration>

Listing 9: Configuratie van een subscriber

Hier zie je dat er twee queues zijn geconfigureerd. De “worker” queueis de queue waar deze subscriber eventueel zelf berichten op zou kun-nen publiceren. In de sectie UnicastBusConfig is gedefinieerd dat erberichten binnenkomen op de “messagebus” queue. Daarbij gevenwe aan dat de berichten die daarop binnenkomen zich bevinden in deMessages DLL. Deze informatie is voldoende voor de generic host omzijn werk te kunnen doen. Nu kun je ervoor kiezen om zelf alle beno-digde queues aan te maken. Dat is misschien ook verstandig in eenproductieomgeving omdat je dan maximale controle hebt over de se-curity en wat er precies wordt aangemaakt. Maar zelfs dat kan de ge-neric host voor je uit handen nemen bij het opstarten. Op deze manierben je bij het ontwikkelen en testen van nieuwe services heel snelup-and-running.

Een stapje verderWe hebben nu een simpele publisher en subscriber geïmplementeerden gehost in de generic host. De berichtuitwisseling tussen deze tweeis ook erg basaal. Bedrijfsprocessen zijn complexer dan dat. In dezeparagraaf laat ik een aantal zaken de revue passeren die je metnServiceBus kunt doen om wat complexere scenario’s te realiseren.

SecurityEen publisher kan zelf bepalen welke subscribers zich wel of nietmogen abonneren op berichten. Hiervoor moet je de interfaceIAuthorizeSubscriptions implementeren. In Listing 10 zie je hier eenvoorbeeld van.


.NET

public class SubscriptionAuthorizer : IAuthorizeSubscripti-

ons

{

public bool AuthorizeSubscribe(string messageType,

string clientEndpoint,

string clientWindowsIden-

tity,

IDictionary<string, string>

headers)

{

// raadpleeg een autorisatie store

return true; // true = toegestaan, false = niet toege-

staan

}

public bool AuthorizeUnsubscribe(string messageType,

string clientEndpoint,

string clientWindowsIden-

tity,

IDictionary<string,

string> headers)

{

// raadpleeg een autorisatie store

return true; // true = toegestaan, false = niet toege-

staan

}

}

Listing 10: Autoriseren van een subscriber door een publisher

Er is geen manier om vanuit code controles te doen of de publishervan een bericht wel authentiek is. Dit zal je moeten inregelen metstrikte security op de message queues. Wel zijn er onderdelen in denServiceBus infrastructuur die automatisch een hash van een berichtkunnen valideren om message tampering te voorkomen.

Request/ReplyWe hebben het nu wel telkens over publish/subscribe, maar er zullensituaties zijn dat we ook een antwoord willen op een bericht. In datgeval spreken we niet echt van een event, maar van een Request. Hetantwoord daarop is een Reply. Een request is niet iets dat je publi-ceert, maar verstuurt naar een specifieke ontvanger. Dat onderscheidis ook aangebracht in de nServiceBus implementatie. Een requestmessage verstuur je met de volgende code:

Bus.Send(requestMessage);

Het bericht wordt dan verstuurd naar het endpoint (de queue) die isopgegeven in de configuratie voor dat berichttype. Request/Reply isin nServiceBus nog wel steeds opgelost met one way messaging. Omervoor te zorgen dat een antwoord terugkomt in de client, moeten wedus nog iets extra doen, namelijk het registreren van een callback omhet retourbericht af te handelen:

Bus.Send(request).Register(asyncCallback, state);

Een geregistreerde callback handler kan geen crash of herstart vande machine overleven. Het reply bericht zal dan echter nog in dequeue staan, dus als je een alternatieve methode hebt om die replyalsnog af te handelen (MessageHandler), dan verlies je in ieder gevalgeen waardevolle data.

Request/ Reply berichtuitwisseling zal vooral veel voorkomen in eind-gebruikersapplicaties, waarin gegevens moeten worden opgehaalden getoond. Voor webapplicaties heeft nServiceBus een speciale vormvoor het registreren van callbacks. Gebruik in dat geval RegisterWeb-Callback in plaats van Register. Zie Listing 11 voor een voorbeeld

hiervan. Aan de serverkant kun je op een verzoek antwoorden met devolgende code:

Bus.Reply<MyResponse>();

Je kunt deze Reply methode in een service meerdere malen aanroe-pen. Dit is handig als je grote hoeveelheden data moet versturen. Hetversturen gebeurt dan op een “streaming” manier. Dit Request/Replypattern kun je goed gebruiken als je opdrachten wilt geven aan eenback-end proces ter verwerking en daarop ooit een antwoord wilt.Voor het opvragen van gegevens is die asynchroniteit misschien nietwenselijk. Liever wil je dan direct antwoord. Hiervoor zijn een WCFservice of een RESTful API misschien beter geschikt.

Alternatieve hostingHet gebruiken van de generic host is geen verplichting. De declaratievemanier om een endpoint te maken en toegang te krijgen tot denServiceBus infrastructuur die ik heb laten zien is niet de enige manierom met nServiceBus te werken. Je kunt dit ook zelf met programma-code aanroepen en zo nServiceBus integreren in een applicatie die ineen custom host of bijvoorbeeld in IIS (Internet Information Server)draait.

In Listing 11 is te zien hoe je via programmacode de nServiceBus con-figureert en start op een manier die equivalent is aan de IConfigureT-hisEndpoint interfaces.

// In een web applicatie, in Global.asax

public class Global : HttpApplication

{

public static IBus Bus { get; private set; }

protected void Application_Start(object sender, EventArgs

e)

{

Bus = NServiceBus.Configure.WithWeb()

.SpringBuilder()

.XmlSerializer()

.MsmqTransport()

.IsTransactional(false)

.PurgeOnStartup(false)

.UnicastBus()

.ImpersonateSender(false)

.CreateBus()

.Start();

}

}

// Gebruik van de bus:

// Een request versturen en het resultaat opvangen in een

WebCallback.

Global.Bus.Send(message)

.RegisterWebCallback<Result>(result =>

Label1.Text = re-

sult.ToString());

Listing 11: nServiceBus in een ASP.NET applicatie

Zelf een host implementeren is niet iets dat je snel zelf wilt doen. Derobuustheid, stabiliteit, performance en mogelijkheden voor monito-ring en logging die je doorgaans nodig hebt zijn niet gemakkelijk omzelf te realiseren. Liever kies je dan voor een host als IIS of de generichost. Het hosten van een subscriber voor events in IIS is niet eenvou-dig, het publiceren of versturen van berichten wel, zoals in Listing 11te zien is.

MAGAZINE26

.NET

WCF integratieHet is mogelijk om nServiceBus te integreren met WCF. Het resultaathiervan is dat de implementatie van een service gewoon bestaat uiteen message handler. De integratie bestaat uit het definiëren van eenclass die afleidt van de WcfService base class. Zie Listing 12.

public class MyService : WcfService<RequestType, Result-

Type>

{

// geen implementatie

}

Listing 12: nServiceBus/WCF integratie

De interface die deze WCF service beschikbaar stelt ziet er altijd het-zelfde uit: er zit één operatie op met de naam Process, die een berichtvan het type RequestType ontvangt en een bericht van het typeResultType retourneert. RequestType en ResultType zijn de typepara-meters van de generic WcfService, zoals in het voorbeeld in Listing12. De SOAP Action en ReplyAction definitie hebben ook een vastformaat. Zie Listing 13 voor een voorbeeld.

[ServiceContract]

public interface ICancelOrderService

{

[OperationContract(

Action=

"http://tempuri.org/IWcfServiceOf_RequestType_Result-

Type/Process",

ReplyAction=

"http://tempuri.org/IWcfServiceOf_RequestType_ResultType/Pr

ocessResponse")]

ResultType Process(RequestType request);

}

Listing 13: ServiceContract definitie van de generiekeWCF interface

Deze WCF integratie biedt je de mogelijkheid om snel een nService-Bus endpoint via WCF beschikbaar te stellen. Je hebt echter geencontrole over hoe de interface eruit ziet. Wil je een intuïtievere interfacedoor duidelijke operatienamen (Process() is wel erg algemeen) of wil jemeer controle over de Action en ReplyAction headers, dan kun je beterde WCF service zelf implementeren op een traditionele manier en deintegratie met nServiceBus regelen door het binnenkomende berichtte publiceren op de bus met Bus.Publish(). De WCF service fungeertdan als een soort proxy die een op RPC gebaseerde wereld verbindtmet de asynchrone wereld van nServiceBus.

SagasEen Saga is een manier om met nServiceBus long running processente implementeren. Dit onderwerp is omvangrijk genoeg om er een heelartikel aan te wijden. Ik zal hier in een volgend artikel op terugkomen.Distributor, Timeout Manager, Proxy en GatewayBuiten de infrastructurele onderdelen van nServiceBus die ik heb be-schreven, zijn er nog vier zelfstandige processen die met nServiceBusmeekomen en die je naar wens kunt inzetten. Dit zijn de Distributor, deTimeout Manager, de Proxy en de Gateway. Deze onderdelen zal ikook toelichten in een vervolgartikel.

ConclusieIn dit artikel heb ik uitgelegd wat er zoal wordt verstaan onder hetbegrip Service Bus in de wereld van Service Oriented Architecture.Er zijn verschillende interpretaties mogelijk. nServiceBus beschouwtde Service Bus vooral als concept, maar levert wel infrastructurele

zaken om communicatie tussen services te realiseren. nServiceBus isgemaakt vanuit de gedachte dat RPC-achtige communicatie teveelblocking service-aanroepen opleveren en daarmee de stabiliteit, per-formance en beschikbaarheid van een SOA geweld wordt aangedaan.Of die bewering waar is, is de vraag. Ook met een WCF oplossing,gecombineerd met Windows Workflow Foundation (WF) kun je schaal-bare en robuuste SOA’s bouwen. Asynchrone communicatie, achter-grondverwerking en retry voor fault tolerance kun je ook met dezetechnologieën realiseren. In sommige gevallen helpt nServiceBus jesnel op weg met bijvoorbeeld de Generic Host, maar van WCF en WFkrijg je ook het een en ander cadeau. Ook gaf ik aan dat in eengemiddelde SOA implementatie alle drie de genoemde communica-tiepatronen wel aanwezig zullen zijn. Het ophalen van data, zoalsreferentiedata, zal je vanuit de client applicatie doorgaans het gemak-kelijkst met (synchrone) Request/Reply kunnen oplossen. Ook voorcommunicatie met de buitenwereld is het gangbaar om met SOAPservices te werken.

Als je voor nServiceBus kiest, dan zal je dat mijns inziens altijd doenin combinatie met andere technieken. Ik vind dat nServiceBus eenaantal zaken fraai oplost, maar ik heb het product nog niet genoeg ingrote praktijkprojecten toegepast om een oordeel te vellen over dekwaliteit als geheel of over de productiviteit bij het ontwikkelen. Debelangrijkste overweging bij het wel of niet inzetten van nServiceBusis of de tamelijk puristische benadering van SOA (geen blocking calls,alleen one-way messaging) past in de architectuur die je aan hetrealiseren bent en de architectuurstandaarden binnen je bedrijf. Het isook deels een kwestie van vertrouwen. Durf je het aan om nService-Bus in te zetten, wetende dat het een open source project is vanenkele enthousiastelingen versus technologie van een gevestigde le-verancier als Microsoft? De mensen achter nServiceBus zijn welgevestigde namen en nServiceBus werkt inmiddels wel aan een aar-dige reputatie met praktijkimplementaties. Wil je je verder in nService-Bus verdiepen, dan raad ik je aan nServiceBus te downloaden en demeegeleverde samples te bekijken. De samples geven je een goedbeeld van de verschillende aspecten van nServiceBus. Ik ga in eenvervolgartikel verder in op een aantal meer geavanceerde aspectenvan nServiceBus.

Dit artikel is gebaseerd op de 2.0 Release Candidate van nService-Bus.

LinksnServiceBus website: http://www.nservicebus.comnServiceBus Architectuurprincipes:http://www.nservicebus.com/ArchitecturalPrinciples.aspxWeblog Udi Dahan: http://www.udidahan.com •

Roy Cornelissen

Roy Cornelissen werkt als IT archi-tect bij Info Support voor de busi-ness unit Industrie. Hij heeft negenjaar ervaring in de ICT en heeft ge-werkt aan uiteenlopende projecten.In zijn dagelijks werk past hij Micro-soft technologie toe in servicegeoriënteerde omgevingen.

Delphi ToolCloudEmbarcadero biedt naast nieuwe versies, upgrades en subscriptions(waarbij je alle upgrades gratis krijgt) sinds kort ook de mogelijkheid omlicenties in een ToolCloud aan te schaffen en te gebruiken.De Embarcadero ToolCloud biedt daarnaast een aantal extra moge-lijkheden zoals het gecentraliseerd beheren van alle licenties, het een-voudig(er) installeren en deployen van ontwikkelomgevingen en tools,inclusief ondersteuning voor meerdere verschillende versies (zoals bij-voorbeeld Delphi 2007 R2 alsmede Delphi 2010, en in de toekomstook Delphi 7 voor wie nog met die versie werkt).Zie de website van Embarcadero of neem contact op met Bob Swartvoor meer informatie over deze mogelijkheid.

Delphi 2010 SurveyHet Delphi Team heeft een Delphi 2010 Survey opgesteld, waarin Del-phi ontwikkelaars hun mening en feedback kunnen geven. Niet alleenop Delphi 2010, maar ook op de onderwerpen en features die wegraag willen zien (of juist niet) in toekomstige versies van Delphi. Laatdeze kans niet voorbijgaan, en deel je mening met het Delphi Teamzodat je invloed kunt (blijven) uitoefenen op de toekomst van Delphi.Zie:http://www.surveymonkey.com/s.aspx?sm=XrKr27_2bmLfybzGzZi_2brsBQ_3d_3d voor de Delphi 2010 Survey.

DataSnap 2010 White PaperBob Swart heeft een DataSnap 2010 White Paper geschreven waarinde architectuur en het gebruik van deze nieuwe versie van het multi-tier framework voor Delphi aan de orde komt. De aandacht wordtvooral gericht op de nieuwe mogelijkheden van de wizards, de filtersen deployment details.Zie http://www.embarcadero-info.com/in_action/radstudio/db.htmlvoor details.

Unicode White PaperCary Jensen heeft een white paper geschreven met de titel “DelphiUnicode Migration for Mere Mortals”, geschikt voor iedereen dieDelphi 2009 of Delphi 2010 gebruikt of wil gaan gebruiken, en zichafvraagt wat Unicode precies is en hoe het effect zal hebben op jebestaande code en componenten.Zie http://edn.embarcadero.com/article/40307 voor meer informatie.

REST White PaperMarco Cantù heeft ook een Delphi 2010 white paper geschreven, metals onderwerp REST waarmee Marco aan de nieuwe generatie webservices werkt en laat zien hoe wel clients kunnen maken voor popu-laire websites en REST servers.

Zie http://www.embarcadero-info.com/in_action/radstudio/rest.htmlvoor details.

Delphi Prism Mono White PaperBrian Long is een tijdje afwezig geweest, maar heeft nu een whitepaper geschreven over het gebruik van Delphi Prism in combinatiemet Mono, met als doel het ontwikkelen van Mono toepassingen diezowel onder Linux als onder Mac OS X te deployen zijn.Zie http://www.embarcadero-info.com/in_action/radstudio/prism.htmlvoor dit white paper.

Quality CentralNiks is zo vervelend als het werken met buggy software – dat zalmenig gebruiker bevestigen. Maar ook als ontwikkelaar is het op z’nminst storend en werkt het vertragend als er bugs of onvolkomen-heden in je ontwikkelomgeving zitten. Er is echter nog één dingvervelender dan een bug, en dat is een bug die niet opgelost wordt.En daar kunnen we allemaal een rol in spelen. Niet zo zeer in hetoplossen, maar wel in het kenbaar maken van de aanwezigheid vaneen bug. Voor Delphi kunnen we daar al jaren de Quality Centralomgeving voor gebruiken. Zie http://qc.embarcadero.com voor deweb pagina waar je de client kunt downloaden, of de web client kuntgebruiken. Bugs worden onderverdeeld in tools, feature sets enhebben een “severity” op basis waarvan het QA team ermee aan deslag gaat. Maar los daarvan kunnen ontwikkelaars ook stemmenuitbrengen op bugs en zelfs nieuwe feature requests (die kun je ookin QC kwijt namelijk). Op die manier is ondersteuning voor SOAP 1.2clients al gerealiseerd, en kan ook jouw meest in het oog springendebug of feature aan de beurt komen.Erger je dus niet langer groen en geel aan die ene bug, maar doe ietsen zorg dat ook het Delphi QA Team zelf er wat aan kan doen. En zorgdat je rapport de stappen bevat om de bug te reproduceren; deeerste stap al op weg om hem op te lossen. Succes, en vast bedankt(ook namens je mede Delphi-ontwikkelaars).

Delphi 2010 Updates 4 en 5Eind december 2009 zijn de updates 4 en 5 (database pack) voorDelphi en C++Builder 2010 uitgebracht. Na installatie moet de aboutbox versie 14.0.3593.25826 aangeven.Zie http://edn.embarcadero.com/article/40174 voor meer informatieen de lijst van fixes (voor een groot deel bug reports uit QualityCentral).

DelphiNieuws

Deafgelopen maanden zijn er verschillendeontwikkelingen en technische publicaties

op het gebied van Delphi geweest.Hierbij een overzicht van het meest in hetoog springende en interessante nieuws.


SDN > Update

9.000

Join

professionals werken samen aanbaanbrekende Microsoft projecten

Werken bij Avanade betekent als onderdeel van een wereldwijd netwerk van IT-professionals werken aan interessante projecten voor grote opdrachtgevers. Avanade-consultants zijn gespecialiseerd inhet Microsoft-technologieplatform en krijgen een groot aanbod van trainingsmogelijkheden om zichzelf daarin te ontwikkelen.

Wil je ook werken aan eenprofessionele carrière in de IT?Kijk dan voor meer informatie op www.avanade.nlOf neem contact met viatelefoonnummer 036 5475107

http://www.avanade.nl

DELPHI Peter van der Sman

Delphi en stringsEerst even het geheugen opfrissen. Als we het hebben over Delphi enstrings dan gaat het al snel over “reference counting”, “copy on write”,“dynamisch geheugen” en “geheugen vrijgeven”. Waar het op neerkomt is dat Delphi probeert te voorkomen dat er kopieën van stringsin het geheugen gemaakt worden, en het geheugen weer vrijgeeft alsde string niet meer nodig is. Op zich allemaal prettige zaken. Innormale situaties scheelt het je een hoop gedoe. Maar er zijn wel eenpaar nadelen. Ten eerste wordt aan iedere string 13 bytes extrainformatie geplakt om de referece-counting te regelen. Gevolg: als jeallemaal strings van 6 karakters (12 bytes) of korter gebruikt ben jeaan directe overhead meer geheugen kwijt dan aan de feitelijke data.Daarnaast moet er logischerwijs op een hoger nivo ook nog geheugengebruikt worden. Op een of andere manier moet immers ergens vast-gelegd worden welke delen van het geheugen (weer) vrij komen enweer (her)gebruikt kunnen worden. En tegen de tijd dat geheugensterk gaat lijken op een gatenkaas met veel gaten heb je natuurlijk ookeen probleem. Een ander nadeel ontstaat als je aan de slag gaat metfuncties die een PChar als parameter gebruiken, bijvoorbeeld als jedirect gebruik wilt maken van de standaardfuncties in windows. Danis er dus ineens geen “copy on write” meer maar wijzig je allereferenties, wat niet altijd de bedoeling is.

Zelf je strings managenHet standaard Delphi geheugenmanagement voor strings werkt primain de meeste standaardsituaties. In situaties waarin je veel (korte)strings gebruikt die bovendien toch nooit opgeruimd worden kan hethandig zijn het geheugenmanagement in eigen handen te nemen. Hetis natuurlijk niet mogelijk om het geheugenmanagement van Delphi uitte schakelen, dus moeten we zelf wat verzinnen. Het basisidee is eengroot array van Chars te declareren en daar dan zelf je strings in testoppen. In principe hoef je dan alleen je startindex te onthouden. Watoverigens evenveel geheugen kost als de reference pointer die jegebruikt om naar je string te verwijzen. Om het ons makkelijk temaken kunnen we daarvoor gebruik maken van de TStringbuildercomponent.

De TStringbuilder componentDe TStringbuilder component wordt gedefinieerd in de SysUtils unit.Hij is standaard al uitgerust met procedures en functies om van allesen nog wat toe te voegen, er iets tussen te voegen of te vervangen.En natuurlijk ook om wat je erin gestopt hebt er weer uit te krijgen:

TStringBuilder = class

…..

function Append(const Value: Integer): TStringBuilder; overload;

function Append(const Value: TObject): TStringBuilder; overload;

function Append(const Value: string): TStringBuilder; overload;

…….

function Insert(Index: Integer; const Value: Integer): TStringBuilder;

overload;

function Insert (const Value: TObject): TStringBuilder; overload;

function Insert(Index: Integer; const Value: string): TStringBuilder;

overload;

…….

function Replace(const OldValue: string; const NewValue: string):

function …….

function ToString(StartIndex: Integer; StrLength: Integer): string;

reintroduce; overload;

…….

property Capacity: Integer read get_Capacity write set_Capacity;

property Chars[index: Integer]: Char read get_Chars write set_Chars;

default;

property Length: Integer read get_Length write set_Length;

property MaxCapacity: Integer read get_MaxCapacity;

end;

Listing 1: interface van TStringbuilder (deel)

Je kan er dus standaard alles heen schrijven, tot en met een TObjectaan toe. Als er maar een string van kan worden gemaakt. Dat maaktdeze component dus ook uitermate geschikt om te gebruiken als jeeen tekstbestand wilt samenstellen. En dus is jammer dat er geenprocedure wordt meegeleverd om de inhoud naar een bestand en/ofstream te schrijven. Gelukkig is, bij wijze van uitzondering, de data-pointer als protected gedefinieerd zodat we dat zelf eenvoudig kunnenregelen in een afgeleide component. Het beste is dat via een proce-dure “SaveToStream” te doen. Je kan die procedure dan gebruikenom via een TFileStream direct naar een bestand te sturen, maar je kandie ook gebruiken om de data in je eigen binaire bestand op te nemen.Een complicatie hierbij is natuurlijk wel dat je na moet denken over deEncoding die je wilt gebruiken en of je wel of niet een PreAmble wiltmeeschrijven. Maar afgezien daarvan is het een makkie. De code is tevinden in de download. Een andere ontbrekende standaardfunctie isde “assign” om een exacte kopie te krijgen. Niet dat je die vaak nodigzult hebben, maar hij kan handig zijn. Ook die is eenvoudig te maken:

Strings of TStringBuilder?Op het SDN event van december werd het nog gezegd: “geheugenproblemen bestaan eigen-lijk niet meer”. Dat had je gedacht. Ja, wij ontwikkelaars zetten wel een bak vol met geheugenneer. Maar wat nu als je gebruikers op een computer van een paar jaar oud werken. Kortom,vlak voor dat SDN event kreeg ik dus meldingen dat mijn applicatie steeds vastliep. En toen ikzelf eens ging kijken bleek dat ik het bestandje van 3 Mb zodanig bewerkte dat de applicatie300 Mb geheugen nodig had. En dat alles om nog een beetje snel met de inhoud van hetbestand te kunnen werken. Na wat analyse bleek al snel dat ik het geheugengebruik konhalveren door gebruik te maken van de TStringBuilder component.


DELPHI

procedure TMyStringBuilder.assign(aSource:TStringBuilder);

begin

self.Capacity :=aSource.Capacity;

self.Length :=aSource.Length;

aSource.CopyTo(0, self.FData,0,aSource.Length);

end;

Listing 2: Toegevoegde procedure “Assign”

Een voorbeeldapplicatieAls voorbeeld maken we een applicatie die alle bestanden in een map(en onderliggende mappen) inleest, waarna we kunnen zoeken ofbestandnaam bestaat. De gevonden bestanden sla ik, voor latergebruik, op in een class die er als volgt uit ziet:

TFileStringClass=class

Selected :boolean;

Path :string;

Filename :string;

Extension:string;

end;

TSDNstringInfo=record Offset:integer; size:word end;

TFileStringbuilderClass=class

Selected :boolean;

PathInfo :TSDNstringInfo;

NameInfo :TSDNstringInfo;

ExtnInfo :TSDNstringInfo;end;

end;

Listing 3: Classtype om bestandsdata op te slaan

In het voorbeeldprogramma zijn deze TFileStringClass en TFileString-builderClass overigens samengevoegd tot één class, om eenvoudigtussen beide varianten te kunnen switchen. In een TSDNstringInfo re-cord worden de gegevens die we nodig hebben om de oorspronke-lijke string weer uit de TStringbuilder te halen opgeslagen. Om dezeinformatie te achterhalen maak ik gebruik van de volgende, zelftoegevoegde procedure:

function TSDNstringBuilder.AppendText(const aTekst:string):

TSDNstringInfo;

begin

result.Offset:=self.Length;

self.Append(aTekst);

result.Size :=self.Length-result.Offset;

end;

Listing 4: Een tekst toevoegen aan de TStringbuilder

De toe te voegen tekst wordt achter aan de bestaande data geplaktmet een reguliere “append”. De offset en lengte voor deze tekstvolgen uit de lengte van de data vóór en na het toevoegen. Overigensga ik er van uit dat de lengte van de strings altijd in een word past.Het teruggeven van de size kan worden weggewerkt door bij hetappenden een goed gekozen scheidingskarakter toe te voegen.Het bespaart niets, want de data die we opslaan wordt nu groter, enbovendien wordt het teruglezen ingewikkelder. Door de gekozenoplossing is het teruglezen nu erg eenvoudig:

function

TSDNstringBuilder.InfoToString(aInfo:TSDNstringInfo):string;

begin

result:=ToString(aInfo.Offset, aInfo.Size);

end;

Listing 5: Een string teruglezen

Als alternatief zou je er ook voor kunnen kiezen om vóór de werkelijkedata de lengte van de tekst, als 2-bits karakter, te schrijven. Je maaktdan als het ware “Unicode-pascalstring”. Ik ben er geen voorstandervan, zoals later in dit artikel nog zal blijken. De gekozen oplossing heeftals voordeel dat hij eenvoudig op te schalen is naar een variantwaarbij het wel toegestaan is langere strings op te slaan, door de Sizeeenvoudigweg als integer te definiëren.

TestenBij een eerste test van het programma bleek de oplossing met stringsin eerste instantie minder geheugen te kosten dan de oplossing metTStringBuilder. Maar daar was een zeer logische verklaring voor. In hetgekozen voorbeeld wordt ook de mapnaam in de structuur opgesla-gen. In de reguliere stringtoepassing krijg je dan het voordeel van dereference counting. Terwijl de TStringBuilder variant braaf iedere keerde mapnaam opnieuw toevoegt. Als we de reference counting meteen trucje te omzeilen gaat de TStringBuilder variant het wel winnen.Het geeft nog maar eens aan dat het afhankelijk is van de applicatieen de data zelf of er in de specifieke situatie voordeel te behalen valtmet een TStringbuilder oplossing.

Een andere opmerking is dat de TStringbuilder ook dynamisch groeiten dus bijdraagt aan het ontstaan van gatenkaasgeheugen. Maar jekan dat wel zelf beperken door vooraf een goed gekozen “capacity”in te stellen. Welke waarde dat moet zijn is natuurlijk afhankelijk van deapplicatie en de te verwachten data.

Een en ander is allemaal eenvoudig te testen met het programma inde download. Om te laten zien dat het echt werkt heb ik een moge-lijkheid ingebouwd om te zoeken op bestandsnaam: In de editboxvoer je (een deel van) de gezochte naam in en drukt op de knop. Allebestanden waarin de opgegeven tekst voorkomst worden dangevonden. En daar loop je dan tegen een probleem op. Ik gebruikdaar de standaard “pos” functie binnen Delphi maar daarin kan je,voor zover ik weet, niet aangeven dat je wilt zoeken onafhankelijk vande “case”. Als voorbeeld laat ik mijn hele C-schijf scannen. Als ik ver-volgens ga zoeken op “app” krijg ik een andere selectie dan als ik zoekop “APP”. De standaardoplossing is om tijdens het zoeken alle stringsmet “Uppercase” in hoofdletters te zetten. Een omslachtige operatie,en zeker als je meerdere zoekopdrachten hebt ook een tijdrovende.Met de TStringbuilder kan dit eenvoudiger: je kan eenvoudig een kopiemaken en deze in éé keer in “Uppercase” zetten. Vervolgens gebruikje die kopie tijdens het zoeken. Om die kopie te maken kan je deeerder genoemde assign gebruiken. Om de hele inhoud in uppercasete zetten heb ik een procedure toegevoegd die direct gebruik maaktvan de Windows aanroep (zoals die ook gebruikt wordt in destandaardfunctie “AnsiUppercase”).

procedure TSDNstringBuilder.setUppercase;

begin

windows.CharUpperBuff(PChar(DataPtr), self.Length);

end;

Listing 6: De inhoud van de TStringbuilder uppercase maken

Het is relatief eenvoudig om zelf procedures toe te voegen die allerleiandere manipulaties doen. Bijvoorbeeld het vervangen van accentka-rakters in accentloze karakters. Dit soort manipulaties is precieswaarom ik eerder stelde geen voorstander te zijn van scheidingstekensen/of het opslaan van de lengte. Als die er niet in staan hoef je er ookgeen rekening mee te houden als je met de tekst gaat manipuleren.

MAGAZINE30

DELPHI

Voorkomen van dubbele stringsEen van de voordelen van de standaardafhandeling kan het voorko-men van duplicaten zijn. We zagen het in dit voorbeeld al eerder bij hetopnemen van de directory van het bestand. Er zijn ook situaties waarinje veel “dubbelen” hebt maar die niet als “dubbel” gezien zullen wor-den, ook niet in de standaardoplossing. In het voorbeeld: veel exten-sies zullen hetzelfde zijn. Maar omdat ze niet als dezelfde verwijzingbinnenkomen zal ook Delphi ze niet als duplicaat zien. Een oplossingzou kunnen zijn om een TStringlist te gebruiken en daar “AddExclu-sive” te gebruiken. Zoiets zit, uiteraard, niet in de standaard TString-builder, maar we kunnen die er wel eenvoudig aan toevoegen. Hetprobleem bij het toevoegen is dat je moet weten waar de afzonderlijkestrings beginnen. Zoals eerder opgemerkt zou dit kunnen door er eenendmarker aan toe te voegen. Een andere methode is om een arraybij te houden met de lengte van de opgenomen strings. Dat heeft bijhet toevoegen een voordeeltje: alleen strings van de juiste lengtehoeven nog te worden gecontroleerd. In code ziet dat er als volgt uit:

…

for lSize in FSizes do begin

if (lSize=result.Size)

and(aTekst=self.ToString(lOffset,lSize))

then begin

result.Offset:=lOffset;

EXIT;

end

else inc(lOffset,lSize);

end;

…

Listing 7: Een string “exclusief toevoegen (deel)

Ook in de download is deze optie toegevoegd en kan worden gebruiktbij het opslaan van extensies.

Conclusie en samenvattingDe standaardafhandeling van strings binnen Delphi werkt in de meestestandaardsituaties prima. Er kunnen echter situaties ontstaan waarinhet wenselijk kan zijn het managen van de strings zelf ter de hand tenemen. De TStringbuilder component is dan een kandidaat om tegebruiken als basis voor zo’n eigen implementatie.•

“als je strings van 6 karakters ofkorter gebruikt ben je aan overheadmeer geheugen kwijt dan aan defeitelijke data”

Peter van der Sman

Peter van der Sman begon op demiddelbare school met programme-ren, in een tijd dat dit nog met pons-kaarten gebeurde. De introductievan de PC maakte hij mee als che-misch analist en later als statisticus.Twee werkvelden waarin de compu-ter een nuttig hulpmiddel is om degrote hoeveelheden (meet)data te

verwerken. Midden jaren ’90 besloot hij, na zijn studie informatica,zich geheel te gaan wijden aan de automatisering. Via PrismanConsultancy houdt hij zich bezig met het maken van software enconsultancy.


.NET TIP:Windows 7 GodModeRaak je de weg in de mogelijkheden van het Configuratiescherm weleens kwijt? Deze zijn natuurlijk georganiseerdvolgens een bepaald concept. Gelukkig is in Windows 7 eengeweldige easteregg aanwezig. Daarna kan je overal bij.Maak een directory aan met de volgende naam: GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

De wereldmensen van Sogeti.

www.sogeti.nl

Je hebt engineers die denken in nullen en enen. Engineers bij Sogeti zien het breder. Die belichten de wereld achter de software. Een wereld met op-lossingen in plaats van toepassingen. Sogetisten ontwikkelen applicaties in omgevingen als Uniface, Cobol, Java, Oracle en Microsoft. Het zijn meesters in migraties. Maar bovenal zijn ze nauw betrokken bij

de uitvoering van projecten. De ene keer in een van de kantoren van Sogeti, de andere keer op locatie bij onze opdrachtgevers in alle markt sectoren. Met alle kennis in huis, met passie voor het vak en altijd op zoek naar de échte wens van de gebruiker. De mens achter het systeem. Want het zijn uitein-delijk mensen die de wereld vooruit brengen.

http://www.sogeti.nl


GENERAL

Being more than interested in model driven software development,this interview cracked me up. James Cameron states that there’s amodel for every rock, every straw, every tree on the planet Pandora,and for every piece of skin and body of the inhabitants. That’s some-thing for you. On the one hand you might say: hey, this Avatar projecttook over 7 years to build, and it costs around 400 million dollar.No way should we do software development projects like that.

James Cameron: “Use the models for sequels”

But it gets more interesting. In the interview James Cameron also saysthat the argument that sold Avatar to studio 20 Century Fox is thatthese expensive and extensive models could be used for any numberof sequels. To sum up why the studio put up with the length and priceof the project in one simple word: it’s reuse.

Seeing is believingI have to admit, seeing is believeing. This movie has the most incredi-ble visual appearance I ever witnessed. And it’s all generated from themodel. And that’s where I got jealous, or even a bit depressed.There we are: enthusiastic software engineers building businesssoftware from our BPMN or UML models or our textual or visual DSL’s.Whatever abbreviation you follow, be it MDA, MDD, FMDD, or MDSD,we think we’re doing great jobs raising the level of abstraction just alittle bit from hand-written code. But even this very little step forwardseems to be highly complex. The technology is hard, the meta-levelthinking is harder, and convincing management and customers (thestudios) that this is the way to go with software development is evenmore challenging.

Kindergarten stuffBut in comparison to the complexity and size of producing Avatar ourwhole MDx venue is kindergarten stuff. We’re not creating a highlydetailed blasting 3D movie experience. We are only implementing asimple business process to change your address at your local bank.

Pfff. Is that all?Don’t get me wrong. We will simply have to move from hand-writingapplications to modeling and generating applications. Raising the levelof abstraction is the only way to deal with the rapidly increasing levelof complexity of technology vendors present us with, and the ever inc-reasing demand for new software, presented on new devices. There’sjust no way we can keep with this demand just by hand-writing all thecode, not with all the developers in the world, not with the best-of-class frameworks at hand, not with the best agile processes and tech-niques in place (let alone waterfall).

Even though model driven techniques are no silver bullet either it willplay an increasingly important role in software development . Our workwill be around simplifying customer demand, standardizing techniquesand raising our levels of abstraction, writing less code and generatingmore code. And for those of you not yet convinced: go see Avatar orpreferably one of its likely many sequels.

Jake Sully: “Ha ha, changing your address at your local bank isdifficult?“

Sander Hoogendoornblog.sanderhoogendoorn.org •

Last month my daughter Sam (13), her friend Joey and I went to see themovie Avatar in 3D at the IMAX theatre in Rotterdam. Following up onthe hype and reading reviews I just got curious. Especially after readingan interview with director James Cameron, who previously directedAliens and Titanic.

Avatar,reuse and model driven development

Before solving complex design problems you need tounderstand the basic components of design at yourdisposal. Much as a musician seeks to understandpitch and rhythm, melody and tempo, a designershould seek a greater understanding and controlover:• unity• gestalt• space• dominance• hierarchy• balance• colorThrough learning these 7 components of design, thewhole of your designs will become more than thesum of their elements and you’ll be better able tocommunicate your ideas.

I’ve written in greater detail about a few of thesecomponents and in the coming weeks I’ll write moredetailed posts about the rest. Consider this post anintroduction.Also note that there are many ways one can breakdown and organize design principles. The 7 compo-nents described here are as organized by Alex Whitein The Elements of Graphic Design.

UnityUnity exists when your design elements are inagreement; when they belong together and aren’t

arbitrarily placed or added to the design. Agreementcan be either visual, conceptual or both.

The 4 basic design principles of contrast, repetition,alignment, and proximity can be used to gain visualunity over your design. Elements that are aligned,repeat some basic characteristic like size, or arelocated in proximity to each other will appear tobelong together. The last principle, contrast, is usedto add variety.Unity imparts order, but too much order can be dulland static. Variety adds interest, but too much canlead to a chaotic design. The key is to find a balancebetween unity and variety so as to have a wellordered design that is also visually interesting.Elements can be conceptually unified by being aboutthe same subject. An image of a steering wheel, afuel pump, and a glove compartment are all unifiedaround the concept of a car.

GestaltGestalt is a German word for form and shape andhere refers to the human mind’s ability to visuallyorganize forms and shapes into a unified whole.When first looking at a design we see the wholeinstead of the parts. When someone says “thisdesign works” it’s because gestalt is at play.By controlling design elements and how eachelement affects those around it you affect thecumulative perception of the viewer. A small changein one element affects how the other elements in

your design are perceived. This cumulative percep-tion is gestalt.We can manipulate gestalt through the same 4 basicprinciples mentioned above as well as through:• figure/ground – the relationship of a subject to

its surrounding space• closure – the viewer’s tendency to complete

unfished forms• continuation – the arrangement of elements to

lead the eye across the page and create flow inyour design

Gestalt helps communicate your message throughthe cumulative perception of all your design ele-ments. Andy Rutledge has written a great series ofposts on Gestalt principles which I encourage you toread• Figure Ground Relationships• Similarity• Proximity, Uniform Connectedness,

and Good Continuation• Common Fate• Closure

SpaceWhitespace or negative space is the space betweendesign elements. It’s just as, if not more, importantthan the space you fill and is one of the mostneglected components of visual design.Day only exists in comparison to night and in muchthe same way your positive space (where designelements are located) only exist in comparison to theempty space around them. Without whitespace,designs become crowded and chaotic. There’s noflow of movement from one element to the next.Space is the context in which your message isperceived. Without ample space communication isdifficult. Imagine a piece of music where every notein the piece was played by every instrument at thesame time. The result would be noise and not music.Music needs space (time) between notes in order tobuild rhythm and melody. Visual design needsspace between elements in order to effectivelycommunicate.

DominanceDominance is contrast taken to the extreme. Bycreating one element to dominate other elements on

The 7 ComponentsOf

MAGAZINE34

SDN > Update

the page, you create an area of interest and a focalpoint to your design. Dominance gives viewers a wayinto your design. It lets them know right away whereto look and from there you can guide them throughthe rest of your design.Without dominance your visitors have to think aboutwhere to look first. Don’t make me think. Make itclear where I’m to look first. Give me an easy way toenter your design and begin to look about.You can create dominance through manipulation of:• size• position• color• style• shapeYou can have more than one area of interest in yourdesign, though one should be dominant. One shouldbe the primary area of interest and be dominant overeverything else.

HierarchyWhile one element should be dominant you cancreate a hierarchy of dominance in order to guidepeople through your design. By creating a visualhierarchy in your design, you enable your page to bescanned and communicate the relative importanceof different parts of the whole.Which of the two layouts above is easier to read?The one without a clear hierarchy on the left or theone with a hierarchy on the right?Once again the basic design principles help uscreate a hierarchy and help us move the eye frommost important to least important elements.

Contrast to make clear what’s most important andrepetition, alignment, and proximity to lead theviewer across a single level of hierarchy and into thenext.Try not to create too many levels of hierarchy. It’seasy to discern most and least, but what’s in betweentends not to be so easy to distinctly separate. Aim for3 levels of hierarchy if you can, most important, leastimportant, and everything else.

BalanceBalance is a state of equalized tension. It’s importantfor achieving gestalt. A balanced design is a moreunified design. Designer’s use visual weight tocontrol design balance. Through the use of things likesize, color, space, and density your design elementscan visually balance each other to create a pleasingwhole.

There are 4 types of balance, 2 of which are moreimportant.• Symmetrical – formal or static balance• Asymmetrical – dynamic balance• Radial – elements radiating from a central point• Mosaic – balanced chaos lacking hierarchy

and focal pointSymmetrical and asymmetrical balance are the twomore important types of balance, with asymmetricalbalance being the more interesting of the two.Kandinsky’s Composition #8 below is a goodexample of asymmetrical balance and dominance.

The dark circle in the upper right is the dominantelement that pulls you into the piece. Notice howthere is no equally dominant object on the right sideto balance it, but rather a combination of elements isused to balance the painting. In a balanced design

the whole is more than the sum of its parts. When adesign is unbalanced some of the parts becomemore visible which leads to competing messagesinstead of a single unified message.

ColorColor aids organization through contrast andrepetition. A good use of color in your design will helpvisitor comprehension of your overall message. Colorprovides direction as it relates elements to eachother. Random color choices negatively affect yourmessage. A color scheme affects your messagepositively by helping achieve unity. You should planfor color early when creating a new design or yourcolors will end up being cosmetic and somewhatrandom.Color theory defines classic color schemes as:• Monochomatic – different shades and tints of a

single color• Analagous – colors adjacent on the color wheel• Complementary – colors at opposite ends of the

color wheel• Split complementary – a main color and

2 addtional colors next to the complementary ofthe main color

• Triadic – 3 colors equally spaced around thecolor wheel

• Tetradic – 2 complimentary color pairsColor evokes emotions. Psychology and cultural dif-ferences influence the way people react to and in-terpret color. Darker colors are seen before lightercolors. Warmer colors move elements forward whilecooler colors make elements recede into the back-ground.

SummaryWhether you’re consciously aware of them or not,each of the above components will be present in yourdesign. You can choose how much or how little of anyto include, but they will all be there to some degreeno matter. Not being aware of them during designwill lead to them being included haphazardly whichmight have negative consequences on your overalldesign.Het originele artikel van Steven Bradley is te vindenop http://www.vanseodesign.com/web-design/7-design-components/

Designby Steven Bradley


.NET Dennis Doomen

gebruiken als eenheid van planning, terwijl fish level use cases maareen deel van de gewenste functionaliteit kunnen leveren. Ik heb zelfveel gewerkt met fish level use cases, en ondanks dat ze erg handigzijn voor een globale omvangsschatting in Use Case Points (eenmethodiek bedacht door Gustav Karner), vaak zijn ze nog te groot omals werkeenheid in een Agile project te dienen.

Wat is het dan?Ik denk zelf dat één van de essentiële verschillen tussen stories enandere methodieken de manier is hoe grote brokken functionaliteitworden opgedeeld in kleine hapklare en schatbare blokjes. Stel jebijvoorbeeld de wens voor om in een E-Commerce website hetconcept product te introduceren. In veel projecten zou het realiserendaarvan worden opgedeeld in een aantal taken of use cases. Zo zouer voor de beheerder een scherm voor het opvoeren van productenmoeten komen, en voor de potentiële koper een scherm om naarproducten te kunnen zoeken.

Elk project prioriteert zijn werk, en voor een use case georiënteerdproject zou dat kunnen betekenen dat de mogelijkheid van zoekennaar producten pas veel later gebouwd wordt dan het opvoeren daar-van. Het scherm voor het opvoeren wordt uiteraard helemaal afge-maakt, inclusief alle bells and whistles die uit de review met de klantkomen. Het grote nadeel hiervan is dat de gewenste functionaliteit duseigenlijk pas af is als alle betrokken schermen zijn afgerond. Zeker bijeen Agile project is het mogelijk dat door wijzigingen in de prioriteit ofde scope deze functionaliteit nooit echt afgerond wordt.

User stories proberen dit op te vangen door te stellen dat dezefunctionaliteit pas business value heeft als het hele proces vanopvoeren en zoeken werkt. Uiteraard loop je daarmee het gevaar datdit alsnog een grote brok werk wordt. Daarom moet je al bij hetopstellen expliciet onderscheid maken tussen de kern van de functio-naliteit zoals de business die ziet en alle extras die het gebruik ervanmakkelijker of gebruiksvriendelijker maken. Zo zou de eerste story zichkunnen beperken tot een simpel invoerscherm zonder mooie layout,validatie of fancy selectielijstje, en een bijbehorend scherm met eenoverzicht van producten waar de bezoeker uit kan selecteren. Delayout laten conformeren aan de huisstijl, een mogelijkheid omproducten in categorieën op te delen, en validatie van velden zouden

User Stories,een verhaal apart

Om maar meteen met een definitie te beginnen: de ideale user story representeert een

onafhankelijke schatbare en prioriteerbare eis of wens, beschreven in de woorden van de

business en die een toegevoegde waarde biedt aan het project of systeem.

Is dat alles? Nou nee, zo makkelijk ben je er helaas niet, maar na het lezen van mijn artikel

beloof ik je dat je een heel eind komt.

Waarom zou ik dit lezen?Met de introductie van Team Foundation Server 2010 laat Microsoftzien dat ook zij actief aanhaken op de best practices van Scrum enExtreme Programming. Het VSTS for Agile process template bevatbijvoorbeeld het nieuwe User Story work item type en levert bovendienrapportages en Excel workbooks die je hele ontwikkelproces kunnenondersteunen. Daarom leek het me wel eens tijd om het user storyconcept eens goed uit te leggen.

Figuur 1: Een user story in Visual Studio 2010

Is het een Use Case?Je zou misschien kunnen denken dat een UML Use Case of een taakuit een work- breakdown ook wel voldoet aan bovengenoemde defi-nitie, maar niets is minder waar. Allereerst onderkend Alistair Cock-burn, een autoriteit op gebied van UML en RUP, use cases op vijfverschillende niveaus. Zo kent het Rational Unified Process (RUP) usecases op sea level die (een deel) van een bedrijfsproces beschrijven endus per definitie een groot deel van een systeem omvatten. Ordina enCap Gemini werken vaak met use cases op fish level waarbij één usecase meestal één scherm of een deel daarvan representeert. Sea leveluse cases hebben het nadeel dat ze te groot zijn om te kunnen

MAGAZINE36

.NET

allemaal als aparte stories kunnen worden gerealiseerd. En ja ik weethet, helemaal onafhankelijk zijn die extra stories natuurlijk niet, maar hetdwingt je wel om je te focussen op de kern van de functionaliteit. Wantal na het realiseren van die eerste story krijgt de gebruiker al een ideevan het systeem in wording en is hij of zij beter in staat om feedbackte geven. Sterker nog, in veel projecten is zo'n eerste story dekatalysator voor nieuwe ideeën en inzichten.

Is het dan het functioneel ontwerp?Ook dat niet. Uit een onderzoek van de Standish Group waarbij meerdan 40000 projecten zijn bekeken, kwamen een aantal verklaringenboven water waarom zo veel projecten nog falen. Eén was het feit datwe onterecht aannemen dat het mogelijk is om een functionele eisondubbelzinnig op te schrijven. En de andere was de gevaarlijkeaanname dat de business al vanaf het begin precies weet wat zewillen. Vandaar dat Agile methodieken werken met korte cycli en datde intensieve betrokkenheid van de business zo belangrijk is.Dat isprecies de reden waarom een user story moet worden gezien als eenherinnering om, op het moment dat deze gerealiseerd gaat worden,opnieuw met de klantverantwoordelijke in overleg te gaan. Pas dankun je optimaal gebruik maken van het voortschrijdend inzicht dattijdens het lopende project is opgebouwd. En pas dan heeft deproduct owner het systeem in aanbouw in levende lijve gezien, en jeweet ongetwijfeld wel dat dit voor een hele hoop nieuwe wensen eneisen kan zorgen.

Maar omdat stories eindig zijn kun je ze ook niet als systeemdocu-mentatie zien. Met andere woorden, zolang het project loopt wordenze gebruikt als centrale plaats voor het vangen van requirements,discussies, schattingen en voortgang. Maar zodra de betreffendefunctionaliteit is gerealiseerd hebben de stories onvoldoende detail omze als referentie te gebruiken. Bovendien worden de stories nietbijgewerkt als er tijdens een demo met de klant verbeteringen en aan-vullingen worden doorgevoerd. Bovendien merkten wij tijdens het uit-voeren van het eerste project dat we nog wat structuur misten.Allereerst had het team behoefte aan een centrale plek waar deconcepten en bedrijfsregels uit het business domain konden wordenbijgehouden. Omdat ik zelf veel ervaring had met domein modellenzoals Martin Fowler dat bedacht heeft, en het laatste jaar meer enmeer ben gaan doen met Domain Driven Design (een concept vanEric Evans), lag het voor de hand om hier een domein model voor tegebruiken. En ook de klantvertegenwoordiging had soms wat moeiteom het overzicht te houden over de vele stories die op onze lijst vanrequirements stonden. Na wat gegoogled te hebben, liep ik tegen eenhele set van posts en discussies aan geleid door Alistair Cockburn.Alistair had hetzelfde probleem en had geëxperimenteerd met hettoepassen van use case diagrammen om de context van het systeemte illustreren. Ik gebruik de use cases op zo’n diagram om schermen,externe koppelingen en processen te representeren. Dit blijkt erg goedte helpen als je met je klant in gesprek bent over een nieuwe feature.En ook al kun je een volledig functioneel ontwerp in de use casebeschrijvingen kwijt, bij ons blijft het bij simpele diagrammen. Allefunctionele aspecten blijven onderdeel van de stories.

Wie? Wat? Waarom?Een ander belangrijk aspect van user stories is het feit dat het bij demeeste requirements wel duidelijk is wat de specifieke wens of eis isen welke soort gebruiker een rol speelt, maar de reden of aanleidingdaarvan ontbreekt. User stories worden daarom in principe altijdgeschreven in de vorm "Als wie, wil ik wat, zodat ik waarom". De wiebeschrijft de stakeholder of rol die belang heeft bij de eis of wensbeschreven door de wat. De waarom moet aangeven waarom die eisof wens zo belangrijk is voor het product. Een goed voorbeeld van hetnut van dat laatste is dat het ontwikkelaars de mogelijkheid geeft omop een beter alternatief voor een eerder door de klant bedachteoplossing te komen. Pas wel op dat je tijdens het verzamelen van user

stories niet uitkomt op een reden die een herhaling is van de wens ofeis. De truc is daarbij om door te blijven vragen totdat de echte redenboven water komt.

Wie schrijft ze dan?Dat hangt er vanaf. In Scrum bijvoorbeeld, is het de product owner rol(de term die ik in de rest van artikel gebruik) die de klant(en)representeert en de verantwoordelijkheid heeft over de volledige lijstvan user stories, ook wel de product backlog genoemd. Buiten hetfeit dat de product owner de prioriteiten bepaald binnen een project,is hij in principe ook degene die de user stories schrijft. Maar in depraktijk zal dat vaak in samenwerking gaan met het team dat defunctionaliteit moet gaan realiseren. Het schrijven van goede stories isnamelijk niet triviaal.

Welke eisen?Zo moeten ze idealiter aan een aantal eisen voldoen gevangen in hetEngelse acroniem INVEST. Allereerst moeten ze zo independentmogelijk zijn. Immers, hoe onafhankelijker ze van elkaar zijn hoemakkelijker het is om de prioriteiten tussen stories te wijzigen. Dat datsoms lastig voor elkaar te krijgen is staat buiten kijf, maar soms kun jedit oplossen door de story te splitsen of twee stories juist tecombineren.

De tweede eis is dat een story negotiable moet zijn, wat zoietsbetekent als dat de beschrijving van de story voldoende ruimte moetbieden om tijdens de bouw discussie mogelijk te maken. Zoals ik aleerder schreef, stories zijn geen vervanging van het functioneelontwerp, maar juist een herinnering om tijdens de bouw samen met deproduct owner de details uit werken. Schrijf je stories die functioneelhelemaal dichtgetimmerd lijken te zijn, dan zou je daarmee deimpressie kunnen wekken dat er geen discussie meer nodig is, terwijldat nou juist de essentie is van user stories.

De derde eis, value, geeft aan dat de user story waarde moet hebbengezien vanuit de business. Een voorbeeld hiervan is wederom deeerder genoemde productcatalogus. Alleen het scherm voor hetopvoeren van producten heeft geen business value. Immers, zolangeen potentiele klant die producten nog niet kan bekijken heb je daarniets aan. Beide schermen volledig realiseren is ook geen optie omdatdat juist weer heel erg lang kan duren. Maar voor de product ownerzou het voldoende kunnen zijn als de klant in een eerste versie alleennog een beschrijving en een prijs kan zien. De mogelijkheid om er eenfoto bij te plaatsen zou wellicht in de volgende versie gebouwdkunnen worden, en is dus een aparte user story. Helaas is dezemanier van opsplitsen niet altijd triviaal, dus is het zaak om samen metde product owner te bekijken wanneer een story nog business valueheeft.

De vierde eis stelt dat elke story estimable oftewel schatbaar moetzijn. Dat klinkt misschien flauw, maar zodra je merkt dat het moeilijk isom de omvang van een user story te schatten, dan is het zeer waar-schijnlijk dat de scope van die story te breed is. Overigens mogen deschattingen voor stories die pas in een later stadium van het projectworden opgepakt nog best grof zijn. Elke poging om hier eengedetailleerde schatting aan te hangen creëert de illusie dat allebelangrijke aspecten al bekend waren ten tijde van de schatting. Hetis veel belangrijker om later met alle kennis en ervaring die danbeschikbaar is een realistischer schatting te maken.

Een belangrijke middel of te zorgen dat user stories schatbaar zijn isdoor ze klein te houden, oftewel small. Een mooi voorbeeld dat ikergens in een blog gelezen heb is om iemand in het team te vrageneen schatting te geven van de hoeveelheid werk voor een redelijk grotestory. Als hij of zij deze vraag beantwoord met: "Ehm, iets van eenmaandje of zo" dan kun je er vergif op innemen dat de ontwikkelaar


MAGAZINE38

.NET

nog helemaal geen beeld heeft van de inhoud en de scope van diestory. In zo'n geval is het niet onverstandig om te proberen deze storyop te splitsen in een aantal kleinere stories met business value en eenbeperkte scope. En daarmee zijn we aangekomen bij de laatste lettervan het acroniem, de ‘t’ van testable. En dit heeft niets met geauto-matiseerde testen of iets dergelijks te maken, maar juist met het feit dateen user story voorzien moet zijn van een aantal meetbare criteriawaarmee ondubbelzinnig bepaald kan worden of de interpretatie vanhet team overeenkomt met de story zoals die door de product ownerbedoel was. Omdat de product owner het resultaat natuurlijk nog nietgezien heeft, krijg je dit niet altijd even makkelijk boven water. Maareen hulpmiddel dat kan helpen is om te vragen hoe hij de gewenstefunctionaliteit zou demonstreren aan andere gebruikers. Dit wordt ookwel de how-to-demo van een story genoemd.

Hoe beperk je de scope?Uit eigen ervaring weet ik dat het bepalen van de juiste scope erg las-tig is, zeker in het bijzijn van de product owner of een andere verte-genwoordiger van de business. Een bijzonder handig hulpmiddeltjeom deze zo scherp mogelijk te definiëren is door gebruik te makenvan zogenaamde storyotypes. Het idee hierachter is dat een goedestory altijd voldoet aan exact één storyotype. Lukt dat niet, dan is destory te groot of te klein en is het zaak om ze te combineren of juist opte splitsen. Het concept van stereotypes voor user stories is voor heteerst door Gerard Meszaro beschreven in zijn artikel Using Storyoty-pes to Split Bloated XP Stories. Daarin onderkend hij de vier storyo-types uit tabel 1.

Tabel 1: Storyotypes volgens Gerard Meszaro

Stel je nu eens een scherm voor waarin je kunt zoeken op productenuit een catalogus. In een aanpak gebaseerd op fish level use caseswordt het gehele scherm, inclusief alle bedrijfsregels, mogelijke zoek-velden en de volledige look-and-feel van de resultaten, meestal alséén use case gezien. Maar wil je dit scherm opdelen in een aantalkleinere use cases die nog steeds voldoen aan INVEST, dan kunnendeze vier storytypes hierbij helpen. Zo zou je als eerste story hetzoeken kunnen beperken op alleen de naam van een product enpresenteer je het resultaat in de standaard layout. Dat biedt nog steedsbusiness value en is dus in feite New Functionality. Alle aanvullendezoekmogelijkheden kun je later toevoegen als één of meerdereVariations, en het opleuken van de look-and-feel als UI Enhancement.Kom je door tijdnood niet meer toe aan die extra mogelijkheden, danis je basisfunctionaliteit nog steeds zinvol. Als je al in Visual Studio2010 naar het User Story work item hebt gekeken dan zal het je wel-licht zijn opgevallen dat deze geen veld voor een storyotype kent. Maarwees niet getreurd, het Agile process template is vrij makkelijk aan tepassen. En als de TFS 2010 Power Toys beschikbaar komen wordtdat helemaal een makkie. In de tussentijd kun je een aangepast WorkItem Template (een WIT) via mijn blog downloaden (zie de linksonderaan dit artikel).

Wat is het waard?In de praktijk hebben de storytypes mij enorm geholpen in de discus-sie met de product owner, maar ik merkte wel dat er een aantalsoorten activiteiten zijn die niet helemaal passen op deze vier storyo-types en de eisen uit het INVEST acroniem. Vaak zijn er eisen en wen-sen in het project die niet van de product owner komen, maar die welbelangrijk zijn om het betreffende systeem in productie te kunnen zet-ten. Zo zou de IT afdeling bepaalde eisen kunnen stellen aan het

systeem om uitgerold te kunnen worden op hun infrastructuur. Ofmisschien willen ze de mogelijkheid hebben om real-time logging opte kunnen vragen. Als architect wil je dat het systeem op een bepaaldemanier gebouwd wordt zodat de onderhoudbaarheid gegarandeerd is,en als team leider wil je mogelijk een automatische nachtelijke buildinrichten om zo de kwaliteit in de gaten te kunnen houden.

Figuur 2: Het storyotype veld bij een user story

Je zou dit soort taken kunnen oppakken door ze als onderdeel vaneen normale user story op te pakken. Maar je zou ook een vastpercentage van je capaciteit kunnen reserveren. Ik ben van meningdat het beter is alle niet-functionele zaken expliciet zichtbaar te makenin je project. Dat helpt ook in de discussie met de product owner alsje hem moet uitleggen waarom je maar een beperkt aantal van zijnuser stories gaat oppakken. Om die reden moeten user stories in mijnproject project value hebben, en niet per se business value.

Waar begin je?Stel nou dat je na veel overleg een lijst van user stories hebt en jebegint met het realiseren van een nieuw systeem. De eerste story zaldan buiten de gewenste functionaliteit ook het bouwen van hetskelet van je architectuur omvatten. Hoe voorkom je dan dat je daar-mee een onacceptabele hoeveelheid van je tijd bezig bent? Hetartikel Managing the Bootstrap Story van Jennitta Andrea behandelddeze uitdaging in meer detail en biedt een aantal alternatieveoplossingen. Eén van die oplossingen is om in overleg met deproduct owner een story te definiëren die weliswaar minimale functio-naliteit biedt, maar toch project value heeft. Zo’n story wordt vaak debackbone story genoemd omdat je daarmee de ruggengraat van jesysteem realiseerd. Een vaak voorkomend compromis is om debackbone story te gebruiken als proof-of-concept van de gekozenarchitectuur. Omdat hij daarmee het vertrouwen verkrijgt dat het teamin staat is om een dergelijk product te bouwen, zou dat voor deproduct owner al voldoende project value kunnen bieden.

Nog meer storyotypes?De bovengenoemde backbone story is natuurlijk ook gewoon eenstoryotype. Sterker nog, nadat ik op zoek ging naar oplossingen voorhet vastleggen van de niet-functionele eisen, liep ik tegen een pre-sentatie aan met een hele set van additionele storyotypes. Dan Rawst-horne, de auteur, heeft gepoogd om voor virtueel elke mogelijkactiviteit een storyotype te definiëren. Ik vind zelf dat hij daarbij wat ver

Storyotype BeschrijvingNew Functionality Een brok nieuwe basisfunctionaliteit die (redelijk)

onafhankelijk is van andere user stories.Variation Een aanvulling of uitbreiding van een eerdere user

story, zoals bv. extra zoekvelden of extra kolommen.New Business Rule Aanvullende (complexe) bedrijfsregels of controles.User Interface Enhancement Het verfraaien van de look-and-feel zoals het

toepassen van kleuren of een bepaalde layout of het verbeteren van de gebruiksvriendelijkheid.

Storyotype BeschrijvingCompound Epic Een samengestelde user story die dient om een aantal

stories logisch te groeperen.Complex Epic Een user story waarvan de inhoud en impact pas later

in het project bepaald kan worden, maar waarvan wel bekend is dat de hoeveelheid werk omvangrijk is.

Setup Een story die dient om de projectomgeving in te richten. Bv. een source control omgeving, een project website, een build omgeving.

Technical Een user story die als doel heeft om een technische aanpassing of verbetering door te voeren. Bv. voldoen aan een coding standard, het refactoren van een slecht ontwerp, het uitvoeren van een performance test.

Documentation Een story voor het schrijven van bv. een gebruikers handleiding, de installatiehandleiding, etc.

Training Het geven van trainingen aan bv. functioneel beheerders, of het organiseren van workshops voor eindgebruikers.

Quality Improvements Een story die als doel heeft om een aantal gerelateerde bugs op te lossen.

Spike Een story met als doel een technisch onderzoek te doen naar bv. de toepassing van een bepaald stuk technologie, of het proberen van een alternatieve technische oplossing.

Tabel 2: Nuttige storyotypes volgens Dan Rawsthorne


.NET

gegaan is, maar een kleine set van additionele storyotypes blijken inde praktijk toch wel nuttig te zijn.

Wanneer is het verhaal af?Maar hoe weet je nu of een user story succesvol is afgerond? Nou, alshet goed is conformeren alle stories aan INVEST en zijn ze voorzienvan een aantal criteria (de how-to-demo) opgesteld door de productowner. Daarmee is het feit of een gerealiseerde story functioneelcorrect is al bepaald. Wat je dan nog mist is een aantal afsprakenzodat alle stakeholders, inclusief de product owner, weten wanneerhet team vindt dat de story af is. Wat dat precies inhoud kan per teamwisselen, maar meestal worden meerdere van de onderstaandecriteria aangehouden.

• De code compileerd en er zijn geen warnings of errors.• De code voldoet aan de coding standards van het project of

organisatie.• De code is gereviewed.• Alle unit- en integratietesten zijn geslaagd.• De Code Analysis van Visual Studio geeft geen waarschuwingen.• ReSharper geeft geen meldingen over potentiële fouten

(alles is ‘groen’).• De dagelijkse integratiebuild heeft succesvol gedraaid.• De functionaliteit is getest door een ander lid van de team dan de

ontwikkelaar.• De oplossing is gecontroleerd aan de hand van een interne

checklist.• De functionaliteit is getest door een systeemtester.• De look-and-feel is gecontroleerd door een medewerker van de

afdeling communicatie.Het totaal van die afspraken en de how-to¬-demo van de story wordtde definition-of-done genoemd.

En de planning dan?Stories zijn ook uitstekend geschikt om te gebruiken als eenheid in jeplanning. Puristisch gezien hebben Agile projecten geen lange termijnplanning en wordt de functionaliteit iteratief gerealiseerd waarbij deprioriteit continu kan worden bijgesteld. Maar in de realiteit ontkom jeer vaak niet aan om een planning te maken. Hoe los je dat dan op?Wat ik vaak doe is alle stakeholders in aantal workshops te krijgen enmet behulp van de use case modellen als context alle stories oppapier te krijgen. Daarbij moet je waken dat je niet te veel in de detailtreedt. Dat zou alle betrokkenen een vals gevoel van precisie kunnengeven waardoor ze de stories toch als functioneel ontwerp gaan zien.Zijn er brokken functionaliteit waarvan niemand nog precies weet hoedat zou moeten gaan werken, maak er dan een epic story van enintroduceer een spike om later in het project tijd te reserveren om dieepic verder uit te werken. Organiseer daarna een aantal korteremeetings met het team, of, als dat er nog niet is, met een aantalervaren ontwikkelaars. Laat hier alle stories de revue passeren enprobeer de omvang te schatten in zogenaamde story points. Som-mige mensen uit de Agile community zeggen dat je hier alleen relatiefmoet schatten. Dus een story die gevoelsmatig twee keer zo veel werkis als een andere story moet ook dubbel zoveel story points krijgen. Ikwerk zelf met de insteek dat elke story point overeenkomt met deideale dag van een ervaren senior software ontwikkelaar. Met anderewoorden, één story point betekend dat een ervaren ontwikkelaar diebekend is met de gekozen architectuur, aanpak en technologie 8 uurlang moet werken, zonder gestoord te worden door telefoon, email enandere afleidingen. Mike Cohn, schrijver van het boek User StoriesApplied, heeft hier een groot aantal hoofdstukken aan gewijd. Ideali-ter is elke story tussen de 1 en 8 story points, maar vooral aan hetbegin van het projecten kunnen er nog epics zijn die nog niet op tesplitsen vallen. Na die meetings heb je een schatting van de totale om-vang van het systeem. Om nu tot een aantal uren te komen moet jeeen schatting maken van de productiviteit van het verwachte team ten

opzichte van die ideale senior ontwikkelaar. Mike Cohn doet dit dooreen tabel te maken met de verwachte rollen, hun inzet, en hun pro-ductiviteit in een percentage af te zetten. Het aantal mandagen kun jebepalen door het aantal story points te delen door de gemiddelde pro-ductiviteit. Bijvoorbeeld, een team met een gemiddelde van 75% heeftvoor 10 story points 10 / 0.75 =13,5 mandagen nodig. Het resultaatvan dit alles is dus een planning om een vast aantal story points terealiseren. Natuurlijk is het maar een schatting, want zowel deproductiviteit kan tegenvallen als de schatting in story points kunnenafwijken, maar het geeft je wel een initiële schatting die gebruikt kanworden voor een globale planning en budgetbesprekingen. Uiteraardis het van belang om te zorgen dat je de daadwerkelijke productiviteitcontinu blijft meten.

Tjonge, en nu?Het moge duidelijk zijn dat een user story geen onafhankelijk conceptis, maar nauw samenhangt met heel veel van de facetten van ons werkin de software industrie. In dit artikel heb ik een poging gedaan omeen aantal van die facetten toe te lichten en de relatie ertussen te ver-duidelijken. Maar ondanks dat ik niet heel erg de diepte in kan gaanhoop ik dat ik je zo enthousiast heb gemaakt dat je staat te springenom meer over de wondere wereld van de stories te weten te komen.Heb je nog vragen of opmerkingen, schroom dan niet om mij temailen op [email protected] of twitter mij op mijn Twit-ter ID ddoomen.

Waar kan ik nog meer lezen?• De blogs van mijzelf en Aviva Solutionshttp://www.dennisdoomen.net en http://blog.avivasolutions.nl• Managing The Bootstrap Storyhttp://www.agilealliance.org/system/article/file/886/file.pdf• Using Storyotypes to Split Bloated XP Stories http://www.sprin-gerlink.com/content/h53td341yagcc80w/• Storyotypes for Agile Developmenthttp://www.sdexpo.ru/data/speakers_2007/dan_rawsthorne_story-otypes.pdf• User Stories Applied for Agile Software Developmenthttp://www.amazon.com/User-Stories-Applied-Software-Develop-ment/dp/0321205685• Domain Driven Design Quicklyhttp://www.infoq.com/minibooks/domain-driven-design-quickly •

Dennis Doomen

Dennis Doomen is een enthousiasteen pragmatische consultant met dik12 jaar ervaring in de IT. De laatste 8jaar daarvan heeft hij vooral besteedaan het.NET producten technolo-gieportfolio, architectuur en object-oriëntatie. In die periode is hij(mede)verantwoordelijk geweestvoor het ontwerpen, bouwen, en

uitrollen van ontwikkelstraten gebaseerd op .NET en DSLs.Tegenwoordig maakt hij voornamelijk gebruik van de standaardsoftware factories en applications blocks van Microsoft's Patterns& Practices team en heeft hij als Expert Advisor opgetreden voorde Web Service Software Factory: Modeling Edition. Hij heeft hettot zijn doel gesteld om zo veel mogelijk van zijn ervaringen tedelen met de .NET community en is altijd in voor een leukediscussie. Als C# adept heeft hij verder nog C# coding guidelinesgepubliceerd waaronder een binnenkort te publiceren C# 3.0versie.

DOTNETNUKE

Stefan Kamphuis

DotNetNuke ProfessionalSinds enige tijd is van DotNetNuke een Professional Edition (PE)beschikbaar. Daarnaast is vanzelfsprekend ook nog altijd deCommunity Editon (CE) beschikbaar. DotNetNuke CE is en blijft eenOpen Source applicatie en de volledige code van DotNetNuke CE isook onderdeel van DotNetNuke PE. Echter, aan DotNetNuke PE isnog wel een aantal features toegevoegd, die in DotNetNuke CE nietbeschikbaar zijn. Aangezien de doelgroep voor DotNetNuke PEbestaat uit bedrijven die DotNetNuke in business-critical omgevingengebruiken, zijn deze “extra” features ook op deze doelgroep gericht.

Befenits of DotNetNuke ProfessionalThe Professional Edition provides organizations running business-critical applications the features and services they expect from aproprietary software vendor including:• A tested and verified version of the Professional Edition content

management system (CMS) including the DotNetNuke opensource core framework

• Full product documentation• Email notifications of security patches and product updates• Access to the Professional Edition online Knowledge Base• Unlimited online and email product support with second level

support from DotNetNuke Corp architects and engineers (phonesupport over a wider time window is available with theElite Edition)

• Product copyright indemnification

The Professional Edition web content management system andapplication development platform includes features which are notavailable in the Community Edition:• Advanced Content Approval Process - Administrators can create

custom workflows with an unlimited number of states andreviewers

• User Interface Customization with Telerik RadControls - A licensefor Telerik RadControls for ASP.NET AJAX for an unlimitednumber of developers to use within your Professional Editioninstance

• Page and Module Caching – Multiple caching options speed thedelivery of web pages and reduce the workload on your web

DotNetNuke

Community UpdateDe DotNetNuke Community is voortdurend inbeweging. Voor insiders zijn alle ontwikkelin-gen al nauwelijks te volgen, en de meesteontwikkelaars zullen ook niet de tijd hebbenom alles exact te volgen. Vandaar dat deDotNetNuke Sectie van SDN gemeend heeftdeze keer het belangrijkste nieuws van de af-gelopen tijd op een rijtje te moeten zetten.Door de verscheidenheid aan bronnen is eengroot deel van dit artikel in het Engels.

Nieuwe Nederlandse GebruikersgroepNadat de aloude Dutch DotNetNuke Usergroup enige tijd aanactiveit had ingeboet, werd het in de Nederlandstalige DotNetNukecommunity duidelijk dat er toch behoefte is aan een actieve gebrui-kersgroep. In overleg met diverse mensen heeft dat geleid totde oprichting van een nieuwe gebruikersgroep: de DotNetNukeGebruikersgroep Nederland. Deze naam is wellicht weinig verrassend,maar zegt wel wat de peilers van de gebruikersgroep zullen zijn:Nederlands en Gebruikersgroep. De DNNGG zal zich onderscheidendoor Nederlandstalig te zijn en alle gebruikers van DotNetNuke teadresseren:• Ontwikkelaars: gebruiken DotNetNuke als framework voor

maatwerk software Beheerders: beheren een DotNetNukewebsite

• Ontwerpers: maken ontwerpen voor DotNetNuke websites• Geïnteresseerden: doen nog geen van bovenstaande, maar zijn

wel geïnteresseerd

De DNNGG zal online te vinden zijn op www.dnngg.nl, alwaar ook deNederlandstalige taalpakketten voor DotNetNuke ter downloadbeschikbaar zullen zijn. In nauwe samenwerking met SDN zullenverschillende activiteiten worden ontplooid. Houdt hiervoor dnngg.nl ofde SDN website in de gaten.

De DNNGG zal zich onderscheidendoor Nederlandstalig te zijn en allegebruikers van DotNetNuke teadresseren

The Professional Edition providesorganizations running business-criticalapplications the features and servicesthey expect

MAGAZINE40

DOTNETNUKE

servers• Google Analytics for Marketing – Support for advanced Google

Analytics functionality such as visitor type, landing page, role,or referrer segmentation

• Granular Permissions – Page, module and folder level extendedpermissions provide more granular security rights

• Security Center – Continuously feeds relevant alerts to youradministrators with links to download any relevant securitypatches

• File Integrity Checking – Checks files in the installation and reportsany inconsistencies which may impact web site reliability

• Web Server Farm Support – New caching provider delivers moreefficient resource usage in web farms

• Health Monitoring – Pings the website periodically to identifyfailures and will notify the site owner. Also ensures the site staysin web server memory for faster user accessibility

The Professional Edition annual subscription provides you with fullaccess to the most recent version of the software during yoursubscription. The Professional Edition subscription model allows youto renew or opt out of your subscription and migrate to the freeCommunity Edition at the end of each subscription period, providingyou with more flexibility than with enterprise software pricing models.

DotNetNuke Community TeamsIn 2009 is de organsiatie van DotNetNuke sterk veranderd. Doordat erbedget beschikbaar kwam om, naast de vele vrijwilligers, ook betaaldekrachten aan te trekken, ontstond de noodzaak om het team meerstructuur te geven. Dit hoofdstuk geeft inzicht in hoe het DotNetNukeProject op dit moment is ingericht.

Community Teams are the backbone of the DotNetNuke Open SourceProject. Every day, volunteer contributors from all over the worldperform myriad tasks necessary to keep the largest Microsoft-basedopen source project in the world running smoothly. They create andtest new versions of extensions; monitor and moderate forums;conduct peer review; validate and test reported issues; collaborate oncore design and development; create documents, articles and videos;enhance user experience, and much, much more.

Fig. 1: DotNetNuke Community Team Organisation

The project is organized into six teams designed to help us collabo-rate effectively on projects, tasks and goals that serve the Community.In the coming weeks these teams will begin rolling out plans andprograms based on the new organization, creating additionalopportunities for Community involvement.

Each team is comprised of Community Team Members working along-side DotNetNuke Corporation employees, and assisted by commu-nity volunteers just like you.

Forge TeamEmpower developers to make the best use of the DotNetNukeplatform extensions capability. Some key project areas include theDotNetNuke Forge and associated services, development standardsand templates, etc.

Quality TeamSupport continuous quality improvement in the DotNetNuke platformand Forge development. Some key project areas include IssueTracking and Management, Public Beta Testing, Forge ReleaseProcess, and testing automation.

Reference TeamExpand and enhance the foundation of knowledge available to allDotNetNuke stakeholders; developers, administrators, users, etc.Some key project areas include Open Core API documentation,Community Wiki, Document Repository, etc.

Experience TeamEnhance the usability, aesthetic and general user experience ofDotNetNuke and Community Resources. Some key project areasinclude Community Recognition, Team Directory, Skinning Contest,UX Advisory and Forums upgrade.

Internationalization TeamChampion adoption of the DotNetNuke framework in non-Englishspeaking regions of the world. Some key project areas includeContent Localization Advisory, Language Pack Facilitation andManagement, Cultivation of Language Leaders.

Health TeamPromote health and wellbeing of the DotNetNuke Community. Somekey project areas include Community Recognition, Forums upgrade,policy and moderation, Project Management, User Group organiza-tion and support.

DotNetNuke with Telerik InsideFrom Shaun Walker’s blog.

In the spring of 2009, we spent considerable time brainstorming theuser experience strategy for the DotNetNuke platform. EmbracingWeb 2.0 techniques and making DotNetNuke more visually appealingand contemporary had been on the roadmap for quite some time andwe knew that we needed a new user interface paradigm in order toaccomplish this goal. And to ensure that end-users received theoptimal user experience possible, we also recognized that we neededto enforce consistency and provide formal conventions for webdevelopers and designers. This meant that whatever solution wechose needed to be accessible to everyone and therefore needed tobe available as part of our core platform.

Community Teams are the backbone ofthe DotNetNuke Open Source Project


DOTNETNUKE

We evaluated four different options:1. Build our own web controls – this would provide an out-of-the-

box set of building blocks for developers and designers with asimple licensing / support model. However we are not a webcontrol vendor and have no interest in spending cycles on an areawhich is not part of our core business.

2. Use Microsoft web controls – developers already have access tothese controls through ASP.NET so the licensing / support is wellestablished. However, the Microsoft toolset is rather limited incomparison to other third party alternatives and with Microsoft'srecent focus on MVC, web controls do not appear to be a majorfocus area for them going forward.

3. Use third party open source controls – although rich infunctionality, these controls generally lack the support andcommitment of an established vendor. Licensing is usually not aproblem; however, some enterprise customers are wary ofmanaging too many embedded open source licenses as part of acomplete solution.

4. Use third party proprietary controls – this option provides a richsuite of UI controls which is backed by professional vendorsupport. Unfortunately it is complicated by proprietary licensingissues.

After carefully weighing the pros and cons of each option, we conclu-ded that the fourth option above offered the most value to the Dot-NetNuke platform - so long as we could overcome the largestimpediment of identifying a vendor who was willing to work with us toresolve the licensing challenges.

Well, it turns out we did not have to look too far. Telerik is the leadingvendor of development tools and components for the Microsoft .NETplatform and Telerik had been a platinum sponsor of the DotNetNukeopen source project for the past 4 years. We reached out to themanagement team at Telerik with a detailed proposal of what wewanted to accomplish and they were highly receptive to the conceptof forging a strategic partnership.

Now in business it is always important to consider multiple options, soI should mention that we also took our proposal to a number of theother prominent .NET web control vendors. Each of these vendorsalso expressed interest in working with us but in the end we feltTelerik was the best candidate, partly because of their superiortechnology, and partly because they were already an active memberof the DotNetNuke open source community.

So why is a strategic partnership interesting to Telerik? It's quitesimple, really. This is a channel opportunity. To be the de facto webcontrol toolset of choice in a developer ecosystem representing750,000 developers and 5 million downloads is a very compellingvalue proposition. It exposes more developers and designers to theTelerik web controls and creates a cross-selling opportunity for otherproducts in their portfolio.

So what are the details of the Telerik license agreement in simpleterms?• DotNetNuke Community Edition users are only able to develop

using RadControls through standard user interface extensionsprovided in the DotNetNuke platform.

• DotNetNuke Professional Edition customers receive a fulldevelopment license for Telerik RadControls which allows any

number of developers within an organization to develop using thefull toolset within DotNetNuke.

In regards to the scenario outlined above, there is actually a signifi-cant economic benefit for DotNetNuke Professional Edition customers.Since the Telerik RADControls for ASP.NET AJAX are normally pricedat $999 per developer when purchased from Telerik directly, if you aredoing DotNetNuke development and you have 2 or more developersin your organization, you can achieve a cost savings on your toolsetby purchasing DotNetNuke Professional Edition.With 5.2 we have only just begun the process of integrating thedyanamic Telerik controls into DotNetNuke. In future releases you canexpect significant UI improvements as we take steps to modernize theuser experience of the DotNetNuke platform.

DotNetNuke Corporation Acquires SnowcoveredFrom Shaun Walker’s blog.One aspect which has been critical to the success of the DotNetNukeplatform is the ability to enhance the core functionality with customextensions. This "killer" architectural feature dates back to the 1.0release in mid-2003 where we introduced the ability to createmodules which could be packaged as a single ZIP file and distributedto other users for simple run-time installation into their site. Over theyears other extension types have been added and today includecategories such as modules, skins, providers, skin objects, languagepacks, and skin widgets.

Now this is the Microsoft ecosystem, so it did not take very longbefore developers discovered the extensibility model and recognizedthe unique commercial opportunity it presented. Commercialmodules began to appear in late 2003 and as the DotNetNuke plat-form evolved, so did the commercial extensions ecosystem aroundthe project. In fact a number of the more serious vendors whichcustomers rely on as a critical component of their business today, gottheir start during this time frame.

While this was going on, Brice Snow created a central ecommercemarketplace to connect consumers with module developers: Snow-Covered.com, which soon became a one-stop-shop for all DotNet-Nuke extensions. The introduction of this marketplace was invaluableto the growth of the DotNetNuke ecosystem. In the years between2005 and the present, Snowcovered retained its first-mover advan-tage and strengthened its position as the leading marketplace forDotNetNuke extensions.

The one unfortunate side effect of having a marketplace which wascompletely independent from the creators and maintainers of the plat-form is that many opportunities for collaboration were missed. For anumber of years DotNetNuke Corporation looked at other successfulmarriages of product and channel ( ie. iPod/iTunes, etc... ) andbelieved there was a viable opportunity to elevate this ecosystem to

One aspect which has been critical tothe success of the DotNetNuke plat-form is the ability to enhance the corefunctionality with custom extensions

MAGAZINE42

DOTNETNUKE

the next level. But this would only be possible if we could combine thearious pieces of the puzzle in a seamless, cohesive manner.

I am very excited to have taken part in the public announcement thatDotNetNuke Corporation has acquired SnowCovered and Brice Snowwill be joining our team immediately as we embark on the next leg ofour journey. Since I am a firm believer in "not messing up a goodthing", I believe it will be beneficial for us to continue operatingSnowcovered in a manner which is consistent with Brice's pastphilosophy of exemplary service and developer enablement. I amconfident this marriage will result in greater opportunities fordevelopers of DotNetNuke extensions. It will also result in muchdeeper integration and collaboration which should lead to increasedmarket growth and prosperity for everyone. •

Stefan Kamphuis

Stefan Kamphuis werkt als zelfstan-dig Software Developer en heeftzich gespecialiseerd in ASP.NET De-velopment. Als DotNetNuke CoreTeam lid en hoofd van de DotNet-Nuke sectie binnen SDN, heeft hijeen voorkeur voor projecten waarDotNetNuke een deel van uitmaakt.Sinds 2008 is Stefan MVP metspecialisme ASP.NET.

DELPHI TIP:Remote of Lokaal?Cary Jensen schrijft in een artikel (in dit nummer van SDNMagazine) over het configureren van een efficiënte ontwikke-lomgeving met behulp van VMWare of Virtual PC. Zelf maak ikdaar ook veel gebruik van, en dan vooral in combinatie met eenRemote Desktop (Terminal Server) verbinding met deze virtuelemachine. Voor de software die ik daar dan draai is het somsvan belang te weten of ze in een remote sessie of in een lokalesessie draaien. Hetzelfde kan gezegd worden van bijvoorbeeldeen Citrix of Terminal Server sessie. Gelukkig is het niet moei-lijk om te zien of we remote of lokaal draaien: we kunnen ditaan Windows zelf vragen via de GetSystemMetrics(SM_REMOTESESSION) API aanroep. Een kort Delphiprogramma dat vertelt of we Remote of Local draaien is danook als volgt:

program Remote;{$APPTYPE CONSOLE}usesWindows;

function RemoteSession: Boolean;constSM_REMOTESESSION = $1000;

beginResult := GetSystemMetrics(SM_REMOTESESSION) <> 0;

end;

beginif RemoteSession thenwriteln('Remote')

else writeln('Local');readln

end.

The one-stop company for .NET development

TEST CENTER

http://www.4dotnet.nl

ZOEK

ZO GEZOCHT, ZO GEVONDEN

>>HOSTING PROVIDER REGIO AMSTERDAM

>

> ITDIRECTORY.NL IS EEN NIEUWE EN UNIEKE ONLINE GIDS MET EEN COMPLEET OVERZICHT VAN ALLE IT LEVERANCIERS.

VAN FREELANCE WEBDEVELOPERS TOT AUTOMATISERINGSBEDRIJVEN. JE VINDT HET SLIM, MAKKELIJK EN SNEL OP ITDIRECTORY.NL >>

partners van IT Directory.nl

http://www.itdirectory.nl

.NET Hassan Fadili & Ewald Hofman

baarheid welke Use Cases getest zijn van je applicatie.

Fig. 1: De User Story voor “Inloggen” met zijn taken

Fig. 2: Voorbeeld van een Test Case

Plan TestHet vastleggen van de Test Case work items heeft zorgt voortraceerbaarheid in TFS, maar VS 2010 ALM biedt meer. Er is eennieuwe applicatie toegevoegd, die zowel in de Ultimate als in de TestEssentials versie zit, genaamd “Test and Lab Manager” (MTLM). InFiguur 3 zie je een voorbeeld van deze applicatie. Met de MTLM kun

Testen met Visual Studio 2010 Ultimate Edition,

een absolute prestatie!

Work ItemsIn Visual Studio 2008 is het mogelijk om work items aan elkaar tekoppelen. Daarmee heb je enig inzicht in de afhankelijkheden tussenwork items, maar het is lastig om hier op te queryen of te rapporteren.In VS ALM 2010 heeft Microsoft de hiërarchische work itemsgeïntroduceerd. Ook hiermee kun je work items aan elkaar koppelen,maar nu heeft deze koppeling ook een betekenis. Het voordeel wordtduidelijk in het volgende voorbeeld.

In de Agile Process Template is er een work item van het type UserStory beschikbaar, die je gebruikt om een Use Case te definiëren.In dit voorbeeld wil de klant de Use Case “Inloggen” hebben. Om deUse Case vast te leggen maak je een nieuw work item aan van hettype User Story. Deze Use Case registeren we nu via het work itemtype User Story in TFS. De implementatie van deze Use Case bestaatvooor het ontwikkelteam uit een aantal taken, zoals het maken vaneen ontwerp, de code aanpassen en de Use Case testen. Deze takenzouden we in VSTS 2008 als losse work items opvoeren. In VS ALM2010 heeft de User Story een tabblad, waarop je de taken kanopvoeren waaruit de User Story bestaat. In Figuur 1 is te zien dat deUser Story “Inloggen” is aangemaakt en dat deze geïmplementeerdwordt door de taken “Maak design”, “Code aanpassen” en “Testenuitvoeren”. Deze taken zijn ook work items, maar maken in tegenstel-ling tot TFS 2008 echt onderdeel van de User Story uit.

Aan een User Story kun je ook een test scenario koppelen. Daarvooris er binnen VS 2010 een ander nieuw work item type geïntroduceerd,namelijk Test Case. In een Test Case work item, kun je de stappenvoor het uitvoeren van de test opvoeren. Figuur 2 laat zien hoe eenTest Case er uit ziet.

Bij de Test Case kun je nu ook zien bij de Tested User Stories op welkeUse Case(s) het test scenario van toepassing is. Hierdoor is traceer-

Visual Studio ALM 2010 heefthiërarchische work items

Microsoft heeft Visual Studio Application Lifecycle Management 2010 (VS ALM 2010) gebouwdop basis van een aantal objectives; waaronder “No More No Repro”, “No More No Butterfly” en“No More No Regression”. Deze objectives houden in:• dat een ontwikkelaar altijd het scenario moet kunnen naspelen (No More No Repro)• dat wijzigingen geen ongewenste gevolgen hebben ergens anders (No More No Butterfly)• dat je in staat bent om snel je wijzigingen te valideren (No More No Regression).Dit artikel beschrijft hoe Microsoft dit met de nieuwe versie van Visual Studio ALM heeftgerealiseerd. Voor dit artikel is gebruik gemaakt van Beta 2, in de uiteindelijke RTM versie kanop een aantal punten afwijken.


.NET

je de user interface van de applicatie onder test brengen. Indien detester fouten vindt in de applicatie, kan hij een schat aan informatie inTFS bij de bug opslaan; waaronder de intellitrace log, screen prints enzelfs een video-opname van de acties die de tester heeft gedaan.

Fig. 3: Testing Center in Plan modus

Dit scherm ondersteunt de verschillende stappen van een tester. Alstester begin je met het maken van een plan voor een bepaald tijdvak,bijvoorbeeld een iteratie. In dit plan geef je aan welke testen je gaatuitvoeren en wie dat gaat doen. Vanuit dit scherm heb je een aantalkeuzes om testen toe te voegen aan je plan. Je kunt allereerst vanuitdit scherm bestaande Test Cases toevoegen met de Add knop op detoolbar, maar ook een nieuwe Test Case (New knop) aanmaakt. Jekunt ook op basis van een query Test Cases aan je plan toevoegen.Denk daarbij aan alle Test Cases voor een iteratie (in figuur 3 “Alle tes-ten van Iteratie 1”). Als laatste kun je een user story aan je plantoevoegen (in het figuur 3 “27: Inloggen”). Het Test Center zal dan alleTest Cases voor de user story tonen. Welke methode je ook kiest, hetresultaat is een set van Test Cases voor je testplan.

TestJe hebt nu een aantal Test Cases gedefinieerd die je gaat uitvoeren.Om deze uit te voeren, schakel je naar de Test modus door boveninop Test te klikken. Je ziet in Figuur 4 nu dezelfde Test Cases, maar numet andere mogelijkheden. In deze modus kun je de ingeplande TestCases uitvoeren.

Als je de Test Case uitvoert, dan wordt de Manual Test Runner (MTR)

opgestart (Figuur 5). Dit scherm toont de gedefinieerde stappen vande Test Case. Je doorloopt de stappen van de test en bij elke stapgeef je aan of het resultaat van de stap voldoet aan de verwachting.

Fig. 5: Manual Test Runner

Indien een van de stappen niet voldoet aan de verwachtingen, dan wilje dat als tester kenbaar maken aan het ontwikkelteam. In VS 2008zou je een bug aanmaken en daar een screendump als attachmentaan koppelen. Extra informatie kun je in de description opgeven. MetVS 2010 ALM gaat dit veel eenvoudiger. Vanuit de MTR kun je eenwork item van het type Bug aanmaken. Aan deze bug wordt alleinformatie toegevoegd, die de MTR heeft verzameld: zoals eenscreenshot die je kunt maken vanuit de MTR, de systeem informatieen een beschrijving van de stappen die je hebt doorlopen.Indien je een Test Case start, dan krijg je (zoals in Figuur 6 te zien) devraag of je de Action Recording wilt starten. Als je voor deze optiekiest, dan registreert de MTR alle acties die je doet. Een volgende keerdat je Test Case uitvoert, kun je deze recording gebruiken om de stap-pen automatisch uit te voeren. Een mooie toepassing hiervan is bij-voorbeeld, dat de ontwikkelaar bij bugfixing de test kan laten uitvoeren,zoals de tester dat heeft gedaan. Dit zorgt ervoor dat het uitvoerenvan de Test Case zeer snel is en dat de handelingen identiek verlopenals bij de tester.

Fig. 6: Starten van een Test Case

CollectorsAls je naar de properties van het plan gaat, dan kun je de detailswijzigen. Dit artikel beperkt zich tot de “Test settings”. Met de testsettings kun je onder andere de collectors aangeven. In Tabel 1 kunje zien welke collectors er zijn en welk doel ze hebben.

Test and Lab Manager voor hetbeheren van Test Plannen

Manual Test Runner kan extra info aande bug toevoegen

Fig. 4: Testing Center in Test modus

MAGAZINE46


Installerenis voor fools.

www.barnsten.com

Streamenmet dietools!

C++Builder

Delphi

RADStudio

InterBaseDBArtisan

DelphiPrism

RapidSQL

DBOptimizer

en meer!

Embarcadero ToolCloud

Voor al je development & database tools.

ChangeManager

ER/Studio

Tabel 1: Een lijst van de mogelijke collectors

ConclusieGezien de nieuwe test features die in dit artikel besproken zijn, kan ergeconcludeerd worden dat de nieuwe versie van Visual Studio 2010,veel toegevoegde waarde zal hebben voor het uitvoeren van functio-neel testen van de applicaties. Met behulp van o.a. Test Automationen Test Impact Analyses, is test discipline niet meer een bijzaak bin-nen een project, maar wordt het ingezet om kwalitatief beter applica-ties op te leveren. De Visual Studio Ultimate objectives, waaronder“No More No Repro”, “No More No Butterfly” en “No More NoRegression”, hebben allemaal een plekje gekregen in het product.De traceerbaarheid van de requirements en de testen die ermee

gemoeid zijn maken hetgeen opgeleverd gaat worden voorspelbaar-der. Uiteraard zal dit krachtiger zijn als het vroegtijding in het projectmeegenomen wordt. •

MAGAZINE

Collector Omschrijving Action Recording and Action Log

ASP.NET Client Proxy forIntelliTrace and Test Impact

Verzamelt de stappen die de tester uitvoert,zodat je de stappen die zijn doorlopen in detekst kunt zien (Action Log) en de test laterterug kunt spelen (Action Recording)

Proxy om de http calls van de client naar deserver te onderscheppen ten behoeve vande IntelliTrace en/of de Test Impact

Event Log Verzamelt alle data die de applicatie naarde event log schrijft

IntelliTrace Verzamelt alle data t.b.v. IntelliTrace. Zielater in dit artikel

Network Emulation Maakt het mogelijk een netwerk na tebootsen, zoals een Dial-Up verbinding

System Information Verzamelt de system informatie tijdens detest

Test Impact Verzamelt data t.b.v. Test Impact. Zie laterin dit artikel

Video Recorder Neemt de test op als een video

ASP.NET Profiler Verzamelt profiling data voor een ASP.NETapplicatie t.b.v. optimalisatie performance

.NET

Ewald Hofman

Ewald Hofman is senior consultantbij Avanade (http:// www.avan-ade.com) en MVP Team System.Zijn blog is te vinden ophttp://www.ewaldhofman.nl

Hassan Fadili

Hassan Fadili is Lead Architect enTeam System Specialist bij DetrioConsultancy B.V. Hij is tevens MVPVisual Studio ALM, DotNed be-stuurslid en INETA-Europe Mem-ber/Speaker. Hassan houdt zijnblog op: http://hassanfad001.blog-spot .com en bereikbaar per E-mailop: [email protected] en/of [email protected].

http://www.barnsten.com

INFORMATIONWORKER Willem Oosterhof

gepresenteerd. Op basis van de gekozen tag worden de items diehieronder vallen getoond; items met als metadata Amsterdam, wordenzowel getoond als Europa, Nederland en Amsterdam zijn geselecteerdin deze boom.

Tenslotte kan de metadata centraal beheerd worden. Via de 'TermStore Management Tool' kan de begrippenboom vooraf wordenopgezet en kunnen synoniemen en vertalingen worden toegevoegd.Tevens is het mogelijk om termen die vaak voorkomen in anderemetadata bomen over te hevelen naar de centrale begrippenlijst.Ook kunnen de (beheer & bijdrage) rechten op de taxonomie bomencentraal worden beheerd. Bovendien kan dezelfde begrippenlijst(compleet en/of gedeeltelijk) worden hergebruikt in verschillendeSharePoint omgevingen: managed metadata. De eerder genoemdevoordelen kunnen dus via een centraal beheerde oplossing wordeningezet in meerdere sites!

De omvangrijke (out-of-the-box) taxonomie functionaliteit zal voor veleklanten een goede oplossing bieden. Belangrijke aandachtspunten bijeen uitrol zijn - net als bij een SharePoint implementatie - een grondigeanalyse van de eisen en wensen van de klant en voldoende aandachtvoor de (beheer)organisatie, training en richtlijnen ('governance').Het alleen beschikbaar stellen van een term store zal namelijk nietresulteren in een begrippenlijst die door de gebruikers ook daadwer-kelijk geaccepteerd en gebruikt wordt. Het is daarom aan te raden omklein te beginnen en door middel van pilots en Proof-of-Concepts uitte groeien tot een volwaardige taxonomie. Met een goed groeimodelen voldoende oog voor governance staat niets een positieve ontvangstvan de term store (en andere SharePoint 2010 functionaliteit) door deeindgebruikers in de weg! •

SharePoint out of the boxTaxonomie in SharePoint 2010

Kijkend door mijn functionele bril is SharePoint

2010 op meerdere vlakken een verbetering ten

opzichte van de MOSS 2007. Hierbij zie

ik onder andere de mogelijkheden rond

dossiervorming (met document sets, unieke

Document ID’s en vernieuwde archiveer func-

tionaliteit), een verbetering van de web 2.0

functionaliteit (zoals bij wiki's, rating en tagging)

en de uitgebreide workflow mogelijkheden.

Toch ben ik vooral enthousiast over de nieuwe functionaliteit van detaxonomie: een begrippenlijst die als boomstructuur gebruikt kanworden. Veel klanten willen items voorzien van metadata om devindbaarheid en de weergave te verbeteren. Hierbij wil de klant ookvoorkomen dat een redacteur talloze en eindeloze invoervelden moetdoorlopen bij het plaatsen van een item. In MOSS 2007 is er geen(out-of-the-box) boomstructuur met begrippen beschikbaar. In 2010is dit opgelost met de 'term store' (Nederlandse term is nog niet be-kend...). Deze term store heeft meerdere voordelen. Ten eerste kande classificatie van items plaatsvinden via een boomstructuur. Determen worden hierdoor gegroepeerd getoond, zoals landen, techno-logieën en producten. Het is ook mogelijk om een deel van de boomte gebruiken (dus bijvoorbeeld alleen de landen in Europa). Met behulpvan de begrippenboom kan de auteur van een item intuïtief en snelde juiste keywords selecteren in plaats van het doorakkeren van ver-schillende lijsten met (vaak) niet relevante termen. Het is bijvoorbeeldook mogelijk om via type-ahead trefwoorden in te typen, waarbijSharePoint al na in intypen van de eerste letters, de trefwoorden invult.

Ten tweede kan de begrippenlijst niet alleen worden toegepast oplijsten en documenten, maar ook op personen en externe pagina's.Profieleigenschappen van personen (in de My Site) kunnen gebaseerdworden op termen uit de centrale begrippenlijst. Zo kan de eigenschap'Specialisaties' bijvoorbeeld gebruik maken van de technologieënboom binnen de term store. Tevens kunnen pagina's buiten deSharePoint site voorzien worden van metadata (à la Delicious) uit determ store. Deze externe pagina's en tags worden vervolgens via deMy Site met collega's gedeeld.

Ten derde is de taxonomie goed geïntegreerd met alle SharePointfeatures. Zo kunnen zoekresultaten worden verfijnd door middel vande centrale begrippenlijst. Ook kunnen personen gezocht en gevon-den worden op de tags die ze hebben gebruikt. Daarnaast is hetmogelijk om door lijsten en bibliotheken heen te navigeren via demetadata. In de linker navigatiebalk kan de navigatieboom worden

Willem Oosterhof

Willem Oosterhof is SharePointConsultant bij de afdeling Informa-tion Worker Soluttions van Macaw.In deze rol helpt hij sinds 2003 be-drijven bij het implementeren vanSharePoint oplossingen. Willemheeft zich vooral gespecialiseerd ingovernance en het vertalen vanbusiness wensen naar functionele

requirements en SharePoint oplossingen.

MAGAZINE48

DELPHI Cary Jensen

Here is what I observed: The Fields in an open DataSet changed orderat runtime. Specifically, a Field that was originally in the zeroethposition (DataSet.Fields[0]) at the time that I opened the Dataset, wasin different position in the Fields array a short time later. I discoveredthis behavior when an exception was raised as a result of my attemp-ting to programmatically read the integer value of the Field that Icreated in the first (zeroeth) position in my DataSet. Between the timeI created the DataSet, and the execution of my code, the integer fieldhad moved. What happened wasn't magic. The Fields didn't changeposition by themselves, nor did they change based on anything I didin my code. What caused the Fields to physically change position inthe DataSet was that the user had changed the order of the Columnsin a DBGrid to which a ClientDataSet was attached (through a Data-Source component, of course). The user's ability to change the posi-tion of the Columns in a DBGrid, by the way, is the default behavior ofa DBGrid.

Besides being interesting (I kind of assumed that once a DataSet wasopened, the position of the Fields in the Fields array was pretty muchset), this behavior is the potential source of intermittent exceptions,the type that are particularly difficult to track down. It turns out thatthis behavior, which I've never seen described before, has beenaround since Delphi 1. (Actually, I discovered this effect in Delphi 7,Delphi 2007, and Delphi 2010. However, I understand that the under-lying source of this behavior has been around since Delphi 1, thoughI have not confirmed this.)I created a very simple Delphi application that demonstrates this effect.It consists of a single form with one DBGrid, a DataSource, a Client-DataSet, and a Button. The ClientDataSet is bound to the DBGridthrough the DataSource. The OnCreate event handler of this formlooks like the following:

procedure TForm1.FormCreate(Sender: TObject);

begin

with ClientDataSet1.FieldDefs do

begin

Clear;

Add('StartOfWeek', ftDate);

Add('Label', ftString, 30);

Add('Count', ftInteger);

Add('Active', ftBoolean);

end;ClientDataSet1.CreateDataSet;

end;

Listing 1: FormCreate

Button1, which is labeled Show ClientDataSet Structure, contains thefollowing OnClick event handler.

procedure TForm1.Button1Click(Sender: TObject);

var

sl: TStringList;

i: Integer;

begin

sl := TStringList.Create;

try

sl.Add('The Structure of ' + ClientDataSet1.Name);

sl.Add('- - - - - - - - - - - - - - - - - ');

for i := 0 to ClientDataSet1.FieldCount - 1 do

sl.Add(ClientDataSet1.Fields[i].FieldName);

ShowMessage(sl.Text);

finally

sl.Free;

end;

end;

Listing 2: ClientDataSet Structure

To demonstrate the moving field effect, run this application and clickthe button labeled Show ClientDataSet Structure. You should seesomething like that shown in Figure 1.

Next, drag the Columns of the DBGrid to re-arrange the display orderof the fields. Click the Show ClientDataSet Structure button onceagain. This time you will see something similar to that shown inFigure 2.

What is remarkable about this example is that there is an apparenteffect on the position of the Fields in the ClientDataSet, such that thefield that was in the ClientDataSet.Field[0] position at one point is notnecessarily there moments later. And, unfortunately, this is notdistinctly a ClientDataSet issue. I performed the same test with BDE-based TTables and ADO-based ADOTables and got the same effect.

It turns out that this behavior has three contributing factors. These are• A DBGrid connects to a DataSet through a DataSource• The DBGrid permits the user to move columns at runtime• The Columns of the DBGrid are dynamic, meaning that they are

created by the DBGrid at runtime

I've been working with Delphi since day 1, with particular emphasis on database development.As a result, it's not often that I encounter a fundamental behavior of data-related componentsthat catches me off guard. Well, it happened last week. And what I observed may be the sourceof a bug in a large number of Delphi database applications.

Shifting TFieldsin DataSets Bound to DBGrids


DELPHI

Fig. 1: First Structure Order

Fig. 2: Second Structure Order

If you programmatically refer to the Fields of a DataSet connected toa DBGrid in which the preceding three conditions exist using a literalindexer, your application can raise an exception, or produce inaccu-rate results, if the user moves one or more of the Columns in thatDBGrid. In the following section I will consider several solutions to thisproblem.

There Are Several SolutionsThere are two relatively simply steps you can take to eliminate thisbug. Either you can create persistent Columns in your DataSet, or youcan prevent the user from moving the DBGrid's Columns. Creatingpersistent columns can be done it design time or runtime. To do it atdesign time, add the Columns using the Columns Editor. Display theColumns Editor by right-clicking the DBGrid and selecting ColumnsEditor or by clicking the ellipsis in the Columns property of the DBGridin Object Inspector. If your DataSet is Active, you can click the Add AllFields button in the Columns Editor toolbar. Otherwise, add one ormore Columns and set their FieldName property in the PropertyEditor. To create persistent Columns at runtime, use the Add orCreate methods of the DBGrid's Columns property. You can then setspecific properties of the added or created Columns.You prevent a user from moving the Columns of a DBGrid by removingthe dgResizeColumn flag from the Options property of the DBGrid.While this approach is effective, it eliminates a potentially valuable userinterface option. Furthermore, removing this flag not only restrictscolumn reordering, it prevents column resizing. (To learn how to limitcolumn reordering without removing the column resizing option, seehttp://delphi.about.com/od/adptips2005/a/bltip0105_2.htm.)

The second workaround is to avoid referring to a DataSet's Fields

based on a literal indexer to the Fields array (since this is the essenceof the problem). In order words, if you need to refer to the Count fieldin the preceding code sample, don't use ClientDataSet1.Fields[2]. Solong as you know the name of the Field, you can use something likeClientDataSet1.FieldByName('Count').

There is one rather big drawback to the use of FieldByName, howe-ver. Specifically, this method identifies the field by iterating through theFields property of the DataSet, looking for a match based on the fieldname. Since it does this every time you call FieldByName, you shouldavoid this method in situations where the Field needs to be referencedmany times, such as in a loop that navigates a large DataSet.If you do need to refer to the field repeatedly (and a large number oftimes), consider using something like the following code snippet:

varCountField: TIntegerField;Sum: Integer;

beginSum := 0;CountField :=

TIntegerField(ClientDataSet1.FieldByName('Count'));ClientDataSet1.DisableControls; //assuming we're attached

to a DBGridtryClientDataSet1.First;while not ClientDataSet1.EOF dobeginSum := Sum + CountField.AsInteger;ClientDataSet1.Next;

end;finallyClientDataSet1.EnableControls;

end;end;

Listing 3: Using DataSet Fields

If you already have code that uses an indexer for the Fields array, andit works reliably, so long as the user does not move the Columns of thebound DBGrid, there is another solution. Change your code to usethe FieldByNumber method of the DataSet's Fields property. Thereare two interesting aspects to the use of FieldByNumber. First, youmust qualify its reference with the Fields property of your DataSet. Se-cond, unlike the Fields array, which is zero-based, FieldByNumbertakes a one-based parameter to indicate the position of the Field youwant to reference.The following is an updated version of the Button1 event handlershown earlier that uses the FieldByNumber method.

procedure TForm1.Button1Click(Sender: TObject);

var

sl: TStringList;

i: Integer;

begin

sl := TStringList.Create;

try

sl.Add('The Structure of ' + ClientDataSet1.Name +

' using FieldByNumber');

sl.Add('- - - - - - - - - - - - - - - - - ');

for i := 0 to ClientDataSet1.FieldCount - 1 do

sl.Add(ClientDataSet1.Fields.FieldByNumber(i +

1).FieldName);

ShowMessage(sl.Text);

finally

sl.Free;

end;

end;

Listing 4: Updated DataSet Structure

MAGAZINE50

DELPHI

For the sample project, this code produces the following output,regardless of the orientation of the Columns in the associated DBGrid.This can be seen in Figure 3.

Fig. 3: Third DataSet Structure Order

There is a third solution, but this is only available when your DataSet isa ClientDataSet, like the one in my sample project. In those situations,you can create a clone of the original ClientDataSet, and it will have theoriginal structure. As a result, whichever Field was created in thezeroeth position will still be in that position, regardless of what a userhas done to a DBGrid that displays the ClientDataSet's data. Note that

I am not suggesting that you should reference Fields in a DataSet usinginteger literals. Personally, the use of a Field variable that gets initiali-zed through a one time call to FieldByName is more readable, and isimmune to changes in the physical order of a table's structure (thoughnot immune to changes in the names of your fields!).

Wrap UpThere are two final points I want to make. First, the actual structure ofthe underlying data is not affected. Specifically, if, after changing theorder of the Columns in a DBGrid, you call the SaveToFile method ofa ClientDataSet bound to that DBGrid, the saved structure is the ori-ginal (true internal) structure. Similarly, if you assign the Data propertyof one ClientDataSet to another, the target ClientDataSet also showsthe true structure (which is similar to the effect observed when asource ClientDataSet is cloned).

Similarly, changes to the column orders of DBGrids bound to othertested DataSets, including TTable and ADOTable, do not affect thestructure of the underlying tables. For example, a TTable that displaysdata from the customer.db sample Paradox table that ships withDelphi does not actually change that table's structure on disk (norwould you expect it to). The second point is that this is not a bug ineither the TDataSet or TDBGrid classes. This is how these classeswere designed to work. And although this behavior can introduce bugsin your applications, this is because we were not aware of this beha-vior until now. And, you now know about this behavior, as well as howto prevent it from causing exceptions in your Delphi applications. •


http://www.oosterkamp.nl

MAGAZINE52

SharePoint EvolutionsMet meer dan 70 sessies voor IT Pro’s/Developers/Designers/InformationWorkers/Business Adoption en Power Users en een Deep dive Level 400 track isdeze conferentie een absolute aanrader voor iedereen die met SharePoint 2010aan de slag wil. Van 19 tot en met 21 april 2010 in Londen!. De sprekerslijst isfenomenaal! SDN DIWUG is er ook bij. Mirjam van Olst zal er presenteren enMarianne van Wanrooij kom je in de zaal tegen!

The Dutch Information Worker User Group (DIWUG) and the Soft-ware Development Network (SDN) produced a free SharePointeMagazine with a lot of interesting articles on a wide variety oftopics from an impressive group of international authors.

• The SharePoint 2010 Enterprise - Sjoerd van Lochem• Customizing the SharePoint Ribbon - Marianne van Wanrooij• Visual Studio extensions or a manually build solution? - Niels Loup• Working With Data in SharePoint Designer 2010 - Laura Rogers• Sandboxed Solutions in SharePoint 2010 – Mirjam van Olst• New ECM features in SharePoint 2010 – Robert van Son• Creating new Visual Experiences with Visio Services - Toni Frankola• How to guides on Visio Services - Toni Frankola• A SharePoint User eXperience – Sandra de Ridder• Introduction to the Business Connectivity Services – Nick Swan• SharePoint 2010 Client Object Models – Ton Stegeman• Understanding Identity in SharePoint 2010 - Michiel van Otegem• Happy Together in 2010 - Dux• SharePoint 2010 Chart Web Part - Agnes Molnar• Enrich your SharePoint 2010 portal by integrating SAP applications -

Cyrille Visser, Johan Kroese and Huub Montanus• SharePointComic – Dan LewisThe magazine can be downloaded in high-res or for use on eReaders atwww.sdn.nl/FreeMagazine.

DIWUG FreeSharePointeMagazine

http://www.sdn.nl/FreeMagazine

Top 10 SharePoint 2010 featuresSharePoint 2010 biedt veel nieuwe features en verbeteringen die hetonderzoeken waard zijn! Hieronder onze top 10 waar je nog veel over zultgaan horen en zal lezen in de komende SDN events en magazines!1. Ribbon2. Content Organizer3. Managed Metadata Service4. Service Applications5. FAST6. ActivityFeed7. Visual Studio 2010 tools8. Sandboxed Solutions9. Silverlight Web Part10. Claims based identity

Lees meer in het Free SharePoint 2010 eMagazine!(http://www.sdn.nl/FreeMagazine)

Top 10 Best Practicesvoor MOSS 2007Wellicht inkoppertjes,maar nog steeds veel gemaakte fouten in de praktijk.Een top 10 waar je MOSS installatie aan moet voldoen wil je later niet al teveel problemen tegenkomen. Zeker als je aan een upgrade naar 2010 zit tedenken...1. Gebruik SharePoint solutions (.wsp files) voor het deployen

van maatwerk oplossingen2. Neem SQL Server serieus3. Pas geen standaard SharePoint files aan4. Maak geen gebruik van web gardens5. Bouw je farm op 64-bit servers6. Houd je content databases klein7. Doe een least privilege installatie8. Gebruik antivirus software voor SharePoint9. Zorg voor een goed backup en restore plan en test dit ook10. Houd bij het ontwerpen van de logische architectuur van je SharePoint

omgeving rekening met de SharePoint Software Boundaries(http://technet.microsoft.com/en-us/library/cc262787.aspx)

Nieuwe SharePoint MVPin Nederland!Sinds 1 januari 2010 telt Nederland een nieuwe SharePoint MVP! NaastWaldek Mastykarz, Ton Stegeman en Gustavo Velez is nu ook Mirjam vanOlst MVP voor SharePoint Server.Hier de Dutch MVP's waar je met je SharePoint vragen terecht kan. Woutervan Vugt hoort daar uiteraard ook bij, als is hij om vreemde wijze nog steedsVSTO MVP! Je zult ze veel tegen komen bij SDN DIWUG events of met eenartikel in het magazine!

Waldek Mastykarz,SharePoint WCM developer, Imtech ICTMVP SharePoint Server Developmentblog: http://blog.mastykarz.nl/Twitter : @waldekm

Ton Stegeman,SharePoint Architect PGGMMVP SharePoint Server DevelopmentBlog: http://www.tonstegeman.com/blogTwitter: @tonstegeman

Mirjam van Olst,SharePoint Architect, MacawMVP SharePoint ServerBlog: http://www.SharePointChick.comTwitter: @MirjamVanOlst

Gustavo Velez,SharePoint Architect, AvanadeMVP SharePoint ServerBlog: http://www.gavd.net/servers/default.aspx(spaanstalig)

Wouter van Vugt,SharePoint trainer, Code CounselMVP VSTOBlog: http://blogs.code-counsel.net/Wouter/default.aspxTwitter: @woutervugt


GENERAL Maarten Metz & Freek Leemhuis

KeuzesWat zijn belangrijke leergebieden voor ontwikkelaars die tot decategorie ‘kickass developer’ willen behoren? Daar verschillen demeningen nogal over. Over het algemeen leggen bedrijven de nadrukvooral op (inter)persoonlijke vaardigheden en platformspecifiekevaardigheden of 'technologieën'. Alhoewel die vaardigheden zeker ookbelangrijk zijn, richt dit artikel zich met name op twee soorten kennisdie over het algemeen duurzamer zijn: domeinkennis en algemenesoftware engineering vaardigheden. Veel software ontwikkelaars den-ken bij software engineering vooral aan kennis van specifieke techno-logieën: Java, .Net, C++, HTML, Javascript, Linux, Windows, etc.Kennis van die technologieën is zeker nodig om software te kunnenontwikkelen.

Maar is dat werkelijk de bepalende factor om een goede ontwikkelaarte worden? Ben je echt voornamelijk code aan het produceren als je

software ontwikkelaar bent? 100% van de tijd? Veelal ligt bij het ont-wikkelen van software de nadruk op productieverbetering. De manierom dat te bereiken wordt vaak gezocht in technische oplossingenzoals kennis van frameworks. Zou je productiever worden in schakenals je traint in het sneller bewegen van de schaakstukken?

Frederick Brooks schreef in de jaren 80 een klassiek artikel: ‘No silverbullet – Essence and Accidents of software engineering’ (Brooks,1987). Volgens Brooks is het moeilijkste deel van ons werk nietzozeer het vertalen van concepten in ons hoofd naar de technologieënwaarmee we die ideeën uitdrukken: ‘I believe the hard part of buildingsoftware to be the specification, design, and testing of this conceptualconstruct, not the labor of representing it and testing the fidelity of therepresentation. We still make syntax errors, to be sure; but they arefuzz compared with the conceptual errors in most systems.’ Wat soft-ware engineering in essentie zo moeilijk maakt volgens Brooks zijn‘complexity, conformity, changeability, and invisibility’.

Complexity – zelfs als je een perfecte DSL (Domain Specific Langu-age) tot je beschikking hebt blijft ons werk ingewikkeld omdat derelaties tussen entiteiten nog steeds precies gedefinieerd moetenworden, excepties nog steeds exact en volledig geïdentificeerdmoeten worden en er nog steeds geanticipeerd moet worden op allemogelijke ‘state transitions’.

Conformity – zelfs als je een volledig nieuw systeem gaat ontwikke-len moet de software zich meestal conformeren aan allerlei beperkin-gen zoals: hardware omgeving, software omgeving, 3rd partycomponents, legacy data, etc.

Changeability – hoe succesvoller een applicatie is, hoe meer manie-ren er gevonden zullen worden om het te gebruiken, hoe groter dedruk wordt om het aan te passen in richtingen waar vooraf nooit opgeanticipeerd is.

Invisibility – zelfs het meest eenvoudige runtime gedrag van softwarewordt binnen de kortste keren absurd ingewikkeld als je het probeertte visualiseren. Kennis over runtime gedrag is dus bijzonder moeilijkover te dragen.

Je bent als software ontwikkelaar continu bezig om je allerlei gereed-schappen en technieken eigen te maken. De vaardigheid om snel en ef-fectief te leren is misschien wel de belangrijkste die je als ontwikkelaarhebt. Het belangrijkste gereedschap dat je hierbij gebruikt is je brein. Maarmaak je daar wel optimaal gebruik van? In de Kick Ass Development reekszullen we je aan de hand van modellen en praktijkvoorbeelden inzichtenen tips geven om je brein te refactoren voor optimaal rendement. Waar heteerste artikel in deze reeks zich vooral richtte op de vraag hoe je als soft-ware engineer te werk kunt gaan om kennis te vergaren richt dit artikelzich vooral op de vraag welke kennis belangrijk is. In een volgend deelvan deze serie zullen we ons vooral richten op een van de kernaktiviteitenvan software engineering: ’problem solving’.

De Kick Ass development reeks deel 2:

Kennisgebieden voor developers

MAGAZINE54

GENERAL

Alistair Cockburn verwoordde de complexiteit in ons vakgebied op deagile 2009 conference als volgt:

Ons vak is dus in essentie complex en kennis van verschillendeframeworks helpt maar mondjesmaat in het omgaan met diecomplexiteit. Sterker nog: een veelvoud van talen, frameworks en toolsdie regelmatig van versie veranderen maken het er niet makkelijker op!En dat terwijl ze vaak juist gemaakt zijn met de bedoeling om tijd tebesparen. Tijd die vervolgens gebruikt kan worden voor het oplossenvan de essentiële problematiek. Hoe die essentiële problemen danopgelost kunnen worden wordt vaak in het midden gelaten. Het lijkt ersoms op dat frameworkbouwers, opleiders, maar vaak ook werkge-vers en klanten veronderstellen dat die kennis al aanwezig -, ofminder relevant is.

Algemene engineering vaardighedenWat betekenen die conclusies van Brooks en Cockburn voor ons alssoftware engineers? Ze helpen wellicht om dat nieuwe productivi-teitsverhogende framework - waarmee je zogenaamd met 4 annota-ties en 3 muiskliks een volledige webapplicatie kunt bouwen - inperspectief te zien.

De focus op methodieken, technologieën en (inter)persoonlijke vaar-digheden heeft veel vruchten afgeworpen. De balans echter is naarons idee soms zoek en we pleiten in dit artikel daarom voor eenherwaardering van algemene software engineering vaardigheden.Algemene software engineering vaardigheden zijn niet gericht op eenspecifieke taal of platform. Het is kennis die altijd van pas komt of jenou met java, .NET, Oracle, flex, C, C++, Ruby of wat voor taal danook werkt. Deze kennis gaat vrij lang mee, is niet of nauwelijksonderhevig aan trends en daarom een uitstekende investering voorkick-ass developers.

SWEBOKIEEE en ACM vakmensen uit de theoretische en uit de praktische hoek(o.a. McConnell, Kruchten, Sommerville, Pressman, etc.) hebben jarengeleden wereldwijde consensus bereikt over wat software enginee-ring inhoudt. Hun streven was een 'Body Of Knowledge' te definiërenwaarmee het software engineering vakgebied geprofessionaliseerdwordt. Wat ze o.a. opgeleverd hebben is 'the guide to the SoftWareengineering Body Of Knowledge (SWEBOK)'. De SWEBOK richt zichop algemeen aanvaarde kennis en laat daarmee de nieuwste- maarook de heel specifieke vormen van software ontwikkeling onberoerd.In de woorden van de SWEBOK: 'The generally accepted knowledgeapplies to most projects most of the time, and widespread consensusvalidates its value and effectiveness.' Relevante deelgebieden ('SWE-

BOK knowledge areas') die onderscheiden worden zijn: requirements,design, construction, testing, maintenance, configuration manage-ment, management, process, tools and methods en quality.

Deze deelgebieden worden weer verder opgesplitst in subdeelge-biedjes (bouwstenen). Tabellen maken duidelijk welke literatuur je zoumoeten lezen om jezelf een bouwsteen eigen te maken. In feite is deSWEBOK dus een taxonomie waarvan de ‘leafs’ gevuld zijn met ver-wijzingen naar ‘best practices’ literatuur.

Ter illustratie zoomen we kort in op de ‘design knowledge area’. Dezeknowledge area is opgedeeld in: Software Design fundamentals, KeyIssues in Software Design, Software Structure and Architecture, Soft-ware Design Quality Analysis and Evaluation, Software Design Nota-tions en Software Design Strategies and Methods. De ‘Key Issues inSoftware Design’ subarea is vervolgens weer opgedeeld in: Concur-rency, Control and handling of events, Distribution of components,Error and exception handling and fault tolerance, Interaction and pre-sentation en Data persistence. Voor ‘Control and handling of events’wordt bijvoorbeeld verwezen naar hoofdstukken en paragrafen in‘Software Architecture in Practice’ (van Bass, Clements & Kazman),‘Object-Oriented Software Construction’ (van Meyer) en ‘SoftwareEngineering: Theory and Practice’ (van Pfleeger). In de ‘list of furtherreadings’ van de design knowledge areas staan nog vele andereinteressante verwijzingen zoals: ‘Refactoring’ en ‘Patterns of Applica-tion Architecture’ van Fowler, ‘Design Patterns’ van the gang of four,‘The 4 + 1 view model of architecture’ van Kruchten, Object OrientedDesign heuristics van Riel en ga zo maar door. Niet de minste boekenen een uitstekend uitgangspunt om op verder te bouwen!

Fig. 1: Impressie van de SWEBOK indeling

Deze deelgebieden worden weer verder opgesplitst in subdeel-gebiedjes (bouwstenen). Tabellen maken duidelijk welke literatuur jezou moeten lezen om jezelf een bouwsteen eigen te maken. In feite isde SWEBOK dus een taxonomie waarvan de ‘leafs’ gevuld zijn metverwijzingen naar ‘best practices’ literatuur.

Gebruik van de SWEBOKDe SWEBOK kan op allerlei manieren gebruikt worden. In dit artikelbelichten we 3 manieren van gebruik: als hulpmiddel bij het zoekennaar ‘wat vind ik leuk in m’n vakgebied’, als hulpmiddel om lacunes invaardigheden op te sporen en als literatuurverwijzer.

Alistair Cockburn: “We’re solving pro-blems we don’t yet understand whichkeeps changing, creating solutions wedon’t yet understand which keepschanging, expressing ideas to an inter-preter unforgiving of errors in langua-ges we don’t understand which keepschanging and making decisions withlimited resources where every choicehas economic consequences.”


GENERAL

Allereerst helpt de SWEBOK om inzicht te krijgen in wat je leuk vindtin het software engineering vakgebied. Nadenken over je professioneletoekomst met een leeg vel papier voor je is een stuk moeilijker danmet de SWEBOK indeling bij de hand. Je zou er voor kunnen kiezende gebieden weg te strepen die je totaal niet aanspreken en in tezoomen op de gebieden die overblijven.

De SWEBOK kan je ook helpen bij het in kaart brengen van lacunesin je kennis. De SWEBOK geeft een zeer goed overzicht van het totalesoftware engineering landschap. Met de SWEBOK bij de hand is hetveel eenvoudiger om gebrek aan kennis op te sporen, te benoemenen in een groter geheel te beschouwen. Het wordt makkelijker om hetgebrek aan kennis op te heffen: je kunt de kennisgaten immerssneller opsporen en door de SWEBOK taxonomie zul je al vrij snel zienwelke aangrenzende kennisgebieden je al wel beheerst. Van daaruitkun je je kennis dan verder uitbreiden.

Daarnaast kun je de SWEBOK gebruiken als literatuurverwijzer. DeSWEBOK bevat verwijzingen naar allerlei boeken die hoog scoren inverschillende software engineering boekenlijsten. Bovendien is de kansheel groot dat je in de SWEBOK interessante artikelen en boeken vindtdie je nog niet kende. Aangezien het om 'generally accepted know-ledge' gaat is de leeftijd van de guide (5 jaar) geen bijzonder grootprobleem. Als je de SWEBOK hebt gebruikt om te bepalen waar jepassie in het vakgebied ligt, zijn de literatuurverwijzingen in degekozen deelgebieden uitstekende zelfstudie wijzers.

Minpunten en tekortkomingen van de SWEBOKDe SWEBOK wordt weleens gezien als het kroonjuweel van de tradi-tionele software engineering methodieken. Het lijkt gebaseerd te zijnop de veronderstelling dat alles gedocumenteerd moet worden (Rico,Sayani, Sone, 2009). Bovendien is veel literatuur waar naar verwezenwordt in de ‘requirements’-, ‘management’- en ‘proces’ deelgebie-den gebouwd op de waarden uit het rechterrijtje van de ‘manifesto forAgile Software Development’: processes, tools, comprehensive do-cumentation, contract negotiation and following a plan. Dit wordt deelsveroorzaakt door het moment waarop de SWEBOK is gecreëerd. DeSWEBOK reflecteert ‘the state of the practice’ rond de milleniumwis-seling. Hierdoor wordt nauwelijks aandacht besteed aan agile metho-dieken, maar bijvoorbeeld ook niet aan gedistribueerdeontwikkelteams en web-based development. Andere gebieden die nietopgenomen zijn in de SWEBOK, maar bijvoorbeeld wel vaak opge-nomen zijn in ‘university programs’ zijn o.a. Human computer inter-faces graphics and visualization, algorithms, databases andinformation management, safety and security, networks internet anddistributed systems, operating systems and middleware & hardwareand computer engineering (Pyster, Turner, Henry, Lasfer, Bernstein,2009).

De waarde van SWEBOKOndanks de kritiek op de SWEBOK, is het op dit moment de bestetaxonomie voor software engineering en een rijke bron van literatuur-verwijzingen. Er is ontzettend veel kennis over algemene softwareengineering aanwezig in het vakgebied maar die kennis is versnipperdin allerlei boeken en artikelen. De SWEBOK heeft die kennis netjesingedeeld en bij elkaar gebracht. De SWEBOK wordt actief onder-houden en de volgende versie wordt al in 2010 verwacht. Veel van deboeken en artikelen die in de 2004 versie genoemd werden zullen ookin de 2010 versie terugkomen omdat die algemene engineering ken-nis ook belangrijk is in een ‘agile’ tijdperk.

Als ontwikkelaar heb je kennis van technologieën nodig om je vak uitte kunnen oefenen, maar heb je kennis van algemene engineeringvaardigheden nodig om je vak goed uit te kunnen oefenen. Misschienken je het Spring framework niet in detail, maar weet je wel alles vanAspect oriëntatie en dependency injection. Misschien heb je nog nooit

gewerkt met Hibernate, maar ken je wel de belangrijkste problemen enoplossingen rondom Object Relational Mapping (ORM). Door deonderliggende kennis te beheersen overleef je het hoge tempo waarintalen en frameworks komen en gaan. Algemene software engineeringkennis overleeft langer dan specifieke implementaties. De SWEBOKhelpt om die algemene kennis te vinden.

DomeinkennisNaast de algemene engineering kennis wordt in ons vak domeinken-nis vaak onderbelicht. Domeinkennis wordt over het algemeen pas naje studie opgedaan, en wordt vaak bepaald door de omgevingen waarje als ontwikkelaar in beland. Als techneuten houden we ons graagbezig met techniek en denken daarom niet vaak na over een investe-ring in domeinkennis. Toch is het voor een ontwikkelaar handig omhier bewust mee om te gaan.

Domeinkennis is noodzakelijkOm software te schrijven voor een business domein moet eenontwikkelaar een solide grip hebben op de concepten en processenin dat domein. Gewapend met deze domeinkennis kan een ontwik-kelaar samen met teamleden een gemeenschappelijke 'taal' ontwik-kelen waarmee deze concepten en processen ook in code kunnenworden gevat. Door dit gebruik van wat Eric Evans (Evans, 2004) een'ubiquitous language' noemt kunnen veel misverstanden omtrent defunctionaliteit worden voorkomen. Veel ontwikkelaars zijn geneigd omzo snel mogelijk met programmeren te beginnen. Agile software de-velopment lijkt dat ook te stimuleren: lever snel software op, die je ver-volgens samen met de klant evalueert op geschiktheid. Wat hierbijvaak wordt vergeten is dat een verdieping in het domein een ontwik-kelaar kan helpen om effectiever en productiever te zijn door eerder dejuiste oplossingen te kiezen. Een eerste iteratie met werkende soft-ware die totaal niet aansluit bij het domein van de klant zal de pro-ductiviteit in volgende iteraties vrijwel zeker vertragen. Domeinkennishelpt bij het maken van designkeuzes, bij het kiezen van de juistebenamingen, en bij het op peil houden van de productiviteit.Daarnaast helpt domeinkennis bij het inleven in de eindgebruiker. Alsje niet precies begrijpt wat een gebruiker met de software wil bereikenis het meestal erg moeilijk - zo niet onmogelijk - om de juiste keuzeste maken bij het ontwerp van een oplossing. Een ander belangrijkvoordeel van domeinkennis is de verminderde afhankelijk van de be-schikbaarheid van domein experts - in veel projecten een bottleneck.Overigens zien we in de praktijk nog wel eens dat de focus op do-meinkennis en het vervatten ervan in code applicaties oplevert die nietvooruit te branden zijn. De focus op het modelleren van het domeinmoet hand in hand gaan met de benodigde software design skills diezorgen voor een applicatie met voldoende performance.

Domeinkennis helpt bij het scheiden van verantwoordelijkheidHet benadrukken van het domein kan namelijk ook helpen om eenduidelijke scheiding aan te brengen tussen de domein logica en on-dersteunende technische code. In projecten krijg je al snel te makenmet de al eerder genoemde 'accidentele' complexiteit. De kunst is omte blijven focussen op de essentiële problemen: de business proble-men die de software op moet lossen. Voor accidentele complexiteitbestaan vaak al oplossingen en frameworks die zichzelf al bewezenhebben in de praktijk. Domeinkennis maakt duidelijk wat bij het domeinhoort, wat niet en op welke manier. Door in het ontwerp van een sys-teem een duidelijk onderscheid aan te brengen tussen de domein-logica en de plumbinglogica, wordt het veel eenvoudiger om hetdomein te doorgronden, te begrijpen en te onderhouden. Dit iswaarom Eric Evans met zijn Domain Driven Design boek zo'n enormebijdrage heeft geleverd aan ons vakgebied.

Domeinkennis kan een strategisch voordeel opleverenNaast de al eerder genoemde voordelen kan domeinkennis ook voor-delen opleveren bij het verkrijgen van een klus of nieuwe baan.

MAGAZINE56

Klanten werken graag met mensen die begrijpen waar ze het overhebben en domeinkennis kan je daarom een voorsprong bieden tenopzichte van andere ontwikkelaars die zich liever beperken tot tech-nische onderwerpen. Bovendien heeft domeinkennis over het alge-meen een langere houdbaarheidsdatum dan technologische kennis.Verzekeringssoftware heeft bijvoorbeeld meestal een zeer beperkte le-vensduur, maar kennis van het domein verzekeringen kan zomaar jehele leven van pas komen. Laat het niet van toeval afhangen welkedomeinkennis je opbouwt, maar probeer je te richten op een domeindat je interesseert en dat toekomst heeft.

Wat is nu belangrijk?In zijn bestseller ‘the seven habits of highly effective people’ (Covey,1989) deelt Stephen Covey activiteiten in in een belangrijk/ urgent kwa-drant:

Fig. 2: Stephen R. Covey’s Time Management Quadrants

Door de focus op 100% inzet van mensen besteden veel IT-ers hetovergrote deel van hun leerinspanningen in kwadrant I. Men heeft detooling van het voorgaande project nog maar net onder de knie en denieuwe tooling in het nieuwe project dringt zich alweer op. Vooral in decommerciële sector ligt de nadruk vaak op het onder hoge druk snelopleveren van oplossingen. Er is nauwelijks tijd om er achter te komen‘waar de configuratievinkjes zitten’, laat staan om een goede, onder-houdbare oplossing te ontwikkelen. Tom DeMarco omschrijft dit ge-drag als template junkies: hectische activiteit wordt aangezien voorgezonde productiviteit(DeMarco, 2008). In de spaarzame overgeble-ven tijd ontsnappen ontwikkelaars naar kwadrant III en IV activiteiten.De tijd wordt dan gevuld met onbelangrijke activiteiten waar weinigdruk op zit en die je het gevoel geven dat je in ieder geval bezig bent.Volgens Covey richten effectieve professionals zich echter vooral opKwadrant II. Op kwadrant I hoef je je niet te richten; die activiteitendienen zichzelf wel aan. Door je op kwadrant II activiteiten te richtenzullen de crises echter afnemen.In zekere zin zou je kunnen zeggen dat specifieke technologieën zichbevinden in kwadrant I en III. Ze kunnen belangrijk of minder belang-rijk zijn voor het slagen van projecten, maar ze dringen zich in iedergeval op en je krijgt als ontwikkelaar al snel het gevoel dat je detooling van een project zo snel mogelijk onder de knie moet krijgen.Algemene engineering vaardigheden dringen zich minder op, zijn min-der urgent aanwezig, maar wel degelijk belangrijk. Het aanscherpenvan algemene engineering vaardigheden is overduidelijk een zeer be-langrijke, maar in het dagelijkse werk schijnbaar minder urgentevaardigheid. Het is een typische kwadrant II activiteit. Door je te con-centreren op algemene engineering vaardigheden zul je de specifieketalen en tools - die elk project weer in andere samenstellingen en ver-sies voorkomen - veel sneller onder de knie krijgen. Bovendien heb je

dan echt krachtig gereedschap in handen: gereedschap waarmee jede complexiteit die inherent is aan software engineering binnen deperken kunt houden.

TenslotteAlgemene software engineering vaardigheden helpen om zo goed mo-gelijk om te gaan met de complexiteit in ons vakgebied. Een investe-ring in algemene engineering vaardigheden rendeert veel langer daneen investering in een specifieke technologie of tool. Investeringen intalen en tools dringen zich echter veel meer op dan investeringen inengineering vaardigheden of domeinkennis. De reden daarvoor komttot uiting in de kwadranten van Covey. Een kickass developer zorgt dathij of zij de verschillende technologieën goed beheerst, maar probeertzich vooral algemene engineering vaardigheden eigen te maken. Alsje stevig geworteld bent in deze fundamentele kennis val je niet omals de wind uit een andere richting gaat waaien.

Referenties• Abran A. et al. Guide to the Software engineering body

of knowledge (SWEBOK). IEEE CS Press. (2004)• Brooks Fred P. "No Silver Bullet - Essence and Accidents

of Software Engineering". IEEE Software 20 (4): 10-19. (April 1987)• Covey, Stephen R. The 7 habits of highly effective people.

Pocket Books. (1989)• DeMarco, Tom et al. Adrenaline Junkies and Template Zombies.

Understanding Patterns of Project Behavior. Dorset HousePublishing, 2008

• Evans. Eric. Domain Driven Design. Tackling Complexity inthe Heart of Software. Addison-Wesley, 2004.

• Fowler, Chad. The Passionate programmer. Pragmatic Bookshelf,2009

• Pyster A., Turner R., Henry D., Lasfer L., Bernstein L.. “Master’sdegrees in software engineering: an analysis of 28 universityprograms”. IEEE Software 26 (5): 94 – 101. (September /October 2009)

• Rico D.F., Sayani H.H., Sone S.. The business value of agilesoftware methods:maximizing ROI with Just-in-Time Processesand Documentation. J.Ross (2009) •

GENERAL

Maarten Metz

Maarten Metz is een software ontwik-kelaar bij Logica. Hij heeft 10 jaar ITervaring in bit-, byte-, procedureel- enobject georiënteerde omgevingen.Zijn interesses gaan onder andere uitnaar software design, software con-

struction, software testing, de psychologie van software ontwik-keling en verder alles wat nodig is om een applicatie goed te latenwerken.


Freek Leemhuis

Freek is deelnemer bij IHomer enwerkt aan projecten als software de-veloper of architect. Hij is actief in soft-ware development sinds 1998 enheeft bijzondere belangstelling vooronderwerpen als OO, Domain Driven

Design, Agile technieken en kwaliteit van software. In zijn vrije tijdzoekt hij via Devnology (http://devnology.nl) gelijkgestemden omkennis en ervarin mee uit te wisselen.

UX Timmy Kokke

Composite Application GuidanceOm je hierbij te helpen heeft het Patterns & Practices team vanMicrosoft hiervoor de Composite Application Guidance geschreven.Deze handleiding/toolkit is bedoeld je te helpen bij het ontwikkelenvan enterprise applicaties in WPF of Rich Internet Applications, RIAs,in Silverlight. Er worden een aantal conventies, patterns en examplesin besproken die je helpen bij het ontwikkelen van Compositeapplicaties.

De Composite Application Guidance maakt gebruik van Unity, dedependency injection container van P&P. Één van de grote voordelenvan het gebruik van Unity is dat het ontkoppelen van een applicatiesimpeler wordt. Het defineren, of registreren, van objecten gebeurt opeen centrale plaats. Dependency injection containers zijn er in allerleisoorten en maten en je bent dan ook niet verplicht Unity te gebruiken,maar doordat deze ook is ontwikkeld door P&P is het gebruik binnende CAG wel het meest voor de hand liggend.Om het gebruik van de Composite Application Guidance te vereen-voudigen zijn er een aantal assemblies nodig; de Composite Applica-tion Library. Het Patterns & Practices team heeft deze beschikbaargesteld met sourcecode, voorbeelden en een referentie implementa-tie. Ze zijn te downloaden van http://shrinkster.com/19qe. Nadat dezegedownload en geinstalleerd zijn moeten ze gebuild worden. Dit iseenvoudig te doen door “Desktop & Silverlight - Open CompositeApplication Library.bat” te starten en de solution die geopend wordt tebuilden. De assemblies worden geplaatst in \CAL\Silverlight\Compo-site.UnityExtensions\bin\Debug.Aan de hand van een simpel voorbeeld wil ik laten zien hoe je jeapplicaties op een manier kunt opzetten zodat deze beter te onder-houden en te testen zijn. De applicatie wordt gemaakt in Silverlight enzou gebruikt kunnen worden om code snippets mee te beheren. Ik gaervan uit dat, als je tegen de eerder genoemde problemen bentaangelopen, je enige ervaring hebt met Silverlight of WPF. Je moet inelk geval bekend zijn met concepten als XAML, routed commands endatabinding.

De demo applicatieDe demo applicatie, “Snipz”, bestaat uit vier delen. Eén Server en drieclient projecten. Snipz is het project dat gestart wordt aan de client

zijde. Hier wordt alles geinitialiseerd en de dependency injectioncontainer gevuld. In dit project zit ook de Shell. De shell is de primairewindow waar de UI in zit. De UI wordt in de vorm van Views uit demodules gelezen en getoont in een Region.Het tweede project is Snipz.Edit. Dit is de voorbeeld module in dedemo applicatie. De module staat volledig op zichzelf en heeft geenenkele afhankelijkheid met het Snipz project. De module toont eeneditor voor de snippets.Snipz.API wordt gedeeld tussen Snipz en Snipz.Edit. In dit projectbevinden zich twee interfaces. Snipz.Edit gebruikt deze interfaces,maar ze zijn geïmplementeerd in Snipz. Unity wordt in Snipz.Editgebruikt om de interfaces te instanciëren. Hierdoor kan Snipz.Edit losvan de rest getest worden.Het vierde en laatste project is Snipz.Web. Dit is het server gedeeltevan de demo applicatie. Hier zouden services geplaatst kunnen wor-den die de data uit een database lezen. Om de demo applicatie sim-pel te houden heb ik dit niet geimplementeerd. De aspx pagina wordt

Modulaire applicaties in Silverlight

Fig. 1: Snipz Client

Weer kostte het bloed, zweet en tranen om de wijzigingen in de requirements van de klant doorte voeren in de applicatie. De halve architectuur moest hiervoor overhoop. Als je dit voorafgeweten had, had je de deadline misschien wel gehaald. Herkenbaar? Vooral nieuwere tech-nologieën zoals Silverlight en WPF kunnen je gemakkelijk in dit soort situaties doen belanden.Je applicatie modulair opbouwen had in een dergelijke situatie uitkomst kunnen bieden. Hetmodulair opzetten van een applicatie brengt een aantal grote voordelen met zich mee. Dooreen applicatie in verschillende modules op te zetten, worden de verschillende onderdelen min-der afhankelijk van elkaar. Separation of Concerns is eenvoudiger na te streven. Ook wordt hetgemakkelijker om met een team aan een applicatie te werken. De verschillende moduleskunnen, zonder afhankelijk te zijn van elkaar, ontwikkelt en onderhouden worden. Doordat er vantevoren nagedacht moet worden wat in welke modules moet gaan komen, wordt er beternagedacht over de architectuur van de applicatie en zul je in een later stadium minder snel vooronaangename verrassingen komen te staan.

MAGAZINE58

alleen gebruikt om de silverlight applicatie te tonen.

Het opzetten van de applicatie

Afbeelding 2: Nieuwe applicatie

Maak in visual studio een nieuw Silverlight project en geef deze eenpakkende naam. Als voorbeeld heb ik gekozen voor de naam Snipz.Selecteer hierbij het ASP.Net Web Site web project type. De solutiondie nu gemaakt is bestaat uit twee projecten. Één voor de client (Snipz)en één voor de server (Snipz.Web).Voeg in het Snipz project references toe naar:Microsoft.Practices.CompositeMicrosoft.Practices.Composite.PresentationMicrosoft.Practices.Composite.UnityExtensionsMicrosoft.Practices.Unity

Rename de Mainpage class naar Shell en het Mainpage.xaml bestandnaar Shell.xaml. In de shell worden de views weergegeven. De viewsworden gedefineerd in modules en geplaatst in een Region. Je kunt deRegion zien als een placeholder voor views. De Region weet niets vande views, en de view weet niets van de Region waar deze in wordtweergegeven. In de shell kunnen ook algemene UI elementen ge-plaatst worden zoals een menu of een statusbalk. De views van Snipzworden weergegeven in een ContentControl. Dit zorgt ervoor dat ermaar één view tegelijkertijd kan worden weergegeven. Je kunt ookeen ItemsControl of zelfs een tab control gebruiken om de views weerte geven. De views worden behandeld als content van deze controls,dus onder elkaar als items in een list of per tab in een tab control. Omde Region te defineren gebruik je de attached property RegionNamevan de class RegionManager (zie listing 1).

<UserControl x:Class="Snipz.Shell"

xmlns= "http://schemas.microsoft.com/winfx/2006/xaml/pre-

sentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:Regions="clr-namespace:Microsoft.Practices.Compo-

site.Presentation.Regions;assembly=Microsoft.Practices.Compo-

site.Presentation"

Width="640" Height="480">

<ItemsControl Name="MainRegion"

Regions:RegionManager.RegionName="MainRegion"/>

</UserControl>

Listing 1

Voeg een nieuwe class toe aan het Snipz project. Noem dezeBootstrapper. De Bootstrapper class moet afgeleid worden vanUnityBootstrapper. Deze class bevat een groot aantal virtual methodsdie kunnen worden gebruikt. De bootstrapper is verantwoordelijk voorde initialisatie van de Composite Application Library. De bootstrapperzorgt ervoor dat je meer controle krijgt over hoe je applicatie in elkaarzit.

In een standaard Silverlight applicatie wordt de main window gestartvanuit App.xaml. In een applicatie die gebruikt maakt van de CALwordt dit gedaan door de bootstrapper, door de virtual methodCreateShell(). De Shell class wordt geinstancieerd door de Unitycontainer en toegekend aan de RootVisual van de current application.Om modules te kunnen gebruiken moet er een ModuleCataloggedefineerd worden. Dit gebeurd in de override van de GetModule-Catalog() method. Later zullen hier de verschillende modules aantoegevoegd worden.

public class BootStrapper:UnityBootstrapper

{

protected override DependencyObject CreateShell()

{

var shell = Container.Resolve<Shell>();

Application.Current.RootVisual = shell;

return shell;

}

protected override IModuleCatalog GetModuleCatalog()

{

ModuleCatalog catalog = new ModuleCatalog();

return catalog;

}

}

Listing 2

Het initialiseren van de bootstrapper gebeurt op de plaatst waarvoorheen de main page geinstancieerd werd, in App.xaml.cs in deafhandeling van het Startup event. In plaats van MainPage wordt nueen nieuwe bootstrapper aangemaakt en gestart.

private void Application_Startup(object sender,

StartupEventArgs e)

{

BootStrapper bootStrapper = new BootStrapper();

bootStrapper.Run();

}

Listing 3

Op dit moment kan de applicatie gecompileerd en uitgevoerdworden. Er gebeurt alleen nog niet zo veel.

De ModuleVoeg een nieuwe Silverlight Library toe aan de solution en noem dezeSnipz.Edit. Voeg, om ook hier de Composite Application library tekunnen gebruiken, de volgende references toe:Microsoft.Practices.CompositeMicrosoft.Practices.Composite.PresentationMicrosoft.Practices.Unity

Hernoem de class “class” naar EditModule. Om deze class al moduleherkenbaar te maken aan de applicatie moet deze afgeleid zijn van deIModule interface. De IModule interface heeft één method diegeïmplementeerd moet worden; Initialize().


UX

UX

Deze method wordt aangeroepen tijdens het initialisatie proces vande module.

public class EditModule:IModule

{

public void Initialize()

{

}

}

Listing 4

Om deze module te kunnen gebruiken moet deze toegevoegd wordenaan de Bootstrapper in de GetModuleCatalog() method. Dit kan doorin het Snipz project een reference te maken naar het Snipz.Edit pro-ject en de GetModuleCatalog() method aan te passen als in listing 5.

protected override IModuleCatalog GetModuleCatalog()

{

ModuleCatalog catalog = new ModuleCatalog()

.AddModule(typeof(Snipz.Edit.EditModule));

return catalog;

}

Listing 5

Het mooie van deze constructie is dat je runtime kunt bepalen welkemodules er geladen moeten worden. De Composite ApplicationLibrary voorziet ook in mogelijkheden om modules uit xaml of uit eenconfiguratie bestand te lezen.

DataDe module moet ergens data vandaan halen en naar toe kunnensturen. In een “echt” project heb je waarschijnlijk een webservice waarje tegenaan praat. De webservice haalt de data uit een database enschrijft deze erin weg. In het client gedeelte heb je een class die decalls naar de server afhandelt. In het geval van het voorbeeld heeft deservice 2 methods: LoadSnippets en SaveSnippet. Het project bevatook een data class, Snippet, om een code snippet te beschrijven.Doordat de interfaces van de service class en de Snippet data toe-gankelijk moeten zijn in de modules, is een gedeelde assembly nodig.Voeg hiervoor een nieuw project toe en noem deze Snipz.API. Deletede class.cs file, voeg een nieuwe interface toe en noem dezeISnipzService zoals in listing 6.

public interface ISnipzService

{

void SaveSnippet(ISnippet snippet);

List<ISnippet> LoadSnippets();

}

Listing 6

Voeg nog een interface toe aan het Snipz.API en noem deze ISnippet.De ISnippet bevat beschrijvingen voor 4 string properties zodat dezelater in de view gebruikt kunnen worden.

public interface ISnippet

{

string Tags { get; set; }

string SnippetText { get; set; }

string Title { get; set; }

string Language { get; set; }

}

Listing 7

Om gebruik te kunnen maken van beide interfaces moeten zegeïmplementeerd worden. Dit gebeurt in het project waar ook de boot-strapper te vinden is, Snipz. Voeg een reference toe vanuit het Snipzproject naar de Snipz.API assembly. Voeg een nieuwe class toe ennoem deze Snippet. Leidt de class af van ISnippet en implementeerde members.

public class Snippet:ISnippet

{

public string Tags { get; set; }

public string SnippetText { get; set; }

public string Title { get; set; }

public string Language { get; set; }

}

}

Listing 8

De server-side implementatie van de service is gaat buiten de scopevan dit artikel. Om toch een paar handvatten te geven, en straks com-manding te kunnen laten zien is er toch een client-side implementatienodig, of in elk geval een concrete implementatie van de ISnipzServiceinterface. De LoadSnippets() method geeft een lijst terug met 2snippets.

public class SnipzService:ISnipzService

{

public void SaveSnippet(ISnippet snippet)

{

//send the snippet to the server…

}

public List<ISnippet> LoadSnippets()

{

return new List<ISnippet>

{

new Snippet {

Language = "C#",

SnippetText = "Console.Writeline(\"Hello world\");",

Tags = "Hello-world",

Title = "Hello World"},

new Snippet{

Language = "C#",

SnippetText = "Console.ReadLine();",

Tags = "readline",

Title = "Readline"}

};

}

}

Listing 9

Om de Snippet class en de SnipzService class beschikbaar te makenin de module moet deze geregistreerd worden in de dependency in-jection container in de bootstrapper. De registratie vindt plaats doormiddel van een interface en de concrete implementatie. De boot-strapper zorgt er dan voor de container met de juiste informatie bij demodule terecht komt. Door een override te maken op de Configure-Container() method in de bootstrapper class kunnen eigen classesaan de container toegevoegd worden.Er kan optioneel een LifetimeController worden meegegeven die be-paald hoe lang een object blijft bestaan. In het geval van de servicewordt er een ContainerControlledLifetimeManager meegegeven. Hier-mee wordt aangegeven dat, elke keer als de ISnipzServer wordt op-gevraagd door middel van de Resolve() method, de ResolveAll()method of als de container wordt gebruikt als parameter in eenconstructor, dezelfde instance van de class wordt gebruikt. Als er geen

MAGAZINE60

parameter wordt meegegeven, wordt er een nieuwe instanceaangemaakt.

protected override void ConfigureContainer()

{

Container.RegisterType<ISnipzService,

SnipzService>(

new ContainerControlledLifetimeManager());

Container.RegisterType<ISnippet, Snippet>();

base.ConfigureContainer();

}

Listing 10

Model-View-View ModelMaak in het module project een reference naar Snipz.API om deze tekunnen gebruiken. Voeg nu een interface toe aan de moduleSnipz.Edit en noem deze IEditModel. Deze class zal gaan communi-ceren met de service om snippets te laden en te saven. De Load-Snippet() method geeft één snippet terug aan de hand van een indexwaarde. De snippet wordt opgevraagd via de SnipzService. De Save-Snippet() method geeft een ISnippet door aan de service. NewSnip-pet() geeft een lege snippet terug.

public interface IEditModel

{

ISnippet LoadSnippet(int index);

void SaveSnippet(ISnippet snippet);

ISnippet NewSnippet();

}

Listing 11

Maak nu een nieuwe class en noem deze EditModel. Implementeer deIEditModel interface. Voeg een constructor toe aan de class en geefhem twee parameters. De eerste parameter ontvangt een ISnipzSer-vice, de tweede een IUnityContainer. Doordat de class geïnstancieerdgaat worden door Unity, krijgt deze vanzelf de juiste waarden voor deparameters mee. Om de constructor parameters in de geïmplemen-teerde methods te kunnen gebruiken, worden deze opgeslagen in pri-vate readonly fields. Als je kijkt naar de uitwerking in listing 12, dan zieje dat er overal gebruik wordt gemaakt van de interfaces. Zelfs hetmaken van een nieuwe snippet wordt gedaan aan de hand van een in-terface. In plaats van het keyword new te gebruiken wordt de Resolve()method van de UnityContainer aangeroepen. De Container.Resolve()method krijgt als type ISnippet mee. Er wordt een nieuwe Snippetgeïnstancieerd, omdat in de bootstrapper tegen Unity is verteld datdeze overal waar een ISnippet gevraagd een concrete Snippet moetworden aangemaakt. Hierdoor verdwijnt de afhankelijkheid op Snippet.De implementatie van ISnippet kan in de bootstrapper wordenaangepast, zonder dat de module hiervoor hoeft te worden gewijzigd.

public class EditModel : IEditModel

{

private readonly ISnipzService _service;

private readonly IUnityContainer _container;

public EditModel(ISnipzService service,

IUnityContainer container)

{

_service = service;

_container = container;

}

public ISnippet LoadSnippet(int index)

{

return _service.LoadSnippets()[index];

}

public void SaveSnippet(ISnippet snippet)

{

_service.SaveSnippet(snippet);

}

public ISnippet NewSnippet()

{

return _container.Resolve<ISnippet>();

}

}

Listing 12

De data moet natuurlijk worden weergegeven en kunnen wordengewijzigd. Voeg hiervoor een nieuwe Silverlight UserControl toe aanhet Snipz.Edit project en noem deze EditView. De User-Interface zelfis niet zo heel bijzonder. Het is niets meer dan een grid met een paartekstboxen voor de invoer van de verschillende properties voor desnippets en 3 knoppen voor de acties naar de service (zie afb.3).

Fig. 3

<Grid x:Name="LayoutRoot" Background="White">

<Grid.RowDefinitions>

<RowDefinition Height="32"/>



<RowDefinition />



</Grid.RowDefinitions>

<Grid.ColumnDefinitions>

<ColumnDefinition Width="72"/>

<ColumnDefinition/>

</Grid.ColumnDefinitions>

<TextBox x:Name="Snippet" Margin="2"

Grid.ColumnSpan="2" Grid.Row="3"

VerticalScrollBarVisibility="Auto"

TextWrapping="Wrap" AcceptsReturn="True" />

<TextBox x:Name="Tags" Margin="2" Grid.Column="1"

Grid.Row="4" />

<TextBox x:Name="Language" Margin="2" Grid.Column="1"

Grid.Row="1" />

<TextBox x:Name="Title" Margin="2" Grid.Column="1" />

<TextBox x:Name="TitleText" Text="Title:"

Margin="2" HorizontalAlignment="Right"

VerticalAlignment="Center" />


UX

<TextBox x:Name="LanguageText" Text="Language:"

Margin="2" Grid.Row="1"

HorizontalAlignment="Right"

VerticalAlignment="Center"/>

<TextBox x:Name="SnippetText" Text="Snippet:"




<TextBox x:Name="TagsText" Text="Tags:"




<StackPanel Orientation="Horizontal" Grid.Row="5"

Grid.Column="1" Margin="2">

<Button Content="Save" Width="50" Margin="2" />

<Button Content="Load" Width="50" Margin="2" />

<Button Content="Clear" Width="50" Margin="2" />

</StackPanel>

</Grid>

Listing 13

Om de Model en de View aan elkaar te koppelen is er een ViewModelnodig. Voeg hiervoor weer een interface toe en noem de IEdit-ViewModel. In de interface komt een readonly property naar de viewIEditView. De moet beschikbaar zijn voor de IModule implementatiezodat deze toegevoegd kan worden aan de Region in de Shell. Ookis er een ISnippet property nodig om de View aan te kunnen binden.In de Composite Application Library is ook de mogelijkheid opgeno-men om Commands te gebruiken. Deze zijn ook te vinden in deinterface om ze te kunnen binden aan de knoppen in de view.

public interface IEditViewModel

{

IEditView View { get;}

ISnippet Snippet { get; set; }

DelegateCommand<string> SaveCommand { get; set; }

DelegateCommand<string> LoadCommand { get; set; }

DelegateCommand<string> ResetCommand { get; set; }

}

Listing 14

Voeg een nieuwe class toe aan de Snipz.Edit module voor de imple-mentatie van de IEditViewModel class en noem deze EditViewModel.Implementeer de IEditViewModel interface. Implementeer, om ervoorte zorgen dat UI bijgewerkt wordt als de Snippet wijzigd, ook deINotifyPropertyChanged interface van Silverlight.

public class EditViewModel:IEditViewModel,

INotifyPropertyChanged

{

public DelegateCommand<string> SaveCommand { get; set;}

public DelegateCommand<string> LoadCommand { get; set;}

public DelegateCommand<string> ResetCommand { get; set;}

private ISnippet _snippet;

public ISnippet Snippet

{

get { return _snippet; }

set { _snippet = value;

if (PropertyChanged != null)

PropertyChanged(this,

new PropertyChangedEventArgs("Snippet"));

}

}

public IEditView View { get; private set; }

public event

PropertyChangedEventHandler PropertyChanged;

}

Listing 15

De EditViewModel class heeft een constructor om alle propertiescorrect te initialiseren. De constructor heeft twee parameters nodigwelke deze meekrijgt van de UnityContainer. Ook geeft deEditViewModel class zichzelf door aan de View. Deze method wordtdadelijk toegevoegd. De commands worden geïnstancieerd metdelegates naar methods.

private IEditModel _model;

public EditViewModel( IEditView view, IEditModel model)

{

_model = model;

SaveCommand = new DelegateCommand<string>(SaveHandler);

LoadCommand = new DelegateCommand<string>(LoadHandler);

ResetCommand =

new DelegateCommand<string>(ResetHandler);

View = view;

View.SetViewModel(this);

}

Listing 16

Deze methods zien er uit zoals in listing 17. Er gebeurt in dezemethods niets meer dan aanroepen naar de EditModel class. DeLoadHandler() zal in een werkelijke implementatie wat complexer zijn.In dit voorbeeld wordt altijd dezelfde snippet geladen, in werkelijkheidzou er een andere view getoond kunnen worden om een snippet tezoeken in de database.

private void ResetHandler(string obj)

{ Snippet = _model.NewSnippet(); }

private void SaveHandler(string obj)

{ _model.SaveSnippet(Snippet); }

private void LoadHandler(string obj)

{ Snippet = _model.LoadSnippet(1);}

Listing 17

Om de ViewModel aan de View te koppelen is er een laatste interfacenodig. Voeg deze toe aan het project en noem deze IEditView.

public interface IEditView

{

void SetViewModel(object viewModel);

}

Listing 18

Implementeer deze interface in de codebehind van de EditView.xaml.Dit is, naast de constructor, de enige code die in de codebehind komtte staan.

public partial class EditView : EditView

{

public void SetViewModel(object viewModel)

{

DataContext = viewModel;

MAGAZINE62

UX

DELPHI TIP:Delphi 2010 DBGrid en Title ClicksDelphi 2010 introduceert o.a. ondersteuning voor themes in allegrids, waaronder de TDBGrid. Een andere uitbreiding in hetTDBGrid zijn de option vlaggen voor dgTitleClick en dgTitle-HotTrack, die default op True staan. De werking van deze vlag-gen lijkt me voor de hand liggen, maar wat niet zo voor de handligt is dat voor bestaande toepassingen deze opties van hetTDBGrid niet lijkt te werken. Het OnTitleClick event, dat al jarenwerkt, lijkt het plotseling niet meer te doen als ik een bestaandetoepassing opnieuw compileer met Delphi 2010.De oorzaak zit hem in het feit dat de option vlag dgTitleClicknog niet bestond in oudere versies van Delphi, en derhalve nietin de DFM file van de form staat, en dus de waarde “False”krijgt. Wat tot gevolg heeft dat dgTitleClick niet aan staat, en hetOnTitleClick event niet meer wordt aangeroepen (bij oudereversies van Delphi bestond de vlag niet, en werd OnTitleClickaltijd aangeroepen).De oplossing is eenvoudig, maar mogelijk wel een beetjetijdrovend: je moet door al je forms heenlopen, en bij alleTDBGrid componenten waar je de OnTitleClick wilt latenuitvoeren, de option vlag dgTitleClick expliciet aanzetten zodatdeze in de DFM file staat.Zie http://www.bobswart.nl/Weblog/Blog.aspx?RootId=5:3791voor meer details.


UX

}…

Listing 19

Voeg in de xaml de bindings toe voor de properties van de Snippet,zodat de tekstboxen dit kunnen weergeven en de gebruiker de tekstkan wijzigen. Zet de mode van de binding op TwoWay om ervoor tezorgen dat de data wordt teruggegeven aan de Model. Voeg de regelhier onder ook toe voor de andere drie tekstboxen.

Text="{Binding Path=Snippet.SnippetText, Mode=TwoWay}"

Listing 20

Voeg om de commando’s te kunnen gebruiken de volgende regel toeaan de UserControl definitie.

xmlns:cal="clr

-namespace:Microsoft.Practices.Composite.Presentation.Com-

mands;assembly=Microsoft.Practices.Composite.Presentation"

Listing 21

Als de onderstaande regel wordt toegevoegd aan de Save button,wordt zordra er op de button geklikt wordt de delegate in de ViewMo-del uitgevoerd. Voeg de regel ook toe voor de andere twee knoppen.

cal:Click.Command="{Binding Path=SaveCommand}"

Listing 22

Nu de bindings op zijn plek zitten kan de View aan de Region wordentoegevoegd. Dit gebeurt in de EditModule class. De constructor vande EditModule class krijgt van Unity een IRegionManager voor deregions en een IUnityContainer mee. Deze worden bewaard omgebruikt te worden vanuit de Initialize() method.

private readonly IRegionManager _regionManager;

private readonly IUnityContainer _container;

public EditModule(IRegionManager regionManager,

IUnityContainer container )

{

_regionManager = regionManager;

_container = container;

}

Listing 23

De Initialize() method moet eerst de drie gebruikt interfaces registerenbij de Unity container, zodat deze op andere plaatsen in de assemblygebruikt kunnen worden. Daarna wordt de EditViewModel geïnstan-cieerd door middel van de Resolve() method van de container. Ookwordt de view aan de “MainRegion” region toegevoegd.

public void Initialize()

{

_container.RegisterType<IEditView, EditView>();

_container.RegisterType<IEditModel, EditModel>();

_container.RegisterType<IEditViewModel,

EditViewModel>();

var ViewModel = _container.Resolve<IEditViewModel>();

_regionManager.Regions["MainRegion"].Add(presenter.View);

}

Listing 24

De applicatie is nu klaar om gecompileerd en gestart te worden.

ConclusieHet Patterns & Practices team heeft een zeer complete handleiding enlibrary geschreven die zowel in Silverlight als WPF gebruikt kanworden. Ik heb hier maar een klein gedeelte van het arsenaal aan func-ties kunnen bespreken, maar ik denk dat het genoeg is om mee testarten. De hoge mate van Testability en Separation of concernszullen zeker bijdragen aan beter onderhoudbare applicaties en minderverrassingen achteraf.

LinksComposite Application Guidance for WPF and Silverlight:http://msdn.microsoft.com/en-us/library/dd458809.aspxPatterns & Practices:http://msdn.microsoft.com/en-us/practices/default.aspx •

Timmy Kokke

Timmy Kokke is werkzaam alssenior software engineer. Zijn focusligt met name op het gebied vanSilverlight, WPF en WCF. Daarnaastis hij actief binnen de Silverlight enExpression usergroup, Sixin. Voorvragen is hij te bereiken [email protected]

GRATIS VERSIEENTERPRISEGENERATIONLANGUAGE (EGL)Het hart van de Rational Business Developer wordt

gevormd door EGL (Enterprise Generation

Language). EGL is een 4GL generatietaal waarmee

het mogelijk is applicatie te genereren in COBOL,

Java of Javascript. Hierdoor is het mogelijk om

met één ontwikkelomgeving webapplicaties als

mede bedrijfskritische systemen gerealiseerd

worden.Voor het gebruik van EGL moet betaald

worden, maar sinds kort is er ook een gratis

versie beschikbaar: EGL CE (Community Edition).

Deze uitgeklede versie is vooral geschikt voor hen

die kennis willen maken met de taal EGL of willen

beoordelen of EGL voldoende faciliteiten biedt om

de uitdagingen van softwareontwikkeling aan

te gaan.

MAGAZINE64

EGL CE is te downloaden van het EGL Café (http://www-949.ibm.com/software/rational/cafe/docs/DOC-3216). Je moet je weleerst eenmalig registreren. Registratie is gratis. In het EGL Caféworden twee versie ter beschikking gesteld:Volledige versie : Deze is bedoeld voor gebruikers die nog geen Eclipsehebben. De download bevat één ZIP-file. Na extractie kan Eclipseworden gestart en kan de kennismaking met EGL beginnen.

Plugin op Eclipse 3.4: Aangezien deze download geen Eclipse bevat,is het aantal te downloaden bytes vele malen kleiner. Voor de ervarenEclipse gebruiker zal de installatie van deze plugin geen problemenopleveren. Het aantal mogelijkheden van EGL CE ten opzichte van degrote broer EGL is wel beperkt. In de Community Edition ligt de focusnadrukkelijk op het ontwikkelen van Web 2.0 applicaties. De onder-liggende databases worden met behulp van webservices geraad-pleegd en gemanipuleerd. Als server wordt alleen Tomcat JEEondersteund. Voor het ontwikkelen van Web 1.0 en/of COBOL-applicaties of gebruik je een WAS-server, dan heb je alsnog debetaalde Rational Business Developer nodig. “Gratis” heeft ook eenkeerzijde: support wordt niet geleverd.

Cobol2002: een stap voorwaarts?Het heeft erg lang, ja te lang geduurd volgens Wim Ebbinkhuijsen, deauteur van hét Nederlandstalige standaardwerk op het gebied vanCOBOL, voordat een nieuwe versie van de internationale COBOLstandaard kon worden gepubliceerd. Een nieuwe versie met heel veelvernieuwingen en uitbreidingen. COBOL is aangepast aan deontwikkelingen die zich in de afgelopen jaren rond het themasoftwareontwikkeling hebben voorgedaan.

Nu openbaart zich een merkwaardig fenomeen. De beschrijving vanEbbinkhuijsen is eind 2003 al op de markt gekomen. Veel nieuwefeatures die in de COBOL-standaarden zijn opgenomen, blijken voorveel programmeurs een welkome aanvulling. Echter, er zijn nog maarweinig organisaties die deze nieuwe features toepassen. Eenmogelijke oorzaak kan zijn dat lang niet alle COBOL-compilers zijnaangepast aan de nieuwe standaarden of hier slechts een deel vanhebben geïmplementeerd. Een andere mogelijkheid is de onbekend-heid met de mogelijkheden die COBOL 2002 biedt.

Daarom wordt in een aantal korte artikelen aandacht besteed aan debelangrijkste wijzigingen van COBOL 2002 ten opzichte van COBOL-85. In dit artikel staan we in hoofdlijnen stil bij de belangrijksteuitbreidingen en vernieuwingen.

De meest in het oog springende uitbreiding is het onderwerp ‘ObjectOrientation’. OO is niet nieuw, het is reeds een begrip dat al sinds eende jaren ’90 aan programmeringtechnieken is toegevoegd. Helaas isOO COBOL nog niet uitvoerig beschreven. In een apart artikel zal hierop termijn aandacht aan worden besteed.

Een tweede belangrijke uitbreiding betreft het valideren van gegevens.In COBOL 2002 is dit onderwerp op het niveau van ‘proces-oriented’gebracht. Daarmee wordt bedoeld dat het valideren als zodanig toteen separaat proces is benoemd dat met één opdracht geactiveerdkan worden. Het is te vergelijken met de functie voor het genereren vanXML in COBOL (zie het laatste SDN Magazine), die immers ook metéén opdracht geactiveerd kan worden. Bij de validatie-faciliteit inCOBOL kunnen de specifieke validatie-eisen bij de benoeming van degegevens geformuleerd worden. Dit maakt de documentatiewaardeaanzienlijk hoger en het onderhoud veel simpeler.

Een derde belangrijk aspect betreft de internationalisatie van de taal.Het voornaamste element daarvan is de mogelijkheid om metnationale tekensets te werken die duizenden tekens groot kunnen zijn.Dit is van essentieel belang voor landen met grote tekensets, zoalsJapan. Bovendien kan worden gewerkt met elementen die cultureelen/of taalgebonden zijn, bijvoorbeeld de indeling van datumwaarden.

Verder is COBOL in de afgelopen jaren grondig doorgenomen, omwaar mogelijk en zinvol tot verbetering en uitbreiding te komen. Enkelevoorbeelden hiervan zijn:• de toevoeging van floating-point velden;• de mogelijkheid om met bits te opereren;• Booleaanse waarden en bewerkingen;• het rechtstreeks sorteren van tabellen;• het vullen van delen van tabellen;• hexadecimale constanten;• meer functies;• het zelf kunnen maken van functies;• file-sharing en record-locking;• nieuwe faciliteiten om te kunnen reageren op

uitzonderingssituaties;• nieuwe mogelijkheden om met andere programma’s

te communiceren;• de mogelijkheid om met sjablonen te werken;• nieuwe compileraanwijzingen.

Tevens zijn alle elementen die in COBOL-85 als obsolete warenbenoemd uit COBOL verwijderd. Enkele nu nog bestaande elementenzijn nu als obsolete aangewezen, zodat deze bij de volgendeherziening van COBOL zullen verdwijnen.

In de komende edities van het SDN Magazine staan we gedetailleer-der stil bij de extra mogelijkheden van COBOL 2002, uiteraardgeïllustreerd met code voorbeelden. (met dank aan Klaas Apperlo,Technologie Specialist bij Sogeti Nederland B.V.)

Release van RTC 2.0.0.2Medio december 2009 is Rational Team Concert 2.0.0.2 gereleased.Met behulp van RTC is het mogelijk om software ontwikkeling in terichten voor gedistribueerde teams. RTC, gebaseerd op het Jazzplatform van IBM, biedt toepassingen voor projectondersteuning,Source Controle Management en build faciliteiten, volledig gericht ophet samenwerken van verschillende ontwikkelteams. In versie 2.0.0.2zijn de mogelijkheden voor het Agile ontwikkelen sterk uitgebreid.Daarnaast zijn er nog extra features toegevoegd zoals eenvoudigversiebeheer op documenten via een webinterface en is RTC ook tegebruiken onder Windows 7 en Windows 2008 server R2. Een leukebijkomstigheid is dat voor RTC 2.0.0.2 de grens voor het gratis gebruikvan RTC is verhoogd van maximaal drie ontwikkelaars naar maximaal10 ontwikkelaars.

Meer informatie en downloads kun je vinden op:https://jazz.net/downloads/rational-team-concert/releases/2.0.0.1?p=gettingStarted


.NET/ARCHITECTURE

Pieter Joost van de Sande enTjeerd Hans Terpstra

meer heeft en vraagt de ketel om wat water te koken. Genoeg omzichzelf helemaal mee te vullen. De ketel loopt naar de waterkraan envraagt deze om hem te vullen. Nadat de ketel gevuld is loopt hij naarhet fornuis en vraagt aan het fornuis of hij zijn pit wilt ontsteken. Zodrahet vuur brand springt de ketel op de pit en wacht hij tot het waterkookt. Daarna loopt hij terug naar de theepot om hem vervolgens volte gieten met water. De theepot loopt terug naar de kop en vraagt aaneen theezakje om in het water te springen en er niet uit te komen voor-dat de thee goed is. Het theezakje springt erin en wacht twee minu-ten voordat hij er weer uitkomt. Hierna is de thee klaar en schenkt detheepot het kopje vol met thee, waarna het theekopje terugloopt naarGeertje.

Figuur 2: Afhankelijkheden tussen objecten in het model

AfhankelijkhedenFiguur 1 en 2 geven de afhankelijkheden van objecten weer voor beideverhalen. Merk op dat in de echte wereld Geertje alle andere objecteninclusief het hele proces moet kennen, terwijl in het model de objec-ten slechts een paar afhankelijkheden hebben. In plaats van afhanke-lijk te zijn van een complex object, is Geertje dit nu alleen van detheekop. De theekop hangt af van de theepot. De theepot op zijn beurtweer van de kraan en het gasfornuis, en zo verder. Alle objecten wer-ken samen om een doel te verwezenlijken.

Het resultaatAls het actief-passief-patroon goed wordt toegepast volgt er eenmodel waarin verschillende objecten met elkaar samenwerken om eendoel te verwezenlijken, waarbij menselijke actoren nauwelijks een rolspelen. De verdeling van de complexiteit in het resulterende model iszoveel mogelijk evenredig verdeeld. Het model bevat kleinere simpeleobjecten met slechts een aantal afhankelijkheden. De objecten hebbenhun eigen verantwoordelijkheden en gebruiken vooral anderen om hundoel te bereiken. Het is te vergelijken met een mierenkolonie. Het aan-tal objecten zal stijgen, terwijl de complexiteit per object afneemt.

• Pieter Joost van de Sande is Principal consultant Microsoftbij Atos Origin

• Tjeerd Hans Terpstra is senior technical consultant Microsoftbij Atos Origin •

Actief-passief design patternkomt een waterkoker bij het fornuis...Dankzij de kracht van object-georiënteerde programmeertalen zijn we als ontwikkelaars in staat eenexecuteerbaar model te definiëren. Dit doen we door objectdefinities te maken, details teencapsuleren en gedrag te abstraheren door middel van polymorfisme. Object-oriëntatie als krachtiggereedschap wordt vaak ingezet om een model te maken van de werkelijkheid en deze in te zetten alsonderdeel van de software. Eén van de problemen die vaak optreed is dat er onnodig complexe objectenontstaan met veel verantwoordelijkheden en relaties tot andere objecten. Door het toepassen van hetactief-passief design pattern kan men deze complexiteit reduceren.

In objectmodellering is actief-passief een patroon dat als volgtsamengevat kan worden: Alle actieve objecten in de echte wereldworden passief in het model. Voor passieve objecten geldt het tegen-overgestelde, deze worden juist actief.

IntentieZelfs als we meerdere modellen gebruiken kunnen modellen onnodigcomplex worden. Een veelgemaakte fout is dat we een model makendat een te strakke afspiegeling is van de echte wereld. Dit is verklaar-baar omdat onze hersenen die wereld goed kennen en we ons hierinthuisvoelen. Om dit te voorkomen passen we het actief-passief-patroon toe. Met behulp van dit patroon kunnen we een eenvoudigevertaling maken van de echte wereld naar een model.

VoorbeeldHieronder zijn twee scenario’s beschreven. Beide beschrijven hoeGeertje thee zet. Het eerste verhaal speelt zich af in de echte wereld,terwijl het tweede zich afspeelt in het model.In de echte wereld

Figuur 1: afhankelijkheden tussen objecten in de werkelijke wereld

Geertje wil graag een kopje thee drinken. Ze staat op van haar stoelen loopt naar de keuken. In de keuken pakt ze een theekop, waarnaze de theepot pakt en erachter komt dat deze helemaal leeg is. Datbetekent dat ze eerst nog thee moet zetten. Ze gebruikt de kraan omde ketel te vullen met water. Niet te vol natuurlijk, want dan kookt hetwater straks over. Geertje zet de ketel met water op het fornuis enwacht tot het water kookt. Daarna vult ze de theepot met het hetewater uit de ketel en hangt er een theezakje in. Zodra de thee donkergenoeg is verwijdert ze het theezakje en schenkt haar kop vol met thee.

In het modelGeertje wil graag een kopje thee drinken. Ze vertelt tegen een theekopdat ze graag thee wil. De kop gaat naar de theepot en vraagt of zehem vol wilt schenken. De theepot komt er achter dat ze geen thee

MAGAZINE66

Usability Study:Shopping For Beds-heets - How HardCould It Be?Lakens zijn maar eenvoudige artikelen dushoe moelijk kan het zijn om een goede web-shop te ontwerpen om ze online te verkopen?Als we dit artikel in Smashing Magazine moe-ten geloven is dit toch nog een stukje lastigerdan je op het eerste gezicht zou denken. Indit artikel worden een aantal prominenteAmerikaanse webshops vergeleken op sterkeen zwake punten. Het resultaat is waarschijn-lijk niet verassend, alle shops hebben min-punten en zijn zelf ook nog op zoek naar deideale oplossing. Maar we kunnen de analysegoed gebruiken als we zelf een webshopmoeten ontwerpen. Het artikel is te vinden op:http://www.smashingmagazine.com/2010/01/13/shopping-for-bedsheets-how-hard-could-it-be/

50 Photoshop Brush Collections

1000s of BrushesDe vraag naar goede kwaliteit Photoshop Brushes is groot, iedere designer heeft ze nodig. Het probleem is dat er veel te veel zijn, waardoorhet bijna onmogelijk is om net die ene brush te vinden die je nodig hebt. Er is geen gebrek aan Photoshop Brush Directories, en er is zekergeen gebrek aan blog posts over de beste en nieuwste brushes. Wat er echter niet is, is een goede en betrouwbare database of bron met brus-hes waarin je kunt filteren of zoeken op categorie, style of shape. Paul Andrew, aka Speckyboy, hoopte dat in zijn blogpost wel aan te kunnenbieden. Of dit hem gelukt is, is te lezen op. http://speckyboy.com/2010/01/13/50-photoshop-brush-collections-1000s-of-brushes/

jQuery 1.4 is uitVoor veel web ontwikkelaars en designers is jQuery geen onbekende.Recent is versie 1.4 van jQuery uitgekomen. In deze nieuwe versie vanjQuery zijn een hoop aanvullingen en verbeteringen verwerkt. Een be-langrijke wijziging voor gebruikers van de huidige versie van jQuery zalzeker de verbeterde snelheid zijn. En die snelheidsverbetering is nietalleen in een paar obscure uithoeken, nee een hoop van de veel ge-bruikte functies als css() of html() zijn 3 of 4 keer zo snel geworden. Eenvan de krachtigste nieuwe functies is dat bijna alle events nu als liveevent gebruikt kunnen worden. Voorheen waren veel gebruikte eventsals die van de muis of een form submit niet beschikbaar als live events.Helaas zijn er wel een paar veranderingen die mogelijk effect kunnenhebben op bestaande code. Er zijn niet veel van deze breakingchanges maar het is, zoals altijd, verstandig om een website eerstgoed te testen met deze nieuwe versie van jQuery. Meerinformatie is te vinden op http://jquery14.com/day-01/jquery-14

iPhone development met jQTouchEr zijn vele manieren om iPhone development te doen. De bekendsteis misschien wel met Objective C in XCode. Voor .NET ontwikkelaarsis dat niet de gemakkelijkste oplossing en die denken misschien aanMonoTouch en C#. Maar er is een andere, veel makkelijkere, maniermet javaScript en jQTouch. Met jQTouch kan een echte iPhone appli-catie gemaakt worden die zelfs offline kan werken. En dat zonder deverplichting die via de Apple iTunes store te verspreiden. De Code-Camp 2009 presentatie van Maurice de Beijer over jQTouch is hier tevinden: http://www.vimeo.com/8689433

Simplicity

SDN > Update


Macaw groeit!

technologie gespecialiseerde, IT dienstverlener. Onze

richten op belangrijke oplossingen op IT gebied.

Macaw groeit en daarom zijn we op zoek naar enthousiaste collega’s die zich helemaal thuis voelen in het werken met de nieuwste technologieën zoals SharePoint 2010, Silverlight, xRM en Windows 2008.

WIJ ZOEKEN:

INTERESSE?

[email protected]

www.echtleukwerk.nl

1 Business Consultant

1 Senior System Engineer

1 Project Manager

1 xRM Technical Specialist

1 SharePoint Consultant

1 SharePoint Specialist

2 Afstudeerders programmeer-opdracht Windows Azure

2 Project Managers

OEKEN:WIJ Z EKEN:

tsy1 Senior S

1 Business Consult

OEKEN:WIJ Z

em Engineert

tanonsult

EKEN:

echnic1 xRM TTechnic

oject Manag1 Pr

tal Specialisic

ernag

toineP1 Shar

toineP1 Shar

tt Specialis

tant Consult

t Windoachopdrdtudeers2 Af

eurs Azwindo-ammeerogrs prder

oject Manag2 Pr sernag

http://www.echtleukwerk.nl

software development network · getronics consulting doet mee aan de extreme mobility challenge!...

Documents