Opleidingen
58.220
resultaten
Drupal Fundamentals
Utrecht
wo 28 mei 2025
en 8 andere data
Deze tweedaagse opleiding biedt een grondige introductie in Drupal, een krachtig en flexibel open-source content management systeem (CMS). Deelnemers leren de basisprincipes van Drupal, inclusief het opzetten van een website, beheren van content, configureren van modules en thema’s, en het gebruik van tools zoals Drush en Composer. Op dag twee verdiepen we ons in geavanceerdere onderwerpen zoals views, taxonomieën, gebruikersrollen en beveiliging, met praktische oefeningen om een schaalbare Drupal-site te bouwen.
Waarom Drupal?
Drupal staat bekend om zijn schaalbaarheid, veiligheid en flexibiliteit, ideaal voor complexe websites. Het biedt een modulaire architectuur, uitgebreide API-ondersteuning en een actieve community. Kenmerkend zijn de "entities" (contentobjecten), thematische lagen met Twig, en CLI-tools zoals Drush voor efficiënt beheer.
Studiebelasting:
2 lesdagen van 8 uur.
Ca. 4 uur zelfstudie voor praktijkopdrachten en verdieping.
Webdevelopers die Drupal willen leren voor enterprise projecten.
Contentmanagers en site builders die zelfstandig sites willen onderhouden.
IT-professionals die overstappen naar een open-source CMS.
Dag 1: Introductie en Basisconfiguratie
Drupal-installatie: Lokaal opzetten van een Drupal-omgeving met XAMPP/MAMP of DDEV.
Content Types en Velden: Aanmaken van artikelen, pagina’s en custom content types via de GUI.
Modules Beheren: Installatie en configuratie van core- en contrib-modules (bijv. Pathauto, Token).
Basis Theming: Introductie tot Twig-templates en themeregistratie via .theme-bestanden.
Contentbeheer: Werken met revisions, workflows en de WYSIWYG-editor (CKEditor).
Dag 2: Geavanceerde Functionaliteit en Beheer
Views en Taxonomie: Dynamische contentlijsten maken met filters, relaties en sorteeropties.
Gebruikersrollen en Toegangscontrole: Configureren van permissies en workflow states.
Configuration Management: Export/import van configuraties via config/sync en Drush-commando’s (bv. drush cex).
Performance en Beveiliging: Caching instellen, SQL-injectiepreventie en updates beheren via Composer.
Multisite en Migratie: Basisprincipes van multisite-installaties en data-import met Migrate API.
Programma:
Installatie en Configuratie:
Drupal-core installatie via Composer (composer create-project drupal/recommended-project).
Basisinstellingen: site name, tijdzone, SMTP-configuratie.
Contentmodellering:
Custom content types met velden (text, image, entity reference).
Display modes: Manage form en view displays.
Extensies:
Contrib-modules downloaden via de GUI of Composer (composer require drupal/module_name).
Configuratie van Webform, Paragraphs en Devel.
Theming:
Subthemes maken met .info.yml en template overrides.
CSS/JS toevoegen via libraries en gebruik van breakpoints.
Geavanceerde Technieken:
Custom modules maken met hook_theme() en routing (*.routing.yml).
REST API-endpoints configureren voor headless Drupal.
Voorbereiding op het Acquia Certified Site Builder-examen.
€1.195
Klassikaal
max 12
2 dagen
OCA ExamenTraining Java SE 8 Programmer I
Utrecht
vr 23 mei 2025
en 7 andere data
Deze intensieve training bereidt je voor op het Oracle Certified Associate (OCA) Java SE 8 Programmer I-examen. Je oefent met examengerichte vragen en leert essentiële Java-concepten beheersen volgens de officiële examenspecificaties.
De focus ligt op het ontwikkelen van examenstrategieën, herkennen van valkuilen en het perfectioneren van syntaxkennis. Inclusief praktijkopdrachten die aansluiten bij de examenterminologie en -structuur.
Waarom Java OCA?
Industriestandaard: Erkend certificaat voor Java-ontwikkelaars
Syntax precisie: Scherp gestelde examenvragen over details
Fundamentele kennis: Basis voor geavanceerde certificeringen
Career boost: Toegang tot enterprise Java-posities
Studiebelasting
1 lesdag (8 uur intensieve training)
20-30 uur aanbevolen zelfstudie
5+ oefenexamens geadviseerd
Junior Java-developers die willen certificeren
Career switchers naar Java-ontwikkeling
Informaticastudenten die hun kennis willen valideren
Tech leads die teamkwalificaties willen verhogen
Dag 1: Exam Focus & Core Concepts
Java Basics: Primitive types, literals en variabele scope
OOP Fundamentals: Encapsulatie, overerving en polymorfisme
Control Flow: if-else, switch en loops met break/continue
Exception Handling: try-catch-finally en multi-catch
Arrays & ArrayList: Initialisatie, iteratie en manipulatie
Methoden & Encapsulatie: Access modifiers en overloading
Mock Exam: Tijdsgebonden oefenexamen met bespreking
Exam Tips: Tijdsmanagement en vraaginterpretatie
Programma
Java Data Types:
Wrapper classes en autoboxing
String manipulatie en immutabiliteit
OOP Concepten:
Interface default methods
Abstract classes vs interfaces
Uitzonderingsbeheer:
Checked vs unchecked exceptions
Custom exceptions definiëren
Array technieken:
Multi-dimensionale arrays
Arrays.asList() valkuilen
Java API Fundamentals:
java.time.LocalDate manipulatie
StringBuilder methoden
Lambda Basics:
Functionele interfaces
Predicate en Consumer voorbeelden
JShell oefeningen:
Snelle syntax validatie
Exam-style REPL vragen
Exam Simulator:
Pearson VUE-achtige interface
Score-analyse per domein
Voorbereiding voor: * Oracle Certified Associate, Java SE 8 Programmer I (1Z0-808) * Aansluitend op OCP Java SE 8 Programmer II (1Z0-809)
€695
Klassikaal
max 12
1 dag
ExamenTraining Java SE 21 Developer Professional (1Z0-830)
Utrecht
vr 23 mei 2025
en 7 andere data
Deze intensieve training dekt alle examendomeinen van Oracle’s Java SE 21 Developer-certificering. Leer essentiële concepten door praktische code-oefeningen en examensimulaties die exact aansluiten bij de officiële examenobjectieven.
Waarom Java SE 21?
Examenspecificatie: 100% coverage van 1Z0-830 onderwerpen
Moderne features: Records, pattern matching, virtual threads
Praktijkgericht: Focus op code-analyse zoals in het examen
Compleet: Inclusief I/O, lokalisatie en concurrency
Studiebelasting
1 lesdag (8 uur exam focus)
50+ uur code-oefeningen
10+ oefenexamens (Enthuware)
Java-developers die de 1Z0-830 willen behalen
OCP Java 11/17 houders die willen upgraden
Ontwikkelaars die enterprise Java-kennis moeten valideren
Dag 1: Examen Focus & Java Core Concepts
Primitives & Wrappers: Autoboxing, geheugenmanagement
String Manipulatie: Text blocks, String vs StringBuilder
Date/Time API: Zoneredes, Period/Duration, Instant
Control Flow: Switch expressions, pattern matching
OOP Concepts: Records, sealed classes, immutable objects
Exception Handling: Try-with-resources, multi-catch
Arrays & Collections: List.of(), Map.Entry, Deque operaties
Streams & Lambdas: Parallel streams, teeing collector
Mock Exam: Tijdsgebonden oefening met codefragmenten
Programma
Handling Values
Primitive vs wrapper: IntegerCache
Math API: floorDiv() vs divideExactly()
Text blocks met """ syntax
DateTime manipulatie: TemporalAdjusters
Control Flow
Switch expressions met → en yield
Pattern matching: instanceof met variabele binding
Labeled breaks in nested loops
OOP Concepts
Record constructors: compact vs canonical
Sealed classes: permits clause
Local variable type inference (var)
Enum constructors met argumenten
Exceptions
Try-with-resources met effectief final variabelen
Suppressed exceptions in stacktraces
Custom exceptions: checked vs unchecked
Collections
Unmodifiable collections: List.copyOf()
Map.computeIfAbsent() patronen
Deque als stack/queue: push() vs offerFirst()
Streams
Collectors.groupingBy() met downstream collector
Parallel stream thread management
flatMap() voor nested collections
Modules
requires transitive dependencies
Migratie strategieën: unnamed modules
Service loading met provides/with
Concurrency
Virtual threads vs platform threads
StructuredTaskScope voor resource management
ConcurrentHashMap compute methods
I/O API
Files.walk() met depth limit
ObjectInputFilter voor serialisatie
Path.of() vs Paths.get()
Localization
ResourceBundle.Control voor formaatcontrole
CompactNumberFormat voor afkortingen
DateTimeFormatter met locale-specifieke patronen
Predicate en Consumer voorbeelden
JShell oefeningen:
Snelle syntax validatie
Exam-style REPL vragen
Exam Simulator:
Pearson VUE-achtige interface
Score-analyse per domein
Voorbereiding voor: * Oracle Certified Professional: Java SE 17 Developer (1Z0-829) * Java SE 21 Developer Professional (1Z0-830)
€695
Klassikaal
max 12
1 dag
Python PCAP ExamenTraining
Utrecht
vr 23 mei 2025
en 7 andere data
Deze training bereidt voor op het Certified Associate in Python Programming (PCAP-31-0x) examen. Leer geavanceerde Python-concepten zoals OOP, exception hierarchies en bestandsmanipulatie via examengerichte labs. Focus op code-analysevaardigheden voor complexe scenario’s.
Waarom Python?
OOP Capabilities: Polymorfisme, encapsulatie, abstractie
Ecosysteem: Uitgebreide standaardbibliotheek (math, os)
Exam Relevance: Sluit aan bij PE1- en PE2-certificeringspad
Cross-platform: Draait op alle grote besturingssystemen
Studiebelasting
1 lesdag (8 uur intensieve training)
30-40 uur code-oefeningen
10+ oefenexamens aanbevolen
PCEP-gediplomeerden die willen doorstromen
Zelfstandig lerenden met 6+ maanden Python-ervaring
Ontwikkelaars die OOP-kennis willen valideren
Data analysts die willen certificeren
Dag 1: Geavanceerde Python Concepten
OOP Fundamentals: Klassen, objecten, str vs repr
Inheritance: Method overriding en MRO (Method Resolution Order)
Modules: Import technieken (from, as, *) en pycache
File Handling: Context managers en seek()/tell()
Exceptions: Hiërarchie en custom exceptions
Advanced Collections: List comprehensions, lambda, map/filter
Mock Exam: 40 vragen in 65 minuten met code tracing
Programma
Object Oriented Programming
Class variables vs instance variables
@classmethod en @staticmethod decorators
Property setters/getters met @property
Multiple inheritance en super() gebruik
Modules & Packages
init.py rol in packages
sys.path manipulatie voor imports
Relatieve imports (from . import module)
name == "main" patroon
File Operations
Binary vs text mode: encoding issues
with-statement voor auto-closing
readline() vs readlines() performance
Exceptions
Exception chaining met from keyword
finally vs else in try-blokken
Built-in exceptions: KeyError vs IndexError
Functional Programming
Lambda met meerdere argumenten
filterfalse() uit itertools
Nested list comprehensions
Exam-specifieke topics
_ voor "throwaway" variabelen
dict attribute inspectie
is vs == bij objectvergelijking
Shallow/deep copy verschillen
Voorbereiding voor: * PCAP-31-0x: Certified Associate in Python Programming
€695
Klassikaal
max 12
1 dag
Python PCEP ExamenTraining
Utrecht
vr 23 mei 2025
en 7 andere data
Deze training bereidt voor op het Certified Entry-Level Python Programmer (PCEP-30-02) examen. Leer basis Python-syntax, controle structuren en functies via examengerichte oefeningen. Focus op code lezen, debuggen en schrijven volgens examenformaat.
Waarom Python?
Beginner-friendly: Leesbare syntax met strikte indentatie
Exam focus: Directe aansluiting bij PCEP-inhoud
Breed inzetbaar: Scripting, data analyse, automation
Groeiende vraag: POPJULY 2024 rapport toont 23% stijging Python-banen
Studiebelasting
1 lesdag (8 uur intensief)
15-25 uur zelfstudie
5+ oefenexamens aanbevolen
Programmeerbeginners zonder ervaring
Career switchers naar IT-gerelateerde rollen
Studenten die certificering nodig hebben
Professionele gebruikers die basiskills willen valideren
Dag 1: Python Programming Essentials
Data types: int, float, bool, str, NoneType
Operators: Assignment, comparison, logical, bitwise
I/O basics: print() en input() met typeconversie
Control flow: if-elif-else, while/for loops
Collections: Lists, tuples, dicts - slicing en methods
Functions: Definitie, parameters, return vs print
Exceptions: Try-except basisafhandeling
Mock exam: 30 vragen in 45 minuten simulatie
Programma
Basisconcepten
Literals vs variabelen: x = 0o34 (octal)
String operaties: "na"*3 + "batman"[2:5]
Type casting: int(True) → 1
Control Structures
While met else clause
For loops met range(3,10,2)
Nesting: if in for in try-except
Functies
Eenvoudige functies: def f(a,b=2): return a**b
Scope regels: LEGB (Local → Global)
Lambda: sqr = lambda x: x*x
Data Structures
List comprehensions: [x%3 for x in range(5)]
Dict key checks: 'key' in my_dict
Tuple unpacking: x,y = (1,2)
Exam Technieken
Code fragment analyse: "Wat is de output?"
Foutdetectie: Syntax vs runtime errors
Tijdsmanagement: 1.5 min per vraag
Voorbereiding voor: * PCEP-30-02: Certified Entry-Level Python Programmer
€695
Klassikaal
max 12
1 dag
Functioneel Programmeren met F#
Utrecht
di 27 mei 2025
en 7 andere data
Deze opleiding introduceert de principes van functioneel programmeren met F#, een krachtige taal binnen het .NET-ecosysteem. Tijdens de training leer je de basisconcepten van F#, zoals immutabiliteit, functiecompositie en type inference, en hoe je deze kunt toepassen in praktische scenario’s. De focus ligt op het schrijven van concise, onderhoudbare code door middel van pattern matching, recursie en het gebruik van hogere-ordefuncties.
Op dag twee duik je in geavanceerde onderwerpen zoals monads, asynchrone workflows en type providers. Je leert F# te integreren met bestaande .NET-bibliotheken en tools, en ontdekt hoe je functionele technieken kunt combineren met praktische toepassingen zoals dataverwerking en domain-driven design.
Waarom F#?
F# combineert functionele programmeerprincipes met praktische .NET-integratie. Kenmerken:
Functioneel-first: Ondersteunt immutabiliteit en compositie als standaard.
Type Inference: Minimaliseert expliciete type-annotaties.
Succincte Syntax: Minder boilerplate dan C# of Java.
Async/Werkelijk parallellisme: Eenvoudige asynchrone code via async-workflows.
Data Science & Scripting: Ideaal voor dataverwerking met REPL (FSI) en type providers.
Studiebelasting
2 lesdagen van 8 uur (16 uur totaal).
Optioneel: 4 uur zelfstudie voor oefeningen en projectwerk.
Ontwikkelaars die functioneel programmeren willen leren.
.NET-developers die F# willen inzetten voor complexe data- of domeinlogica.
Data engineers en wetenschappers die F# gebruiken voor analyse en scripting.
Dag 1: Introductie en Basisconcepten
F# Syntax en Tooling: Werken met F# Interactive (FSI), dotnet fsi-commando’s, en projectopbouw via dotnet new.
Immutabiliteit en Basistypes: let-bindingen, tuples, records en Option<T>.
Functies en Hogere-ordefuncties: fun-sleutelwoord, |> (pipe operator), List.map, List.filter.
Recursie en Pattern Matching: match … with, rec-sleutelwoord, recursieve data structuren.
Lijsten en Sequences: List.fold, seq { … }, lazy evaluation.
Dag 2: Geavanceerde Technieken en Toepassingen
Computation Expressions: async { … }, maybe-workflows, custom builders.
Type Providers: JSON/XML-type providers met FSharp.Data.
Eenheden van Maat: -attributen voor type-safe eenheden.
Testen in F#: Gebruik van FsUnit, Expecto, en property-based testing met FsCheck.
.NET Interoperabiliteit: C#-bibliotheken aanroepen, F#-modules vs. .NET classes.
Domain Modeling: Discriminated Unions (type … = | …) voor domain-driven design.
Programma
F#-projectstructuur: .fsproj, paket.dependencies, FAKE-buildscripts.
Kernconcepten: Currying, partial application, >> (compose operator).
Collections: Array, List, Seq, Map, en Set-modules.
Pattern Matching: Guards, active patterns ((|…|_|)).
Asynchrone Programmering: Async.Start, Async.Parallel.
Metaprogrammering: Quotations (<@ … @>) en reflection.
Tooling: Debuggen in VS/VSCode, dotnet watch run, Paket voor dependency management.
Praktijkcases: JSON-parsing met Thoth.Json, web-API’s met Giraffe.
Voorbereiding op Microsoft’s "F# Software Development" (indien beschikbaar).
Geschikt als opstap naar certificeringen voor functioneel programmeren (bijv. via FP-community).
€1.195
Klassikaal
max 12
2 dagen
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
Utrecht
di 3 jun. 2025
en 8 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