Design Patterns Trainingen in Utrecht

Deze door een instructeur geleide, live training in Utrecht (online of ter plaatse) is bedoeld voor ontwikkelaars van het tussenniveau Java die ontwerppatronen willen toepassen om de software-structuur, onderhoudbaarheid en schaalbaarheid te verbeteren.

Aan het einde van deze training zullen de deelnemers in staat zijn om:

• De doelstellingen en voordelen van ontwerppatronen te begrijpen.
• Creational, Structural en Behavioral patronen effectief toe te passen in Java.
• De herbruikbaarheid van code, schaalbaarheid en onderhoudbaarheid te verbeteren.
• Besteed codebases opnieuw te refactoren met behulp van ontwerppatronen.

De evolutie van microservices en containers in de afgelopen jaren heeft de manier waarop we software ontwerpen, ontwikkelen, implementeren en uitvoeren aanzienlijk veranderd. Moderne toepassingen moeten worden geoptimaliseerd voor schaalbaarheid, elasticiteit, falen en verandering. Gedreven door deze nieuwe eisen, vereisen moderne architecturen een andere set patronen en praktijken. In deze training onderzoeken we manieren om deze nieuwe vereisten te identificeren, begrijpen en aan te passen.

Publiek
Deze training is bedoeld voor mensen die enigszins bekend zijn met containertechnologie en met Kubernetes concepten, maar die misschien de praktijkervaring missen. Het is gebaseerd op use cases en lessen die zijn getrokken uit real-life projecten met de bedoeling mensen te inspireren om nog betere cloud-native applicaties te maken en te beheren.

• ontwikkelaars
• Activiteiten
• DevOps
• QA-ingenieurs
• IT-projectmanagers

Indeling van de cursus

• Interactieve lezing en discussie
• Veel oefeningen en oefenen
• Handson-implementatie in een live-labomgeving

Cursusaanpassingsopties

• Neem contact met ons op om een aangepaste training voor deze cursus aan te vragen.

Er zijn tal van beproefde en geteste patronen beschikbaar voor iedereen. Soms gaat het erom om de namen te veranderen en het patroon in een specifieke technologie te implementeren. Dit kan honderden uren besparen die anders aan ontwerp en testen zouden worden besteed. Trainingsdoelen Deze cursus heeft twee doelen: ten eerste stelt het je in staat om bekendere patronen te hergebruiken, ten tweede stelt het je in staat om patronen te creëren en te hergebruiken die specifiek zijn voor jouw organisatie. Het helpt je om in te schatten hoe patronen kosten kunnen verlagen, het ontwerpproces kunnen systematiseren en een codeframework kunnen genereren op basis van jouw patronen. Publiiek Softwareontwerpers, businessanalisten, projectmanagers, programmeurs en ontwikkelaars, evenals operationele managers en software-afdelingsmanagers. Cursusstijl De cursus richt zich op gebruiksscenario's en hun relatie met een specifiek patroon. De meeste voorbeelden worden uitgelegd in UML en in eenvoudige Java-voorbeelden (de taal kan veranderen als de cursus wordt geboekt als een gesloten cursus). Het leidt je door de bronnen van de patronen en laat je zien hoe je patronen kunt catalogiseren en beschrijven die door jouw organisatie kunnen worden hergebruikt.

Doelgroep:

Technische Teamleider, Softwareontwikkelaar

Lerendoel:

Het doel van de training is om het vermogen te verwerven om geavanceerde ontwikkel-/projectstructuren in C# te ontwerpen.

Tijdens de cursus maken de deelnemers kennis met MSDN-resources en hulpmiddelen die het ontwikkelproces ondersteunen, zoals Microsoft Visual Studio en ReSharper.

Dit door een instructeur geleide live training in Utrecht (online of op locatie) is gericht op middelberupeerende PHP-ontwikkelaars die effectief ontwerp patronen willen toepassen in hun projecten.

Na afloop van deze training zullen de deelnemers in staat zijn om:

• Het doel en de voordelen van ontwerppatronen te begrijpen.
• Enkele geschikte ontwerppatronen voor algemene scenario's identificeren en implementeren.
• PHP-toepassingen structureren met behulp van door de industrie erkende beste praktijken.
• Patronen integreren in moderne frameworks zoals Symfony of Zend.

De training is ontworpen voor JavaScript-ontwikkelaars die geavanceerde internettoepassingen ontwerpen en implementeren. Tijdens de training worden onderwerpen besproken die gericht zijn op het brengen van best practices in JavaScript-programmeren en de meest voorkomende fouten benadrukken. Een belangrijk punt van de training is het bespreken van de beschikbare object-georiënteerde programmering met JavaScript-syntax.

Kubernetes is een open-source platform voor het automatiseren van alle ontwikkelingsstages van containerized applicaties. Design patterns zijn herbruikbare oplossingen voor softwareontwikkelingsproblemen die specifiek zijn voor softwareontwerp. Kubernetes-extensies worden gebruikt om Kubernetes-clusters te configureren en ondersteunen. Met behulp van Kubernetes-designpatterns en -extensies kunnen platformgebruikers CI/CD-benaderingen bereiken terwijl ze de schaalbaarheid en flexibiliteit van softwareapplicaties handhaven.

