Opleidingen
58.498
resultaten
GIT GitHub
Utrecht
di 20 mei 2025
en 7 andere data
Wil je efficiënt versiebeheer met Git en GitHub onder de knie krijgen? In deze driedaagse training leer je alle essentiële commando’s en workflows, van het beheren van repositories tot het oplossen van conflicts en herstellen van codes. Je oefent met dagelijkse Git-taken en ontdekt best practices voor samenwerking in teams.
Wat leer je in deze training?
Git-basis – Repositories starten, commits maken, bestanden beheren.
Branching & merging – Werken met branches, merge vs. rebase, conflicten oplossen.
Codeherstel – Reset, revert, stash en cherry-picking toepassen.
Geavanceerde tools – Blame, bisect, submodules en historische analyse.
GitHub-workflows – Pull requests, code reviews en samenwerking in teams.
Deze training is ideaal voor developers, tech leads en iedereen die professionele Git-workflows wil beheersen.
De focus ligt op praktijk en hands-on oefeningen, met Engelstalig lesmateriaal en begeleiding door een Nederlandstalige docent.
Developers die professioneel willen werken met Git.
Tech leads die workflows willen standaardiseren.
Studenten die groepsprojecten moeten beheren.
Technical writers die documentatie versiebeheren.
Dag 1: Git Basis en Repository Beheer
Repository starten:
git init, git clone, git config (globale/lokale instellingen).
Werken met bestanden: git add, git commit, git status, git rm, git mv.
Commit-geschiedenis:
git log (met --oneline, --graph, --pretty), git show, git diff.
Branching:
git branch, git checkout, git switch, git checkout -b (nieuwe branch maken).
Remote repositories:
git remote, git push, git pull, git fetch.
Dag 2: Geavanceerde Wijzigingen en Samenwerking
Merge vs. Rebase:
git merge, git rebase, conflicten oplossen.
Ongedaan maken:
git reset (soft/mixed/hard), git revert, git commit --amend.
Stash en tijdelijke opslag:
git stash, git stash pop, git stash list.
Cherry-picking en historie:
git cherry-pick, git reflog (verloren commits terugvinden).
Dag 3: Geavanceerde Tools en GitHub Workflows
Tagging en releases:
git tag (annotated/lightweight), git describe.
Historische analyse:
git blame, git bisect (bugs traceren), git shortlog.
Submodules en opschonen:
git submodule, git clean.
Patches en configuratie:
git format-patch, git apply, git am.
Geavanceerde git config-instellingen (aliassen, hooks).
GitHub samenwerking:
Pull requests, code reviews, issues.
.gitignore-bestanden en licentiebeheer.
Programma:
Dagelijkse commando’s:
init, clone, add, commit, status, log, push, pull.
diff, checkout, branch, merge, rebase, stash.
Ongedaan maken/herstellen:
reset, revert, amend, reflog, cherry-pick.
Geavanceerde historie:
blame, bisect, shortlog, tag, describe.
Bestandsbeheer:
rm, mv, clean, submodule.
Configuratie en patches:
config, format-patch, apply, am.
Certificaat van deelname + voorbereiding op GitHub Certified Associate.
€1.695
Klassikaal
max 12
3 dagen
HTML CSS Bootstrap
Utrecht
wo 21 mei 2025
en 8 andere data
Wil je leren hoe je professionele, responsive websites bouwt? In deze driedaagse training ontdek je hoe je HTML, CSS en Bootstrap gebruikt om gestructureerde, mobielvriendelijke webpagina’s te ontwikkelen. Je leert semantische HTML, geavanceerde CSS-technieken en hoe je met Bootstrap sneller en efficiënter webinterfaces creëert.
Wat leer je in deze training?
HTML-structuur – Semantische elementen, formulieren en tabellen.
CSS-opmaak – Flexbox, Grid, animaties en responsieve ontwerpen.
Bootstrap-framework – Grid-systeem, componenten en utility classes.
Webdevelopment-tools – Werken met browser DevTools, Emmet en Live Server.
Accessibility & best practices – ARIA-labels, contrastcontroles en SEO-optimalisatie.
Deze training is perfect voor beginners, designers en marketeers die webdevelopment willen beheersen. Met praktijkgerichte opdrachten en moderne tools bouw je functionele en visueel aantrekkelijke websites. De training bevat Engelstalig lesmateriaal en wordt gegeven door een Nederlandstalige docent.
Beginners die willen starten met webdevelopment.
Designers die hun ontwerpen zelf willen coderen.
Marketeers die basisvaardigheden nodig hebben voor CMS-aanpassingen.
Ondernemers die eenvoudige websites zelf willen bouwen.
Dag 1: HTML Basis en CSS Introductie
Werkomgeving opzetten: VS Code, browserdeveloper tools (Chrome DevTools).
HTML5-semantiek: <!DOCTYPE html>, <header>, <nav>, <section>, <article>, <footer>.
Elementen: tekst (<h1>-<h6>, <p>), lijsten (<ul>, <ol>, <li>), media (<img>, <video>).
Formulieren: <form>, <input>-types (text, email, checkbox), <button>, validatie.
CSS-basis: selectors (class, id), box model (margin, padding, border), kleuren (hex, rgb).
Dag 2: Geavanceerde CSS en Responsive Design
Flexbox: display: flex, justify-content, align-items, flex-direction.
CSS Grid: grid-template-columns, grid-gap, fr-eenheden.
Responsive technieken: media queries (@media (max-width: 768px)), mobile-first vs desktop-first.
Transities en animaties: transition, @keyframes, transform (rotate, scale).
CSS-variabelen: :root, var(--primary-color).
Dag 3: Bootstrap Framework en Afronding
Bootstrap installatie: CDN-link, npm of download.
Grid-systeem: container, row, col-* (breakpoints: sm, md, lg, xl).
Componenten: navbar, cards, carousel, modals, dropdowns.
Utilities: spacing (mt-3), kleuren (bg-primary, text-white), flex utilities (d-flex).
Customizen: Sass-variabelen overschrijven, themekleuren aanpassen.
Programma:
HTML:
Semantische tags (<main>, <aside>, <figure>).
Meta-tags (<meta charset="UTF-8">, viewport-instellingen).
Tabellen (<table>, <thead>, <tbody>), iframes.
CSS:
Positionering: relative, absolute, fixed, sticky.
Pseudo-classes (:hover, :nth-child()), pseudo-elementen (::before, ::after).
Specificiteit, !important, inheritance.
Moderne eenheden: rem, vh, vw, calc().
Bootstrap:
Breakpoints: xs (extra small) tot xl (extra large).
Forms: validatiestyling, custom form controls.
Icons: Bootstrap Icons of Font Awesome integreren.
JavaScript-componenten: collapsible menus, tooltips (met data-attributes).
Tools:
Browser DevTools: element inspecteren, responsive modus.
Emmet-snelkoppelingen in VS Code.
Live Server-extensie voor real-time preview.
Accessibility:
ARIA-labels (aria-label, role="navigation").
Contrastratio’s controleren (WCAG-richtlijnen).
Bereidt voor op freeCodeCamp Responsive Web Design Certification.
Basis voor Microsoft MTA: HTML5 Application Development Fundamentals.
€1.695
Klassikaal
max 12
3 dagen
Javascript JS
Utrecht
wo 21 mei 2025
en 8 andere data
Wil je JavaScript leren en interactieve webapplicaties bouwen? In deze driedaagse training ontdek je de kracht van JavaScript, van basisconcepten tot moderne technieken zoals ES6+, asynchroon programmeren en API-integratie. Je leert hoe je dynamische content beheert via de DOM, events afhandelt en efficiënte code schrijft met functies, objecten en arrays.
Wat leer je in deze training?
JavaScript-basis – Variabelen, datatypes, operators en controleflow.
Functies & objecten – Scope, closures, ES6-classes en prototype-inheritance.
DOM-manipulatie – HTML-elementen selecteren, aanpassen en events afhandelen.
Asynchroon programmeren – Callbacks, Promises, async/await en de Fetch API.
Moderne ES6+ technieken – Arrow functions, destructuring en modules.
Deze training is ideaal voor beginnende developers, frontend-ontwikkelaars en designers die interactieve functionaliteiten aan websites willen toevoegen. Je werkt met Engelstalig lesmateriaal, praktijkgerichte opdrachten en moderne tools, ondersteund door een Nederlandstalige docent.
Beginners die webdevelopment willen leren.
Frontend-developers die hun JavaScript-kennis willen verdiepen.
Full-stack ontwikkelaars in opleiding (i.c.m. Node.js).
Designers die interactieve elementen aan websites willen toevoegen.
Dag 1: JavaScript Basis en Syntax
Installatie van Software Node.js en VSCode.
Basisconcepten: variabelen (let, const, var), datatypes (string, number, boolean, null, undefined, object).
Operatoren: rekenkundig (+, -, *, /), vergelijking (===, !==), logisch (&&, ||, !).
Controlestructuren: if/else, switch, for-loops, while-loops.
Functies: declaratie, parameters, return-waarden.
Dag 2: Geavanceerde Functies en DOM-introductie
Functies als first-class citizens: anonieme functies, callbacks.
Arrays: aanmaken, methoden (push, pop, map, filter, reduce).
Objecten: properties, methods, this-keyword.
Introductie tot de DOM (Document Object Model): querySelector, elementen aanpassen (.textContent, .innerHTML).
ES6+ features: arrow functions, template literals, destructuring.
Dag 3: Asynchroon Programmeren en Moderne Technieken
Asynchrone code: setTimeout, Promises, async/await.
Event handling: click-, form- en keyboard-events.
Error handling: try/catch/finally.
Fetch API: data ophalen van een externe bron (JSONPlaceholder).
Modulaire code: import/export (ES6-modules).
Basisconcepten en Syntax:
Variabelen: let, const, var (scope-verschillen).
Datatypes: primitief (string, number, boolean, null, undefined) en complex (object, array).
Typeconversie: expliciet (parseInt(), String()) en impliciet.
Operatoren:
Rekenkundig: +, -, , /, %, *.
Vergelijking: ==, ===, !=, !==, >, <.
Logisch: &&, ||, ! (truthy/falsy-waarden).
Strings: template literals (backticks), methoden (slice(), replace(), includes()).
Controlestructuren:
Conditioneel: if/else if/else, switch-statements.
Loops: for (traditioneel, for…of, for…in), while, do…while.
Loop-control: break, continue, geneste loops.
Functies en Scope:
Functiedefinities: declaraties, expressies, IIFE (Immediately Invoked Function Expressions).
Parameters: default values, rest parameters (…args).
Arrow functions: syntax, this-binding.
Scope: globale scope, function scope, block scope (let/const).
Closure: basisconcept en praktijkvoorbeelden.
Arrays en Methoden:
Aanmaken: literals, Array.from(), new Array().
Methoden:
Mutatie: push(), pop(), shift(), unshift(), splice().
Iteratie: forEach(), map(), filter(), reduce(), find(), some(), every().
Ordening: sort(), reverse().
Array destructuring: const [a, b] = arr;.
Objecten en OOP:
Object literals: properties, methods, shorthand syntax.
this-keyword: context in functies en arrow functions.
Constructor functions en new-keyword.
ES6 Classes: class, constructor, methods, static methods.
Prototype chain en inheritance: extends, super().
Object destructuring: const { name, age } = obj;.
JSON: JSON.parse(), JSON.stringify().
Moderne ES6+ Features:
Template literals: interpolatie, multi-line strings.
Destructuring: arrays, objecten, geneste structuren.
Spread/rest operator: … voor arrays/objecten/parameters.
Modules: import/export, default vs named exports.
DOM-manipulatie en Events:
DOM-selectie: document.querySelector(), querySelectorAll().
Elementen aanpassen: .textContent, .innerHTML, .setAttribute().
Stijl wijzigen: .style.property, classList.add()/remove().
Event listeners: addEventListener(), click, submit, keydown.
Event object: event.preventDefault(), event.target.
Dynamische HTML: elementen maken/verwijderen (createElement(), appendChild()).
Asynchroon Programmeren:
Callback-functies en callback hell.
Promises: .then(), .catch(), .finally(), chaining.
async/await-syntax voor leesbare asynchrone code.
Fetch API: fetch(), Response.json(), error handling.
Axios (basis): alternatief voor fetch.
Error Handling en Debugging:
try/catch/finally-blokken.
Custom errors: throw new Error().
Debugging met console.log(), console.error(), breakpoints (Chrome DevTools).
Tools en Praktijk:
npm basics: npm init, packages installeren (bijv. axios).
Bundelen met Parcel (basis): modules bundelen voor browsers.
Linting: ESLint introductie (consistentie in code).
Praktijkcases:
Formuliervalidatie.
Dynamische filters voor productlijsten.
API-integratie (weer-app met OpenWeatherMap).
Geavanceerde Concepten (introductie):
Web APIs: localStorage, sessionStorage.
Timers: setInterval(), clearInterval().
Strict mode: "use strict" en voordelen.
Functioneel programmeren: pure functies, immutability.
Bereidt voor op het Microsoft Technology Associate (MTA) JavaScript-certificaat.
Basis voor vervolgcursussen zoals Frontend Development met React of Node.js Fundamentals.
Optioneel extern examen (niet inbegrepen).
€1.695
Klassikaal
max 12
3 dagen
Node.js
Eindhoven
di 13 mei 2025
en 9 andere data
Een intensieve eendaagse training in server-side JavaScript ontwikkeling met Node.js. Leer basisconcepten zoals de event loop, npm-package management en het bouwen van REST API’s. Focus op praktische toepassingen met Express.js en database-integratie, inclusief basis deployment technieken.
Waarom Node.js?
Non-blocking I/O: Ideaal voor hoge concurrentie
Groot ecosysteem: 1.3M+ npm packages
Full-stack uniformiteit: Zelfde taal als frontend
Snel prototype: Snelle ontwikkelcyclus
Cross-platform: Draait overal met JavaScript
Studiebelasting
1 lesdag (8 uur intensief)
8-10 uur praktijkopdrachten
4 uur aanbevolen zelfstudie
Frontend developers die backend willen leren
JavaScript enthousiastelingen
Tech leads die microservices overwegen
DevOps engineers die Node-apps moeten onderhouden
Dag 1: Core Concepts & API Development
Runtime fundamentals: Event loop en async programming
Core modules: fs, http, path (hands-on met streams)
NPM essentials: package.json scripts, dependency installs
Express.js setup: Middleware chain en routing
REST API basics: CRUD endpoints met JSON
Database connectie: MongoDB + Mongoose basis
Error handling: Custom middleware en logging
Deployment prep: Docker basis en PM2 process manager
Programma
Node REPL en debug technieken (--inspect)
EventEmitter class en custom events
Streams voor file processing
Express middleware: body-parser, cors
Route params: GET /users/:id
Mongoose schema design (new Schema())
Basis queries: find(), save()
Error middleware met next(err)
JWT authenticatie basis
Dockerfile configuratie (FROM node:18-alpine)
PM2 basics (pm2 start app.js)
Voorbereiding op: * OpenJS Node.js Services Developer (JSNSD) * AWS Certified Developer (basisconcepten) * Microsoft Certified: Azure Fundamentals
€695
Klassikaal
max 12
1 dag
React,js
Eindhoven
wo 7 mei 2025
en 9 andere data
Deze tweedaagse opleiding biedt een praktijkgerichte introductie tot React, het populaire JavaScript-framework voor het bouwen van interactieve gebruikersinterfaces. Je leert componentgebaseerde ontwikkeling, state management en integratie met externe API’s. De training focust op moderne React-features zoals hooks, context API en functionele componenten. Hands-on oefeningen omvatten het bouwen van een todo-app, een productcatalogus met filtering en een eenvoudige social media feed. Na afloop kun je dynamische, efficiënte webapps ontwikkelen met React en het bijbehorende ecosysteem.
Waarom React?
React is de facto standaard voor moderne webinterfaces. Kenmerken:
Componentgebaseerd: herbruikbare, onderhoudbare UI-componenten.
Virtual DOM: optimale prestaties door efficiënte updates.
Universeel inzetbaar: web, mobile (React Native), desktop (Electron).
Rijk ecosysteem: Next.js, Redux, React Query en duizenden packages.
Door Facebook ondersteund: gebruikt door Instagram, Netflix, Airbnb.
Studiebelasting:
Contacturen: 2 dagen × 8 uur = 16 uur.
Zelfstudie: 10–12 uur (projecten, documentatie, oefeningen).
Totaal: ca. 26–28 uur.
Android-developers die overstappen van Java naar Kotlin.
Backend-developers die Kotlin met Spring of Ktor willen gebruiken.
Java-ontwikkelaars die moderne taalfeatures willen benutten.
Beginners die een productietaal voor meerdere platforms leren.
Dag 1: React Basis en Componenten
Omgeving opzetten: Node.js, npm, Create React App (npx create-react-app).
JSX-syntax: combinatie van HTML en JavaScript, expressies ({variabele}).
Functionele componenten: props, children, compositie.
State management: useState, useEffect voor levenscyclusbeheer.
Event handling: onClick, onChange, synthetic events.
Dag 2: Geavanceerde Features en Integratie
Custom hooks: herbruikbare logica (bijv. useFetch voor API-calls).
Context API: createContext, useContext voor globale state.
Routing: React Router (BrowserRouter, Route, Link, dynamische routes).
API-integratie: fetch of Axios, error handling, loading states.
Introductie tot state management met Redux Toolkit (optioneel).
Programma:
Core Concepts:
React-componenten: functioneel vs. class-based (kort).
JSX: conditional rendering (&&, ternary operator), lists (map met key).
Props: typechecking met PropTypes of TypeScript.
State en Lifecycle:
Hooks: useState, useEffect, useRef, useMemo, useCallback.
Formulierbeheer: controlled vs. uncontrolled components.
Geavanceerde Technieken:
Context API: theming, gebruikerssessies.
Error boundaries: componentDidCatch (class-based).
Lazy loading: React.lazy(), Suspense.
Routing en Data Fetching:
React Router: nested routes, route guards.
Data fetching: abort controllers, caching strategieën.
Authentication: JWT-tokens, localStorage.
Tools en Optimalisatie:
DevTools: React Developer Tools extensie.
Bundelen: Webpack-configuratie (basis), code-splitting.
Testing: Jest en React Testing Library (render, fireEvent).
State Management:
Redux Toolkit: createSlice, configureStore, useSelector/useDispatch.
Alternatieven: Zustand, Recoil (kort benoemd).
Bereidt voor op Meta Front-End Developer Professional Certificate (Coursera).
Relevant voor React Certified Developer (door derden, bijv. CertiProf).
€1.195
Klassikaal
max 12
2 dagen
Vue,js
Eindhoven
wo 7 mei 2025
en 9 andere data
Deze tweedaagse opleiding biedt een praktische introductie tot Vue.js, een progressief framework voor het bouwen van gebruikersinterfaces. Je leert componentgebaseerde ontwikkeling, reactieve data binding en integratie met moderne tools. De training omvat het bouwen van een dynamische e-commerce interface en een real-time dashboard. Focus ligt op Vue 3 Composition API, Pinia voor state management en integratie met REST APIs. Na afloop kun je schaalbare, onderhoudbare frontends ontwikkelen met Vue.js en het ecosysteem (Vite, Vue Router).
Waarom Vue.js?
Vue.js combineert eenvoud met enterprise-capaciteiten. Kenmerken:
Progressief framework: inzetbaar voor kleine widgets tot complexe SPAs.
Reactief systeem: automatische UI-updates bij datawijzigingen.
Composition API: betere logica-hergebruik en TypeScript-ondersteuning.
Officiële tools: Vue CLI/Vite, Vue Router, Pinia, DevTools.
Gemeenschapsdriven: gebruikt door GitLab, BMW en Louis Vuitton.
Door Facebook ondersteund: gebruikt door Instagram, Netflix, Airbnb.
Studiebelasting:
Contacturen: 2 dagen × 8 uur = 16 uur.
Zelfstudie: 8–10 uur (projecten, documentatie).
Totaal: ca. 24–26 uur.
Frontend-developers die een lichtgewicht alternatief voor React zoeken.
Full-stack ontwikkelaars die snel prototypes moeten bouwen.
UI-designers die interactiviteit aan mockups willen toevoegen.
Teams die developer ervaring (DX) en flexibiliteit prioriteren.
Dag 1: Vue.js Basis en Reactiviteit
Ontwikkelomgeving: Node.js, Vite (npm create vue@latest), DevTools installeren.
Vue-syntax: SFCs (Single File Components), template-directives (v-if, v-for).
Reactiviteit: ref(), reactive(), computed properties.
Componenten: props, emits, slots.
Event handling: @click, @input, modifiers (.prevent, .stop).
Dag 2: State Management en Geavanceerde Features
Vue Router: dynamische routes, navigation guards.
State management: Pinia (defineStore(), actions, getters).
API-integratie: fetch of Axios, error boundaries.
Composables: herbruikbare logica (bijv. usePagination).
Transities: <Transition>, <TransitionGroup>.
Programma:
Core Concepts:
Reactiviteit: watch(), watchEffect(), lifecycle hooks (onMounted()).
Directives: v-model (two-way binding), v-bind (dynamic attributes).
Template-refs: DOM-elementen benaderen met ref().
State Management:
Pinia: stores modulariseren, SSR-ondersteuning.
Hydratie: server-side state naar client overdragen.
Routing:
Lazy loading: () ⇒ import('./views/Home.vue').
Route meta-velden: authenticatie-flags.
Performance:
Optimized re-renders: key-attribuut voor lijsten.
Code-splitting: dynamische imports met Vite.
Testing:
Vitest: componenttests met @vue/test-utils.
E2E-testen: Cypress of Playwright integreren.
Ecosysteem:
UI-libraries: Quasar, PrimeVue.
Backend-integratie: Nuxt.js voor SSR/SSG.
Voorbereiding op Vue.js Certified Developer (community-driven certificaten).
Relevant voor Nuxt.js-certificering bij vervolgopleidingen.
€1.195
Klassikaal
max 12
2 dagen
Java OOP Object Oriented Programmeren
Utrecht
wo 21 mei 2025
en 8 andere data
Wil je Java leren en object georiënteerd programmeren toepassen? In deze driedaagse training ontdek je de kernprincipes van Java, van basisconcepten en syntax tot geavanceerde OOP-technieken zoals overerving, polymorfisme en exception handling. Je leert hoe de Java Virtual Machine (JVM) werkt, hoe je efficiënte code schrijft en hoe je collections en bestandsbeheer toepast.
Wat leer je in deze training?
Java-basis – Syntax, variabelen, datatypes en controleflow.
Objectgeoriënteerd programmeren – Klassen, objecten, overerving en interfaces.
Exception handling – Foutafhandeling met try/catch en custom exceptions.
Collections Framework – Werken met ArrayList, HashMap en generics.
Moderne Java-features – Lambda’s, streams en het java.time API.
Deze training is ideaal voor beginners, IT-professionals en ontwikkelaars die Java willen gebruiken voor enterprise-applicaties, Android-ontwikkeling of backend-systemen. Je werkt met Engelstalig lesmateriaal, praktijkgerichte opdrachten en moderne tools, onder begeleiding van een Nederlandstalige docent.
Beginners zonder programmeerervaring.
Backend-developers die Java willen inzetten voor enterprise-oplossingen.
Android-ontwikkelaars in opleiding.
IT-professionals die legacy Java-systemen moeten onderhouden.
Dag 1: Java Basis en Syntax
Installatie van JDK, IntelliJ/Eclipse IDE en configuratie van de ontwikkelomgeving.
Basisconcepten: public static void main(String[] args), syntaxregels (hoofdlettergevoeligheid, semicolons).
Variabelen en datatypes: primitief (int, double, boolean, char) vs. referentie (String, Array).
Operatoren: rekenkundig (+, -, %), vergelijking (==, !=, >), logisch (&&, ||).
Controlestructuren: if/else, switch, for-loops, while/do-while.
Dag 2: Objectgeoriënteerd Programmeren (OOP)
Klassen en objecten: definiëren van klassen, instantiatie met new.
Methoden: parameters, return-types, overloading.
Encapsulatie: private fields, getters/setters.
Constructors: default en parameterized.
Static vs. instance members: static sleutelwoord.
Dag 3: Geavanceerde Concepten en Tools
Overerving: extends, super(), method overriding.
Polymorfisme en interfaces: implements, abstracte klassen.
Exception handling: try/catch/finally, custom exceptions.
Collections Framework: ArrayList, HashMap, iterators.
Introductie tot Maven/Gradle: dependency management.
Programma:
Basisconcepten en JVM:
JVM-architectuur: bytecode, Just-In-Time (JIT) compiler.
JDK-installatie: javac, java, PATH-configuratie.
Primitive datatypes: byte, short, int, long, float, double, boolean, char.
Referentietypes: String, Object, arrays.
Literals: hex/octale notatie, escape-sequenties (\n, \t).
Operatoren:
Bitwise (&, |, ^, ~), shift (<<, >>, >>>).
Ternary operator (? :), operator precedence.
Packages: package-declaratie, import-statements.
Controlestructuren en Methoden:
Enhanced switch (Java 14+): → syntax, yield.
Labeled loops: outer: while (…) { … break outer; }.
Varargs: void printAll(String… values).
Methoden: recursie, stack frames, stack overflow.
Objectgeoriënteerd Programmeren (OOP):
Verplichte OOP-structuur: klassen als bouwstenen.
Instantievariabelen vs. lokale variabelen.
this-keyword: verwijzen naar instantievariabelen.
Overerving: @Override, super in constructors/methoden.
Polymorfisme: dynamische method dispatch.
Abstracte klassen vs. interfaces (Java 8+): default/static methoden.
Enums: enum Day { MONDAY, TUESDAY }, methods en constructors.
Inner classes: static/niet-static, anonieme klassen.
Exception Handling en Debugging:
Checked exceptions: throws-declaratie.
Try-with-resources (Java 7+): AutoCloseable interface.
Multi-catch: catch (IOException | SQLException e).
Stack traces analyseren: e.printStackTrace().
Common exceptions: NullPointerException, ArrayIndexOutOfBoundsException.
Collections Framework en Generics:
Generics: List<String>, type parameters, wildcards (<? extends Number>).
LinkedList, HashSet, TreeSet, PriorityQueue.
HashMap: hash-keys, collision management.
Comparator vs. Comparable: sorteren met compareTo() en compare().
Streams (Java 8+ intro): filter(), map(), collect(Collectors.toList()).
Geheugenbeheer en Prestaties:
Stack vs. heap: primitieven vs. objecten.
Garbage collection: generational GC, System.gc() (advies).
Immutable objecten: String, LocalDate.
StringBuilder vs. String concatenatie.
Bestandsafhandeling en I/O:
FileReader/FileWriter, BufferedReader, Scanner.
NIO.2 (Java 7+): Path, Files.readAllLines().
Serialisatie: Serializable interface, transient keyword.
Moderne Java Features (introductie):
Lambda-expressies: (a, b) → a + b.
Optional: voorkomen van NullPointerException.
var (Java 10+): lokale variabele type-inferentie.
java.time API: LocalDate, LocalDateTime, Duration.
Bereidt voor op Oracle Certified Associate (Java SE 8 Programmer I).
Basis voor vervolgcursussen zoals Java EE of Android Development.
Examen is extern af te leggen (niet inbegrepen).
€1.695
Klassikaal
max 12
3 dagen
Spring Boot Gevorderd
Eindhoven
wo 7 mei 2025
en 9 andere data
Deze tweedaagse opleiding is gericht op ontwikkelaars die al bekend zijn met de basis van Spring Boot en zich willen verdiepen in meer gevorderde onderwerpen. We gaan aan de slag met complexe configuraties, securitymaatregelen, asynchrone en reactieve patronen en de integratie van microservices binnen de Spring-omgeving. Je leert hoe je grootschalige en high-performance applicaties kunt ontwikkelen en onderhouden, met veel aandacht voor best practices en solide architectuurkeuzes.
Aan de hand van praktijkvoorbeelden en hands-on opdrachten verkennen we de nieuwste ontwikkelingen binnen het Spring-ecosysteem. Na deze cursus ben je in staat om Spring Boot in te zetten voor enterprise-omgevingen, met focus op schaalbaarheid, betrouwbaarheid en optimale ontwikkelsnelheid.
Waarom Spring Boot?
Spring Boot is een ‘opinionated’ aanvulling op het populaire Spring Framework, waardoor het veel boilerplate-configuraties en terugkerende taken automatiseert. In de gevorderde context biedt het een stevige basis voor het bouwen van veerkrachtige, schaalbare en onderhoudsvriendelijke microservices. Dankzij de uitgebreide ecosystemen (Spring Cloud, Spring Security, Spring Data) en sterke community kunnen ontwikkelaars snel en efficiënt enterprise-grade applicaties neerzetten die naadloos integreren in moderne, gedistribueerde omgevingen.
Studiebelasting
Deze opleiding bestaat uit twee lesdagen van elk 8 uur (totaal 16 uur contacttijd). Houd daarnaast rekening met een extra studiebelasting van 4 tot 8 uur voor het voorbereiden en afronden van oefeningen, afhankelijk van je eigen tempo en voorkennis.Deze training is bedoeld voor Java-ontwikkelaars, architecten en DevOps-engineers die reeds basiskennis van Spring Boot hebben en willen overstappen naar gevorderde toepassingen. Deelnemers die al ervaring hebben met het bouwen van RESTful services in Java en bekend zijn met databases en CI/CD-omgevingen halen het meeste rendement uit deze opleiding.Dag 1: Advanced Configuration en Asynchrone Architectuur
Deep Dive Configuratie Uitgebreide configuratie met Spring Boot profiles, conditionele beans en externalized config via Spring Cloud Config.
Asynchrone Services Implementatie van asynchrone logica met @Async en messaging via RabbitMQ/Kafka.
Reactive Programming Inleiding in Spring WebFlux, Mono/Flux en non-blocking IO.
Circuit Breakers en Resilience Gebruik van Spring Cloud Circuit Breaker (Hystrix/Resilience4j) voor fouttolerantie.
Dag 2: Geavanceerde Security en Microservices
Security Patterns Verdere verdieping in Spring Security: method-level security, OIDC, OAuth2-client en JWT-tokenverwerking.
Microservices en Service Discovery Configuratie van Eureka of Consul voor service-registratie, load balancing met Spring Cloud LoadBalancer.
Observability en Tracing Metrics en distributed tracing (Sleuth, Zipkin) voor het inzichtelijk maken van microservice-communicatie.
Deployment en Cloud Integratie Bouw en deploy van gecontaineriseerde applicaties naar Kubernetes of cloudplatforms. Basisbesturing met kubectl.
Programma
Configuratie: Spring Boot profiles, Spring Cloud Config, conditionele beans
Asynchrone services: @Async, messaging (RabbitMQ/Kafka)
Reactive programming met Spring WebFlux (Mono/Flux)
Circuit breakers en resilience patterns (Hystrix, Resilience4j)
Geavanceerde security met Spring Security (method-level security, OAuth2, JWT)
Microservices-architectuur: service discovery (Eureka/Consul), load balancing
Observability: Spring Boot Actuator, Sleuth, Zipkin
Deploy-strategieën: Docker, Kubernetes, cloudplatformintegratie
Deze opleiding bereidt je voor op diverse geavanceerde Spring- of Cloud-gerelateerde certificeringen, zoals de VMware Spring Professional-certificering of de Pivotal Certified Spring Web Application Developer (voorheen Pivotal). Hoewel er geen specifiek examen is gekoppeld, vormt de opgedane kennis een stevige basis voor vervolgopleidingen en certificeringstrajecten binnen het Spring-ecosysteem.
€1.195
Klassikaal
max 12
2 dagen
Spring Boot Introductie
Eindhoven
wo 7 mei 2025
en 9 andere data
Deze tweedaagse opleiding biedt een introductie in het gebruik van Spring Boot voor het ontwikkelen van moderne, schaalbare Java-toepassingen. We behandelen hoe Spring Boot de configuratie en implementatie van Spring-applicaties vereenvoudigt, de belangrijkste annotaties en componenten, en het opzetten van RESTful APIs. Daarnaast besteden we aandacht aan het testen, beveiligen en deployen van applicaties.
Tijdens deze cursus krijg je zowel een theoretisch als praktisch inzicht in hoe Spring Boot kan worden toegepast binnen verschillende projectomgevingen. Je leert efficiënte werkwijzen en best practices kennen, zodat je na afloop zelfstandig aan de slag kunt met Spring Boot.
Waarom Spring Boot?
Spring Boot is een opinated framework bovenop het populaire Spring Framework. Het onderscheidt zich doordat het veel boilerplateconfiguraties vereenvoudigt of automatiseert, waardoor ontwikkelaars zich kunnen richten op het bouwen van functionaliteit in plaats van het configureren van de infrastructuur. Met auto-configuration, ingebouwde starters en geïntegreerde tools voor monitoring en security kunnen Java-teams sneller en consistenter applicaties leveren. Bovendien heeft Spring Boot een grote community die zorgt voor veel documentatie, plug-ins en ondersteuning.
Studiebelasting
Naast de twee lesdagen van elk 8 uur (totaal 16 uur contacttijd) raden we 4 tot 6 uur zelfstudie aan voor het oefenen met voorbeeldprojecten, het doornemen van documentatie en het bestuderen van best practices.Deze opleiding is bedoeld voor (beginnende) Java-ontwikkelaars, architecten en DevOps-engineers die willen leren hoe ze met Spring Boot snel en efficiënt moderne webapplicaties kunnen bouwen. Enige kennis van de Java-taal en basisbegrip van het Spring Framework worden aanbevolen voor het volgen van deze training.Dag 1: Introductie in Spring Boot
Waarom Spring Boot? Overzicht van voordelen, vergelijking met traditionele Spring-configuratie.
Spring Initializr Opzetten van een nieuw project met Maven of Gradle.
Annotaties en Configuratie Basisaanduidingen zoals @SpringBootApplication, @Component, @Service, @Repository.
RESTful Services Creëren van REST-controllers met @RestController en het verwerken van HTTP-verzoeken.
Dependency Injection Werking van de IoC-container en gebruik van annotaties @Autowired, @Qualifier.
Dag 2: Geavanceerde Functionaliteiten en Deploy
Persistentie met Spring Data JPA Entiteiten, repositories en databaseconnecties configureren.
Beveiliging met Spring Security Basisauthenticatie, autorisatie en integratie van security-configuration.
Configuratie en Profielen Externe configuratie (application.yml), gebruik van verschillende profielen (dev, test, prod).
Monitoring en Actuators Inspecteren van metrics, health checks en endpoints voor productieomgevingen.
Testing en Deploy Schrijven van integratie- en unittests, deployment naar applicatieservers of cloudplatforms.
Programma
Spring Boot Fundamentals
Inleiding in het Spring-ecosysteem en de rol van Spring Boot
Opzetten van een nieuwe Spring Boot-applicatie (Maven/Gradle, Spring Initializr)
Configuratie via application.properties en application.yml
Dependency Injection: IoC-container (@Autowired, bean-scoping)
Tooling
Spring Boot CLI-commando’s (spring run, spring test)
Debugging met DevTools (live reload, remote debug)
API Features
Ontwerp van RESTful services met @RestController, request mappings en responses
Validatie via @Valid en BindingResult
OpenAPI/Swagger-documentatie met SpringDoc (springdoc-openapi-ui)
Data Management
Data-integratie met Spring Data JPA (repositories, query-annotaties)
JDBC-template voor raw SQL-queries
Transactiebeheer met @Transactional
Security
Beveiliging met Spring Security (authenticatie, autorisatie, rollen en permissies)
Configuration & Profiles
Profielen en omgevingsspecifieke instellingen (dev/test/prod)
Configuratie van Spring Cloud Config voor externalized config
Logging & Foutafhandeling
Aangepaste exception handling met @ControllerAdvice
Logback-configuratie voor gestructureerde logging (JSON-output)
Actuators & Monitoring
Actuators voor monitoring en health checks
Basisprincipes van Kubernetes-deployments met kubectl apply -f deployment.yaml
Testing
Testing met JUnit en Mockito
Integratie met Continuous Integration-omgevingen
Deployment
Deploy-strategieën (jar/war, Docker, cloud-native platforms)
Deze opleiding is niet direct gekoppeld aan een officieel examen. De inhoud vormt echter een goede basis voor diverse Spring-certificeringen, zoals het Pivotal/Spring Professional-certificeringstraject, of als voorbereiding op meer gespecialiseerde Spring Boot- en microservicescursussen.
€1.195
Klassikaal
max 12
2 dagen
Spring Framework
Eindhoven
wo 7 mei 2025
en 9 andere data
Deze tweedaagse opleiding duikt diep in het Spring Framework, het toonaangevende Java-framework voor het bouwen van enterprise-grade applicaties. Leer hoe je modulaire, onderhoudbare applicaties ontwikkelt met Spring’s dependency injection, aspect-georiënteerd programmeren (AOP) en integratie met databases, security en RESTful services. De training behandelt zowel XML-configuratie als moderne annotation-driven ontwikkeling, inclusief Spring Boot voor snelle prototyping.
Waarom Spring Framework?
Java biedt platformonafhankelijkheid, robuuste multithreading en een rijke ecosystem van libraries. Spring versterkt dit met enterprise-patronen zoals inversion of control (IoC), declaratieve transacties en naadloze integratie met databases (Hibernate, JPA) en messaging-systemen (JMS, Kafka).
Studiebelasting
2 lesdagen van 8 uur.
Ca. 8 uur zelfstudie (oefencases, configuratie-opdrachten).
Java-developers die enterprise-applicaties moeten bouwen of onderhouden.
Architects die modulaire, schaalbare systemen willen ontwerpen met Spring-modules (Boot, Security, Data).
Teams die legacy Spring XML-configuraties willen moderniseren naar annotation-driven code.
Dag 1: Core Spring en Dependency Injection
Spring Container: Werken met ApplicationContext, BeanFactory en bean-lifecycle.
Annotations: Gebruik van @Component, @Service, @Repository en @Autowired voor DI.
XML-configuratie: Definities in beans.xml (scope, lazy-init, constructor-args).
AOP: Logging en transacties via @Aspect, @Before/@After advies.
Profielen: Omgevingsconfiguratie met @Profile en <beans profile="dev">.
Dag 2: Geavanceerde Integraties en Web
Spring MVC: Ontwerp van controllers met @RequestMapping, ModelAndView en Thymeleaf-integratie.
RESTful Services: JSON/XML-responses met @RestController en HttpMessageConverter.
Security: Role-based toegang via Spring Security (WebSecurityConfigurerAdapter, @PreAuthorize).
Data Access: JDBC (JdbcTemplate), JPA (@EntityManager) en transactiebeheer (@Transactional).
Testing: Integratietests met SpringJUnit4ClassRunner en mock-objecten via MockMvc.
Programma
Core Concepts:
Bean-definities via XML (<bean id="…" class="…">) en Java-config (@Configuration).
Autowiring-modus (byType, byName) en qualifiers (@Qualifier("myBean")).
Data Layer:
Transactiepropagatie (PROPAGATION_REQUIRED) en isolation levels in @Transactional.
Spring Data JPA: CrudRepository, @Query("SELECT a FROM Author a WHERE a.name = ?1").
Web Layer:
Interceptors (HandlerInterceptor) voor cross-cutting concerns.
Validatie van form-input met @Valid en BindingResult.
Integratie:
REST-clients met RestTemplate en WebClient (reactive).
JMS-berichten versturen via JmsTemplate en @JmsListener.
Tools:
Spring Boot CLI: spring run app.groovy.
Actuator endpoints (/health, /metrics) configureren in application.properties.
Voorbereiding op het VMware Spring Professional certificaat (examencode: EDU-1202) en Pivotal Certified Spring Developer.
€1.195
Klassikaal
max 12
2 dagen