Opleidingen
58.220
resultaten
GIT GitHub
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.
€495
Klassikaal
max 12
90 dagen
HTML CSS Bootstrap
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.
€495
Klassikaal
max 12
90 dagen
Javascript JS
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).
€495
Klassikaal
max 12
90 dagen
Java OOP Object Oriented Programmeren
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).
€495
Klassikaal
max 12
90 dagen
Kotlin Fundamentals
Deze driedaagse opleiding biedt een complete introductie tot Kotlin, een moderne programmeertaal die volledig interoperabel is met Java en geschikt is voor Android, backend- en webdevelopment. Je leert de unieke syntax van Kotlin, null-veiligheid, functionele programmeerconcepten en het bouwen van efficiënte applicaties. De training bevat praktische oefeningen zoals het ontwikkelen van een Android-app (basis) en een REST API met Ktor. Na afloop ben je vertrouwd met JetBrains-tools (IntelliJ), Gradle-builds en Kotlin’s uitbreidingen zoals coroutines.
Waarom Kotlin?
Kotlin is concis, veilig en veelzijdig, ontwikkeld door JetBrains. Kenmerken:
Null safety: compile-time checks voorkomen NullPointerException.
Interoperabel met Java: bestaande Java-bibliotheken en frameworks.
Multiplatform: Android, iOS (KMM), web (Kotlin/JS), native.
Moderne syntax: data classes, extension functions, coroutines.
Officiële taal voor Android: aanbevolen door Google.
Community-driven: open source met actieve updates.
Studiebelasting:
Contacturen: 3 dagen × 8 uur = 24 uur.
Zelfstudie: 6–10 uur (oefeningen, projecten).
Totaal: ca. 30–34 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: Kotlin Basis en Functionele Concepten
Installatie van IntelliJ IDEA en Kotlin-plugin configuratie.
Basis syntax: fun main(), val vs var, type inference.
Datatypes: primitief (Int, Double, Boolean), String, Any, Unit.
Controlestructuren: if als expressie, when, for/while-loops.
Functies: default parameters, named arguments, single-expression functies.
Dag 2: OOP, Null Safety en Uitbreidingen
Klassen: primary/secondary constructors, init-blokken.
Data classes: data class User(val name: String), copy(), destructuring.
Null safety: ?, !!, let/also/apply scope functions.
Uitbreidingen: extension functions (fun String.reverse()).
Objecten en companions: object Singleton, companion object.
Dag 3: Geavanceerde Features en Integration
Collecties: List, MutableList, Map, filter/map/groupBy.
Lambdas en hogere-ordefuncties: (Int) → Boolean, fold/reduce.
Coroutines: launch, async/await, suspend functies.
Ktor-basis: eenvoudige REST API bouwen met routing.
Android-integratie (optioneel): Activity, RecyclerView (basis).
Programma:
Basisconcepten:
Variabelen (val, var), type inference, string templates (${var}).
Ranges: 1..10, until, step, downTo.
Type checks en casts: is, as, as?.
Functioneel Programmeren:
Hogere-ordefuncties: functies als parameters retourneren.
Lambda-expressies: syntaxis, it-keyword.
Inline functies: inline fun voor performance-optimalisatie.
OOP en Uitbreidingen:
Overerving: open classes, override, abstracte klassen.
Interfaces: default methoden, properties.
Sealed classes: beperkte class-hiërarchieën.
Null Safety en Scope Functions:
Elvis-operator (?:), safe calls (?.).
run, let, apply, also, with voor contextbeheer.
Coroutines en Asynchroon:
Coroutine-scopes: GlobalScope, CoroutineScope.
Dispatchers: IO, Main, Default.
Job en Deferred voor concurrencybeheer.
Android/Backend Integration:
Room Database: @Entity, @Dao, basisqueries.
Ktor: routing, statuscodes, JSON-serialisatie (kotlinx.serialization).
Tools en Build Systems:
Gradle: Kotlin DSL, dependencies toevoegen.
Debugging: breakpoints, coroutine-inspectie.
Linting: detekt-configuratie voor codekwaliteit.
Bereidt voor op Google Associate Android Developer (AAD)-certificering.
Relevant voor JetBrains Academy-projecten (geen officieel examen).
€495
Klassikaal
max 12
90 dagen
PHP MySQL
Wil je PHP leren en server-side webontwikkeling beheersen? In deze driedaagse training bouw je dynamische websites met PHP en MySQL. Je leert basisconcepten zoals variabelen, loops en formulieren, maar ook geavanceerde onderwerpen zoals sessiebeheer, OOP en security. Via praktijkcases zoals een contactformulier met validatie en een eenvoudig CMS-systeem pas je de theorie direct toe.
Wat leer je in deze training?
PHP-basis – Syntax, controlestructuren en formulierverwerking.
Databases & MySQL – CRUD-operaties, prepared statements en PDO.
Sessies & cookies – Gebruikersbeheer en authenticatie.
Objectgeoriënteerd programmeren – Klassen, methoden en overerving.
Security best practices – SQL-injectie en XSS-preventie.
Deze training is ideaal voor beginners, frontend-developers en WordPress-ontwikkelaars die hun PHP-kennis willen verdiepen. Je werkt met Engelstalig lesmateriaal, praktijkgerichte opdrachten en moderne tools, ondersteund door een Nederlandstalige docent.
Beginners die server-side webdevelopment willen leren.
Frontend-developers die hun stack willen uitbreiden.
WordPress-ontwikkelaars die dieper in PHP willen duiken.
Backend-developers in opleiding (voor Laravel/Symfony).
Dag 1: PHP Basis en Formulierverwerking
Installatie van PHP, XAMPP/MAMP, en een IDE (bijv. PHPStorm of VSCode).
Syntax: variabelen, datatypes (string, int, float, bool, array, null).
Operatoren: rekenkundig, vergelijking, logisch, concatenatie (.).
Controlestructuren: if/elseif/else, switch, for, while, foreach.
Formulierverwerking: $_GET, $_POST, inputvalidatie (basis).
Dag 2: Functies, Arrays en Sessiebeheer
Functies: definiëren, parameters, return-waarden, typehinting (basis).
Arrays: indexeerde en associatieve arrays, array_push(), array_filter(), array_map().
Superglobals: $_SERVER, $_SESSION, $_COOKIE.
Sessiebeheer: session_start(), gebruikersauthenticatie (basis).
Bestandsafhandeling: fopen(), fwrite(), file_get_contents().
Dag 3: Databases en OOP Introductie
MySQL-integratie: verbinding maken met mysqli of PDO.
SQL-basis: SELECT, INSERT, UPDATE, DELETE, prepared statements.
Databaseklasse bouwen: herbruikbare connectie en queries.
Introductie OOP: klassen, objecten, methoden, eigenschappen.
Security: basis van SQL-injectiepreventie, htmlspecialchars().
Programma:
Basisconcepten en Syntax:
Variabelen: $variabele, datatypes (string, int, float, bool, array, null, resource).
Type Juggling en expliciete conversie: (int), (string), (array).
Operatoren:
Rekenkundig: +, -, , /, %, *.
Vergelijking: ==, ===, !=, !==, >, <.
Logisch: &&, ||, !, and, or.
String-concatenatie: . en .=.
Controlestructuren:
if/elseif/else, switch met case/default.
Loops: for, while, do…while, foreach (voor arrays).
Formulierverwerking en Validatie:
Superglobals: $_GET, $_POST, $_FILES (bestandsuploads).
Input sanitization: trim(), stripslashes(), htmlspecialchars().
Validatie: filter_var() met filters (FILTER_VALIDATE_EMAIL, FILTER_SANITIZE_STRING).
Basis regex: preg_match() voor patroonvalidatie.
Bestandsuploads: $_FILES-array, move_uploaded_file(), mime-type checks.
Arrays en Functies:
Array-types:
Indexeerde arrays: $arr = [1, 2, 3];.
Associatieve arrays: $assoc = ["naam" ⇒ "Jan", "leeftijd" ⇒ 30];.
Array-functies: count(), array_push(), array_merge(), array_key_exists().
Functies:
Definities: function naam($param) { … }.
Optionele parameters: default values (function tel($a, $b = 0)).
Type declarations: function add(int $a, int $b): int.
Anonieme functies en closures.
Sessies en Cookies:
Sessiestart: session_start(), $_SESSION-variabelen.
Cookie-beheer: setcookie(), $_COOKIE, vervaldatums.
Veiligheid: sessie-ID-regeneratie (session_regenerate_id()).
Bestands- en Directorybeheer:
Bestanden lezen/schrijven: file_get_contents(), file_put_contents().
Directory-functies: scandir(), mkdir(), rmdir().
Bestandspermissies: chmod(), is_readable().
Database-integratie (MySQL):
MySQLi:
Verbinden: mysqli_connect().
Queries: mysqli_query(), prepared statements (mysqli_prepare(), bind_param()).
Resultaten ophalen: mysqli_fetch_assoc(), mysqli_fetch_all().
PDO:
Verbinden: new PDO("mysql:host=…;dbname=…", $user, $pass).
Prepared statements: prepare(), execute(), fetch().
Transacties: beginTransaction(), commit(), rollback().
CRUD-operaties: Create, Read, Update, Delete.
OOP (Objectgeoriënteerd Programmeren):
Klassen en objecten: class Gebruiker { … }, new Gebruiker().
Eigenschappen en methoden: public, private, protected.
Constructor/destructor: construct(), destruct().
Static methods/properties: self::$teller, static::methode().
Overerving: extends, parent::__construct().
Security Best Practices:
SQL-injectie voorkomen: prepared statements (MySQLi/PDO).
XSS-preventie: htmlspecialchars(), strip_tags().
Wachtwoordhashing: password_hash(), password_verify().
CSRF-tokens: basisimplementatie voor formulieren.
Tools en Praktijkcases:
Composer: package manager, composer.json, autoloading (PSR-4).
PHPUnit: basis testcases schrijven.
Praktijk:
Contactformulier met validatie en e-mailverzending (mail()).
Inlogsysteem met sessies en wachtwoordbeveiliging.
Blog met database-CRUD en paginering.
Bestandsbeheersysteem (upload/download/delete).
Error Handling en Debugging:
Foutmeldingen: error_reporting(), ini_set("display_errors", 1).
Custom error handler: set_error_handler().
Uitzonderingen: try/catch/throw new Exception().
Logging: error_log(), logbestanden analyseren.
Bereidt voor op het Zend PHP Certification Associate-examen.
Basis voor vervolgtrainingen zoals Laravel of WordPress Development.
Examen is extern af te leggen (niet inbegrepen).
€495
Klassikaal
max 12
90 dagen
Python
Wil je aan de slag met Python? Deze driedaagse training biedt een complete introductie, van basisconcepten tot geavanceerde onderwerpen zoals objectgeoriënteerd programmeren (OOP), data-analyse met pandas en database-integratie met MySQL. Je leert niet alleen de syntax en logica van Python, maar past deze direct toe in praktijkgerichte scenario’s.
Wat leer je in deze training?
Basisconcepten – Variabelen, datatypes, operatoren en controlestructuren.
Functies en foutafhandeling – Definiëren, return-waarden en error-handling met try/except.
Objectgeoriënteerd programmeren – Klassen, objecten, overerving en encapsulatie.
Data-analyse – Werken met pandas, DataFrames en datavisualisatie.
Database-integratie – SQL-queries uitvoeren met MySQL-connector.
Deze training is perfect voor beginners, developers en IT-professionals die Python willen gebruiken voor automatisering, data science of webontwikkeling.
De training bevat praktijkgerichte opdrachten en Engelstalig lesmateriaal en wordt gegeven door een Nederlandstalige docent.
Beginners zonder programmeerachtergrond.
Data-analisten die Python willen inzetten voor dataverwerking.
Developers die overstappen van andere talen (bijv. Java, C#).
IT-professionals die scripts willen schrijven voor automatisering.
Dag 1: Python Basis en Controlestructuren
Installatie van Python, Jupyter Notebook en een IDE (bijv. VSCode of PyCharm).
Basisconcepten: variabelen, datatypes (strings, integers, floats, booleans), operatoren.
Input/output: print(), input(), eenvoudig bestandslezen/schrijven.
Controlestructuren: if/elif/else, for- en while-loops.
Oefeningen: tekstmanipulatie, lijstbewerkingen en eenvoudige scripts schrijven.
Dag 2: Functies, Foutafhandeling en Introductie OOP
Functies definiëren: parameters, return-waarden en scope.
Foutafhandeling met try/except/finally.
Werken met modules: math, datetime, random.
Introductie OOP: klassen, objecten, methoden en attributen.
Dag 3: Pandas, Databases en Geavanceerde OOP
Data-analyse met pandas: DataFrames, data filteren/sorteren, basisaggregaties.
Database-integratie met MySQL-connector: verbinden, SELECT- en INSERT-queries uitvoeren.
OOP-uitbreiding: overerving, encapsulatie en polymorfisme.
Integratie: CSV-data inladen, verwerken met pandas en opslaan in een MySQL-database.
Tips voor vervolgstappen (data science, webdevelopment).
Programma
Basisconcepten:
Variabelen, datatypes (str, int, float, bool, None).
Operatoren (rekenkundig: +, -, *, /; vergelijkings-: ==, !=, >; logisch: and, or, not).
Typeconversie (int(), str(), float()).
Strings: concatenatie, formattering (f-strings), methoden (lower(), upper(), split()).
Boolean-logica en truthy/falsy-waarden.
Controlestructuren:
Conditionele statements: if/elif/else, geneste voorwaarden.
Loops: for (itereren over lijsten, strings, dictionaries), while met break/continue.
Loop-control: range(), enumerate(), list comprehensions.
Functies en modularisatie:
Functies definiëren met def, parameters (defaults, keyword arguments).
Return-waarden, lambda-functies.
Scope: globale vs. lokale variabelen (global keyword).
Foutafhandeling: try/except/else/finally, specifieke exceptions (ValueError, KeyError).
Datastructuren:
Lijsten: aanmaken, indexeren, methoden (append(), remove(), sort()), slicing.
Tuples: immutable operaties, unpacking.
Dictionaries: keys/values, methoden (get(), keys(), items()).
Sets: unieke elementen, operaties (union(), intersection()).
Modules en libraries:
Standaardmodules: math (sqrt, pow), datetime (datum/tijd-formattering), random (shuffle, choice).
Externe libraries installeren met pip (bv. pandas, mysql-connector-python).
Importeren: import, from … import … as ….
Objectgeoriënteerd programmeren (OOP):
Klassen en objecten: init-methode, instantievariabelen.
Methoden: instance methods, static methods.
Overerving: parent/child-klassen, super().
Encapsulatie: public/private attributen (conventie met _).
Polymorfisme en magic methods (bv. str).
Bestandsafhandeling:
Bestanden openen met open(), modi (r, w, a, r+).
Tekstbestanden lezen/schrijven (read(), readline(), write()).
CSV-afhandeling met pandas (read_csv(), to_csv()).
Data-analyse met pandas:
DataFrame en Series aanmaken.
Data manipulatie: filteren met loc/iloc, groupby(), agg().
Basisvisualisatie: plot() (lijn-/staafdiagrammen).
Database-integratie (MySQL):
Verbinden met mysql.connector.connect().
Cursors: execute(), fetchall(), fetchone().
SQL-operaties: SELECT, INSERT, WHERE-clausules.
Transaction management: commit(), rollback().
Praktische toepassingen:
Scripts schrijven voor bestandsautomatisering.
Data transformeren tussen CSV en databases.
Eenvoudige OOP-applicatie bouwen (bv. inventory management).
Bereidt voor op het PCAP-certificaat (Python Institute Certified Associate in Python Programming).
Basis voor vervolgcursussen zoals Data Science met Python of Python voor Webdevelopment.
Examenafname is extern mogelijk (niet inbegrepen in de cursus).
€495
Klassikaal
max 12
90 dagen
Typescript Fundamentals
Deze driedaagse opleiding biedt een diepgaande introductie tot TypeScript, een krachtige superset van JavaScript met statische typing. Je leert hoe je schaalbare en onderhoudbare code schrijft voor zowel frontend- als backend-toepassingen. De training behandelt essentiële concepten zoals interfaces, generics, decorators en integration met frameworks zoals Angular of React. Praktische oefeningen, zoals het migreren van JavaScript naar TypeScript en het bouwen van een type-veilige API, zorgen voor directe toepassing van de theorie.
Waarom TypeScript?
TypeScript combineert JavaScript-flexibiliteit met enterprise-grade typeveiligheid. Kenmerken:
Statische typing: compile-time foutdetectie, betere IDE-ondersteuning (IntelliSense).
Moderne JavaScript: ondersteunt ES6+, async/await, destructuring.
Schaalbaarheid: ideaal voor grote codebases en teamprojecten.
Framework-integratie: Angular, React, Vue, Node.js (NestJS).
Open source: actieve community, door Microsoft ondersteund.
Studiebelasting:
Contacturen: 3 dagen × 8 uur = 24 uur.
Zelfstudie: 6–10 uur (oefeningen, projectafronding).
Totaal: ca. 30–34 uur.
JavaScript-ontwikkelaars die hun code robuuster willen maken.
Frontend-developers die met Angular/React werken.
Backend-developers die Node.js met TypeScript willen inzetten.
Teams die codekwaliteit en collaboratie willen verbeteren.
Dag 1: TypeScript Basis en Type System
Installatie van Node.js, TypeScript (npm install -g typescript) en een IDE (VSCode aanbevolen).
Basisconcepten: statische typing vs. dynamische typing, tsconfig.json.
Primitieve types: string, number, boolean, null, undefined, any.
Arrays en tuples: string[], [string, number].
Functies: type annotations, optionele parameters, default values.
Compilatieproces: tsc, debuggen met source maps.
Dag 2: Geavanceerde Types en OOP
Union/intersection types: string | number, T & U.
Type guards: typeof, instanceof, custom type predicates.
Interfaces: definiëren, optionele properties, readonly.
Klassen: public/private/protected, abstracte klassen, inheritance.
Generics: functies, interfaces, classes met type parameters.
Dag 3: Decorators, Modules en Integration
Decorators: @Component, @NgModule (Angular-style), metadata.
Modules: import/export, namespaces vs. ES6-modules.
Integration met JavaScript: type declarations (.d.ts), gebruik van any en type assertion.
Tooling: Webpack configuratie voor TypeScript, linting met ESLint.
Programma:
Basisconcepten:
Type annotations, type inference, any vs. unknown.
Type aliassen: type UserID = string;.
Literal types: type Direction = "left" | "right";.
Geavanceerde Typing:
Mapped types: Partial<T>, Readonly<T>.
Conditional types: T extends U ? X : Y.
Utility types: Pick<T, K>, Omit<T, K>.
OOP en Generics:
Abstract classes, implements voor interfaces.
Generic constraints: T extends SomeInterface.
Overloading: functies met meerdere signatures.
Decorators en Metadata:
Class decorators, method decorators, parameter decorators.
Reflect API: metadata opslaan/ophalen.
Tooling en Configuratie:
tsconfig.json opties: strictNullChecks, noImplicitAny.
Integration met build tools: Webpack, Babel.
Debugging: source maps, breakpoints in VSCode.
Framework Integration:
React: FC-type, props met interfaces.
Angular: Dependency Injection met types.
Node.js: Express-routes met TypeScript.
Testing en Best Practices:
Jest-configuratie voor TypeScript.
Mocking met jest.mock() en type-safe mocks.
Bereidt voor op Microsoft Certified: Azure Developer Associate (TypeScript-gerelateerde onderdelen).
Relevant voor Angular Certification (voor vervolgcursussen).
Geen officieel TypeScript-examen – certificering via praktijkprojecten of frameworks.
€495
Klassikaal
max 12
90 dagen
Leren werken met ChatGPT en Open AI
Eindhoven
wo 21 mei 2025
en 5 andere data
Unlock the power of AI and gain a huge productivity boost?
Are you ready to harness the incredible potential of ChatGPT? Look no further! Our course, "ChatGPT - The Complete Guide to ChatGPT & OpenAI APIs" is your all-in-one solution to mastering this revolutionary technology.
Through this immersive, hands-on course, you'll discover:
All The Fundamentals: Dive into the world of ChatGPT, GPT models, and Large Language Models (LLMs). Learn the science and mechanics that drive these advanced AI systems.
Essential Skills: Master the ChatGPT interface, its key features, and how to craft both basic and complex prompts. Empower yourself with the tools needed to excel in the AI-driven landscape.
Prompt Engineering Mastery: Optimize your AI experience by learning basic and advanced prompt engineering techniques. Write efficient prompts that get you the precise results you're looking for.
Midjourney Introduction: Learn how to generate beautiful images with help of AI!
Real-World Applications: Explore the diverse use-cases for ChatGPT, from speeding up day-to-day tasks to conducting research, creating content (including blog posts, tweets, and more), writing and enhancing code. And much, much more!
App Creation Magic: Discover how ChatGPT can revolutionize your app and program development, even without programming knowledge. Unleash the power of AI to create innovative and powerful solutions.
Become a 10x Developer: Already got programming experience? Great! Learn how ChatGPT can help you speed up your day-to-day work. Use ChatGPT for development, debugging, refactoring and much more!
Insider Tips & Tricks: Gain access to our treasure trove of tips and tricks for working with ChatGPT. Maximize your efficiency and productivity with these expert insights.
Hands-on Examples & Exercises: Apply & practice what you learned by diving into real examples. Build websites, games, web APIs, blog posts & much more!
Prompt Templates: Use & fine-tune many included pre-built prompt templates to save valuable time and boost your productivity immediately!
OpenAI API Mastery: Learn how to work with OpenAI's APIs and leverage them to build your own AI-powered applications. Unleash the full potential of AI in your projects.
AutoGPT Automation: Master the use of tools like AutoGPT to build automated AI processes and workflows. Streamline your work and let AI do the heavy lifting.
By enrolling in this course, you're taking the first step towards a future powered by AI. No matter your background or experience level, our course is designed to provide you with the knowledge and skills you need to thrive in this rapidly evolving landscape.
Don't miss this opportunity to become an AI pioneer! Enrol now, unlock your potential & transform your career today!
This course covers it all: ChatGPT-powered copywriting, blog post & article generation, email / email draft generation, text summaries via ChatGPT, translations, tone adjustments, social media post generation, code generation, code debugging, refactoring & much, much more!
Busy professionals looking to streamline their day-to-day tasks and improve productivity with AI assistance
Content creators seeking innovative ways to generate engaging blog posts, social media updates, and marketing materials
Aspiring app developers with limited programming knowledge eager to harness the power of AI for building user-friendly applications
Experienced developers who aim to boost their productivity
Non-developers who want to build applications without learning to code
Wat je leert
Master ChatGPT essentials & understand core ChatGPT concepts
Engineer perfect prompts to boost efficiency and impact
Learn key ChatGPT tricks & tips to 10x your productivity
Generate content & code with ease
Turbocharge daily tasks
Innovate with AI by integrating OpenAI's APIs into custom code
Use Midjourney to generate stunning images with help of AI
Automate AI workflows with AutoGPT & LangChainAan deze training is geen examen verbonden.
Wel wordt een certificaat van deelname afgegeven.
€1.695
Klassikaal
max 12
3 dagen
Leren programmeren met Python
Eindhoven
wo 21 mei 2025
en 5 andere data
Tijdens deze cursus ga je een start maken met programmeren in Python.
Op de eerste dag behandelen we alle basiselementen van het programmeren (variabelen, if/else statements, for loops, functies, klassen, objecten),
Op de tweede dag gaan we houden we ons bezig met het manipuleren, analyseren en visualiseren van data.
Deze cursus is richt zich enerzijds op mensen die willen beginnen met het programmeren zonder voorkennis.
Anderzijds is de training geschikt voor mensen die bekend zijn met een andere programmeertaal en de syntax van Python willen leren kennen.
Ook professionals die benieuwd zijn hoe programmeurs denken en werken, kunnen zich met deze cursus goed een beeld vormen bij dat beroep.
Python is een krachtige taal, die goed te lezen is.
De taal is enorm veelzijdig en speelt in heel veel toepassingen in het dagelijks leven een rol.
Het een van de meest gebruikte taal bij bijvoorbeeld Google, Amazon en Instagram.
Omdat het zo een populaire taal is zijn er veel programmeurs die dagelijks nieuwe spannende toepassingen maken.
De taal kom je veel tegen in de wereld van data science, kunstmatige intelligentie, webscrapen en data-gebaseerd onderzoek.
Python is een erg geschikte taal om mee te starten.Deze cursus is richt zich enerzijds op mensen die willen beginnen met het programmeren zonder voorkennis.
Anderzijds is de training geschikt voor mensen die bekend zijn met een andere programmeertaal en de syntax van Python willen leren kennen.
Ook professionals die veel werken met programmeurs, kunnen zich met deze cursus goed een beeld vormen bij dit mooie beroep.Introductie met programmeren
Installeren en runnen
Variabelen
Functies en methoden
Argumenten en Parameters
Objecten en klassen
Operatoren (Wiskundig, Logisch, Vergelijkend, etc)
Typering van Variabelen
Data slicing
Condities
Loops
Array
Randomgenerators
Functies
Error handling
Externe librariesAan deze training is geen examen verbonden.
Wel wordt een certificaat van deelname afgegeven.
€1.695
Klassikaal
max 12
3 dagen