Deze instructeur-led, live training (online of op locatie) is gericht op ontwikkelaars en DevOps-ingenieurs die Kubernetes-designpatterns en -extensies willen inzetten om enterprise-applicaties te creëren op Kubernetes-clusters.

Tegen het einde van deze training zullen de deelnemers in staat zijn:

• Een Kubernetes-cluster instellen en de noodzakelijke DevOps-hulpmiddelen configureren.
• De basisprincipes van software-designpatterns en Kubernetes-extensies begrijpen.
• Kubernetes-extensies en -designpatterns inzetten bij het werken met de Kubernetes API.
• Gecustomizeerde Kubernetes-resources ontwikkelen en dynamische controllers op een cluster toepassen.
• Een willekeurige Kubernetes-omgeving beheren en beveiligen met behulp van Kubernetes-plugins.
• DevOps-netwerkmodellen integreren in bestaande en komende Kubernetes-projecten.

Cursusopzet

• Interactieve lezing en discussie.
• Veel oefeningen en praktijk.
• Pas in een live-labomgeving toe.

Cursusaanpassingsmogelijkheden

• Voor een aangepaste training voor deze cursus kunt u contact met ons opnemen om dit te regelen.

Microservice-architectuur is een benadering voor het ontwikkelen van softwareapplicaties als een pakketje kleine, zelfstandige diensten, elk draaiend in zijn eigen proces en communicerend via lichtgewicht mechanismen zoals een HTTP-resource API. Deze diensten kunnen efficiënt worden geïmplementeerd met continue automatiseringssystemen en omzeilen de noodzaak voor central beheer. Microservices kunnen in verschillende programmeertalen geschreven worden en integreren met verschillende datopslagsystemen.

Dit instructeur-led, live training is gericht op enterprise-ontwikkelaars en -architecten. Het introduceert microservice-architectuur vanuit een .Net-perspectief, presenteert migratiestrategieën van een monolitisch systeem, en begeleidt de deelnemers door de creatie en implementatie van een voorbeeld microservice-gebaseerde applicatie.

Na afloop van deze training zullen de deelnemers in staat zijn:

• Begrijpen wanneer u wel en wanneer niet microservice-architectuur moet gebruiken
• Een teststrategie voor microservices creëren en implementeren
• Een voorbeeld microservice-gebaseerde applicatie in een productieomgeving implementeren
• Een monolitische toepassing herschrijven naar diensten

Doelgroep

• Ontwikkelaars
• Architecten

Vorm van de cursus

• Gedeeltelijk lezing, gedeeltelijk discussie, oefeningen en veel praktijkwerk

Doelstelling:

Technische analisten en ontwerpers helpen begrijpen hoe software-implementatie van de vereisten moet worden doorlopen, waardoor traceerbaarheid tussen bedrijfsspecificaties en de softwarecode wordt gewaarborgd.

Deze tweedaagse training is bedoeld om technische analisten en ontwerpers te helpen bij het ontwerpen van specificaties die zijn beschreven door de bedrijfsanalisten. Na transformatie naar representaties van softwarecomponenten, traceren de resulterende systeemcomponenten systeemvereisten naar softwarecomponentstructuren.

Ten slotte worden deze technische specificaties geïmplementeerd in softwarecode en getest op componentbasis. De resulterende softwarecomponenten bieden een goede mate van reactiviteit op veranderingen omdat ze het mogelijk maken om het systeemgedrag laag voor laag afzonderlijk te traceren (van de gebruikersinterfaces naar bedrijfsobjecten laag via de applicatiecomponenten waar de gebruikkeuzes van de actoren worden opgeslagen.

De cursus is bedoeld voor ervaren programmeurs die problemen willen onderzoeken die verband houden met het gebruik van patronen en refactoring. Elke deelnemer kent de eigenschappen en praktische voorbeelden van het gebruik van deze patronen, wat op zijn beurt het efficiënt bouwen en corrigeren van de applicatiecode mogelijk maakt.

Met de opkomst van zeer complexe gedistribueerde systemen is de complexiteit van een enkel systeem verplaatst naar de complexiteit van de architectuur van de groep systemen. Deze cursus omvat de relatie van Software Architecture met Technisch Enterprise Architecture. Deze twee gebieden zijn onderling verbonden op een manier die momenteel niet goed wordt beschreven. Bijvoorbeeld, het splitsen van een complex monolithisch systeem in twee systemen die via webdiensten communiceren, zal aanzienlijke veranderingen in beide nieuwe systemen en de architectuur tussen hen veroorzaken.

Deze cursus zal trade-offs, momenteel gemeenschappelijke patronen en oplossingen voor het beheren van complexe systemen en communicatie binnen en tussen hen dekken.