This event is history, please check out the List of Upcoming Seminars, or send us an email

Check out our related in-house workshops:

 Leerdoelen

Waarom dit seminar?

Het .NET platform is één van de belangrijkste platformen voor het ontwikkelen van software en omvat een grote verscheidenheid aan frameworks, technieken en tools. Toch laat de kwaliteit van de ontwikkelde software nog al eens te wensen over. In zulke gevallen ontbreekt het niet zelden aan een passende software-architectuur, of worden ontwerpprincipes met de voeten getreden. Dit heeft tot gevolg dat applicaties soms onvoorspelbaar reageren, veel fouten bevatten, slecht onderhoudbaar zijn en dat het onevenredig veel tijd vergt om aanpassingen te doen of om nieuwe requirements toe te voegen.

Sander Hoogendoorn heeft vanaf het prilste begin kennis en ervaring opgebouwd met .NET. Tijdens het seminar Pragmatisch ontwikkelen met .NET toont en demonstreert hij in zijn bekende enthousiasmerende stijl hoe u met relatief weinig extra moeite de kwaliteit van de door u ontwikkelde software sterk kan verbeteren. Sander start met een pragmatische meerlaagse software architectuur, en demonstreert en evalueert aansluitend per laag talrijke gemakkelijk toe te passen ontwerppatronen (design patterns), onder andere afkomstig uit de literatuur van Erich Gamma en Martin Fowler, en natuurlijk ook uit Sander's boek "Pragmatisch modelleren met UML".

Alle onderwerpen worden door Sander rijkelijk en onderhoudend geïllustreerd met praktijkvoorbeelden, stukken code en demo's. Natuurlijk laat de spreker ook zien hoe de ontwerppatronen zijn te gebruiken in uw eigen software-ontwikkelingsprojecten. Aan bod komen onder meer het opzetten van frameworks, model-view-controllers, het implementeren van use cases, het omgaan met domain driven development en het gestructureerd ontsluiten van uw databases en services.

De onderwerpen van dit seminar dragen direct bij aan het succesvol ontwikkelen van software. Tijdens het seminar bespreekt Sander Hoogendoorn, Principal Technology Officer bij Capgemini en lid van de Visual Studio Advisory Board bij Microsoft, het toepassen van software architectuur, het opzetten van frameworks en het hanteren van de juiste ontwerppatronen.

Dit seminar geeft veel praktijkvoorbeelden over het toepassen van dergelijke patronen in de dagelijkse praktijk, maar toont ook diverse zeer leerzame anti-voorbeelden. Het geeft de deelnemers een helder inzicht in de positieve bijdrage die deze technieken leveren aan projecten, het motiveert de deelnemers en biedt talrijke handvatten voor het verbeteren van de kwaliteit en onderhoudbaarheid van uw software ontwikkeling.

Welke vragen worden tijdens dit seminar beantwoord ?

Tijdens het seminar worden onderstaande vragen beantwoord:

• Hoe structureren softwarearchitectuur en ontwerppatronen mijn code ?
• Welke lagen en patronen hanteer ik het best in mijn software-architectuur, zowel in database- als in service-georiënteerde applicaties ?
• Waarom en hoe zet ik het best mijn frameworks op en hoe hergebruik ik bestaande frameworks ?
• Welke patronen kan ik toepassen in de user interface in Windows, Web en Silverlight ?
• Hoe vertaal ik requirements en smart use cases in code ?
• Hoe verdeel ik mijn business logica over services, repositories, factories en bedrijfsregels ?
• Welke patronen helpen mij om databases en services te ontsluiten ?

Voor wie is dit seminar bestemd ?

De software-architectuur-principes, ontwerppatronen en vele praktijkvoorbeelden in dit seminar hebben tot doel de kwaliteit en onderhoudbaarheid van uw software te verhogen en de productiviteit van uw projecten te vergroten. Het seminar is daarom aan te raden voor iedereen die betrokken is bij software development (in .NET).

Software-architecten, designers, senior developers en framework developers zullen veel inspiratie halen uit dit seminar. Het seminar gaat niet over de technologie van .NET, maar over hoe .NET pragmatisch is in te zetten in uw projecten. Het biedt talrijke ideëen die uw eigen organisatie kan aanwenden en die leiden tot het effectiever, cleaner en productiever ontwikkelen van (Web) applicaties.

 Volledig Programma

1. Introductie: Denken in applicatie-architecturen

• Kennismaken met meerlaagse (multi-tier) applicatie-architecturen
• Beschamende voorbeelden van verkeerde software architecturen
• Waarom is een goede software architectuur cruciaal in projecten
• Welke lagen heb ik nodig in mijn applicaties ?
• Wat gebeurt er in een presentation layer nodig ?
• Wanneer introduceer ik een process layer ?
• Bedrijfslogica in de domain layer
• Het ontsluiten van gegevens en servicesin de data access layer

2. Software-architectuur: Het opzetten en gebruiken van frameworks

• Heb ik frameworks nodig in mijn project?
• Welk frameworks zijn er allemaal beschikbaar in .NET ?
• Hoe zet ik mijn software architectuur op ?
• Toepassingen en varianten van het layer supertype pattern
• Onafhankelijkheid creëren via het bridge pattern
• Theorie en praktijk van dependency injection

3. User interface: Effectief ontwikkelen van de user interface

• Wat is nu eigenlijk een model-view-controller (MVC) ?
• Hoe werkt Microsoft’s ASP.NET MVC Framework ?
• Domeinobjecten en de user interface: binding en persisting
• Voor- en nadelen van record sets
• Een snel alternatief: een pragmatische data binding architecture
• Een korte introductie tot ASP.NET (Ajax) en Silverlight / WPF

4. Use cases: Realiseren van use cases in tasks

• Use cases modelleren op verschillende niveau's
• Smart use cases als eenheid van werk
• Hoe gebruik ik smart use cases in mijn software architectuur ?
• Use cases implementeren met een model-view-controller
• Introductie van het template method pattern en het task pattern
• De process layer. Hoe maak ik use cases herbruikbaar ?
• Use cases faciliteren met een task manager

5. Bedrijfslogica: Bouwen met factories, domeinobjecten en bedrijfsregels

• Patronen voor het realiseren van domeinobjecten: domain model en table module
• Do's en don'ts van domain object factories en repositories
• Pragmatisch modelleren van domeinobjecten, hun relaties en hun properties
• Werken met verschillende property types, zoals nullable types en value objects
• Gebruiken van referenties, zoals enumerations en het descriptor pattern
• Een pragmatisch patroon voor referenties: smart reference
• Bedrijfsregels valideren via een validation manager en attributes

6. Data en services: Patronen voor het ontsluiten van de back-end

• Het ontsluiten van data via een table gateway
• Onafhankelijk van uw database implementeren van een data manager
• Hoe omgaan met de internal state van uw domeinobjecten ?
• Hoe werkt nHibernate? Een overzicht en demo
• Queries onafhankelijk realiseren via het query pattern
• Een korte introductie van een service gateway

7. Next steps: Model driven architecture en domain specific languages

• Onmisbare tools in .NET: Resharper en NDepend
• Een kort overzicht van het Accelerated Delivery Platform (ADP)
• Pragmatisch modelleren in UML
• Korte introductie van model driven development (MDD)
• Korte introductie in domain specific languages (DSL's)
• Wanneer modelleer ik in UML, wanneer in een DSL ?
• Een applicatie realiseren in 10 minuten. Demo

8. Round up

 Sprekers

Questions about this ? Interested but you can't attend ? Send us an email !