
Het beheren van software en de machines waarop het draait kan een uitdaging zijn.
Kubernetes maakt het eenvoudig om software te beheren en uit te rollen op een cluster van machines.

## Waarom Kubernetes gebruiken?

Wij bij Ontola gebruiken Kubernetes voor de meeste van onze implementaties.

- **Uitrollen automatiseren**. Bereik _Continuous Integration_ door uw software automatisch en programmatisch uit te rollen.
- **Gemakkelijk schalen**. Laat uw cluster van machines automatisch groeien of krimpen, en schaal alleen de applicaties die dat nodig hebben.
- **Zelfherstellend**. Start containers die falen automatisch opnieuw op.
- **Hoge compatibiliteit**. Werkt met AWS, DigitalOcean, Azure, Google, en anderen.
- **Gemakkelijkere devops**. Met Kubernetes wordt het grootste deel van de logica en configuratie die nodig zijn voor het beheren van uw applicaties opgeslagen in gestandaardiseerde, herbruikbare bestanden.

## Hulp nodig?

De Kubernetes [documentatie](https://kubernetes.io/docs/home/) en [tutorials](https://kubernetes.io/docs/tutorials/) zijn een geweldige plek om te beginnen.
Als u andere hulp nodig heeft met Kubernetes om uw devops te beheren, voel u vrij om [contact op te nemen](/nl/contact)!


Cloudomgevingen beheren met Kubernetes


NextJS is een modern Framework om websites mee te bouwen.
Het combineert de flexibiliteit van moderne web applicaties met de snelheid van statische websites.
Door slim gebruik te maken van _Server Side Rendering_ (SSR), kunnen NextJS applicaties erg snel worden ingeladen in browsers.
NextJS maakt gebruik van het [React](/nl/tech/react) framework.
Hiermee worden websites gebouwd met _componenten_, welke herbruikbaar zijn.
Door deze modulaire aanpak kan een NextJS website groeien.

Deze website is ook gebouwd in NextJS.
Je kunt [de broncode op Github bekijken](https://github.com/ontola/home).

## Waarom NextJS gebruiken

- **Snel laden, snel klikken**. NextJS ondersteunt zowel static site generation (SSG), server-side rendering (SSR) als client-side rendering (CSR). Hierdoor laden NextJS applicaties extreem snel.
- **Betere SEO**. Door de korte laadtijden scoren jouw pagina's beter in zoekmachines.
- **Werkt met praktisch alle back-ends**. NextJS werkt met diverse CMS systemen en databases, zoals Stripe, Contentful, [RESTFul API's](/nl/blog/api-design),
- **Makkelijk deploybaar**. Diensten als AWS Amplify en Vercel zorgen er voor dat het hosten van NextJS applicaties erg snel gaat.
- **Vertalingen**. Je kunt NextJS websites goed laten werken in verschillende talen.
- **Snel ontwikkelen**. NextJS is fijn om mee te werken, doordat je er als ontwikkelaar in hoog tempo resultaten mee kan boeken.
- **Afbeeldingen**. NextJS zet afbeeldingen om naar de juiste groottes, zonder dat je zelf hoef te optimaliseren bij het uploaden. Dat scheelt tijd en houdt de website snel.

## Combineren met...

Je kunt er voor kiezen om je NextJS applicatie data als bestanden in Git te beheren, maar dat is niet handig als je content veel wijzigt, of als niet-programmeurs de content moeten kunnen wijzigen.
Vaak heb je dus nog een andere back-end nodig voor content management.
Je kunt diensten zoals [Contentful](https://www.contentful.com/developers/docs/compose/building-a-website-with-compose/) gebruiken, of een maatwerk back-end ontwikkelen.

## Wil jij ook een NextJS applicatie?

Neem dan contact op!


Wat is NextJS, en waarom zou je er mee werken?

NextJS website ontwikkelen


React JS is de meest populaire front-end Javascript Library om webapplicaties mee te ontwikkelen.
Het is ontwikkeld door Facebook, en daarna als Open Source library gebruikt in vele duizenden projecten.

## Waarom React gebruiken

Wij van Ontola zijn best wel fan van React - de meeste van onze projecten (waaronder deze website) zijn er daarom mee gebouwd.
In veel gevallen raden we dan ook aan om hier webapplicaties mee te ontwikkelen.

- **Herbruikbare componenten**. In React bouw je _componenten_, welke kunnen worden gedeeld tussen schermen en tussen applicaties. Zo blijft je code beheersbaar en modulair.
- **Gigantische community**. Een grote community betekent dat het makkelijk is om oplossingen te vinden als je een probleem hebt. Daarnaast zijn er zeer veel gebruiksklare componenten te vinden. Tenslotte zijn er ook veel ontwikkelaars voor te vinden!
- **Snelle ontwikkelling**. Bouwen met React gaat snel - en een productieve developer maakt een blije klant!
- **Flexibel inzetbaar**. React kan gebruikt worden van zeer dynamische, beweeglijke applicaties, tot statische websites (zoals deze).
- **Korte laadtijden**. Met React kunnen webapplicaites zowel op de server (_SSR_), als in de browser worden opgebouwd. Dit zorgt voor zeer korte laadtijden!

## Combineren met...

React is een front-end library, en heeft (vaak) dus een back-end nodig waar de data vandaan moet komen.
Een paar geschikte opties (waar wij ook veel mee werken) zijn:

<TechWrapperSmall>
  <TechPill technology="nextjs" />
</TechWrapperSmall>


React JS webapplicaties ontwikkelen


Rust is een moderne programmeertaal die snel aan populariteit aan het winnen is.
Het is _low-level_ taal met _high-level_ features, welke direct compileert naar machine-code (assembly).

## Waarom Rust gebruiken

- **Veilig**. Rust introduceert een unieke oplossing om geheugen te beheren genaamd _ownership_. Dit zorgt er voor dat Rust applicaties doorgaans zeer veilig zijn.
- **Snel**. Met Rust kan je het laatste beetje performance uit je machine halen. Het is dan ook geen verassing dat in de meeste benchmarks Rust applicaties naar voren komen als de aller snelste.
- **Compact**. Een Rust applicatie kan worden gecompileerd naar kleine binaries (uitvoerbare bestanden).
- **Draait overal**. Rust kan je compileren naar praktisch ieder platform.
- **Geen runtime nodig**. Een Rust applicatie kan je draaien _zonder externe runtime_, in tegenstelling tot talen als Python, Javascript en Java.
- **Blije programmeurs**. Rust is al sinds 2016 ieder jaar [verkozen](https://insights.stackoverflow.com/survey/2021#technology-most-loved-dreaded-and-wanted) tot meest geliefde programmeertaal, en we begrijpen waarom.

## Ownership en de Borrow Checker

De meest kenmerkende nieuwe vinding van Rust, is het concept _Ownership_ (eigenaarschap).
Het is een oplossing voor een fundamenteel aspect van hoe computers vandaag de dag werken: bijhouden welke data in je werkgeheugen kan worden losgelaten.
Als een applicatie draait, wordt er doorgaans steeds meer data in het werkgeheugen geladen.
Iedere berekening heeft werkgeheugen nodig.
Het is de verantwoordelijkheid van de software om dit werkgeheugen weer vrij te maken wanneer het kan.
Traditioneel waren twee oplossingen voor dit probleem:

1. **Handmatig memory management**. De programmeur moet in zijn code aangeven wanneer een stukje geheugen kan worden vrijgemaakt. Dit is een lastig en bovenal foutgevoelig proces, wat voor nare (onveilige) bugs kan zorgen. Zo [gaf Microsoft aan dat 70% van de beveiligings issues komen door memory management](https://www.zdnet.com/article/microsoft-70-percent-of-all-security-bugs-are-memory-safety-issues/).
1. **Garbage Collection**. De _runtime_ van de programmeertaal verwijderd af en toe stukjes data uit het werkgeheugen die niet meer nodig zijn. Dit is lekker makkelijk voor de programmeur, maar het zorgt er voor dat je code _trager_ wordt, omdat je applicatie nu ook tijd moet besteden aan het controleren van wat er weg kan worden gegooid.

Rust introduceert een derde oplossing voor memory management: _Ownership_.
In Rust, is iedere variabele (ieder stukje data in je werkgeheugen) eigendom van een bepaalde _scope_.
Wanneer een variabele deze scope verlaat, kan het stukje data uit het werkgeheugen worden gehaald.
Een elegante oplossing, want dit kost de applicatie geen extra tijd, waardoor je de volledige 100% van de theoretisch haalbare snelheid kan halen.

## WebAssembly en Rust

WebAssembly is een standaard om applicaties mee te beschrijven.
Het is niet zozeer een programmeertaal, maar een _compilation target_ (net als de eerder genoemde Assembly).
Het wordt dus (bijna) niet geschreven door mensen, maar programmeertalen kunnen er naar compileren.
Met bijna alle gecompileerde applicaties, moet er worden gecompileerd naar een specifiek _target_ (een specifieke architectuur).
Een applicatie voor Windows heeft bijvoorbeeld een andere binary dan een voor MacOS, or voor Linux.
Dit betekent dat jij als ontwikkelaar daar rekening mee met houden, en dus (behoorlijk veel) verschillende versies moet aanbieden.
Dat kost tijd, en maakt het distribueren van je applicatie een stuk ingewikkelder.

Wat WebAssembly interessant maakt, is dat het praktisch overal draait.
Dezelfde WebAssembly code draait op x86, Arm, 32bit, 64bit...
Het is ontworpen om te draaien in Browsers, als alternatief voor Javascript.
Hiermee kunnen sommige taken een stuk sneller draaien.
Daarnaast kan je zo code hergebruiken uit een programmeertaal die naar WebAssembly compileert, zonder het te hoeven herschrijven in Javascript.

Maar WebAssembly is niet _alleen_ maar interessant voor browsers.
WebAssembly _runtimes_ zijn omgevingen die WebAssembly kunnen draaien, zoals in je browser zit.
We kunnen deze runtimes ook in een server context gebruiken.
De eigenschappen die het geschikt maakt voor browsers, maakt ook een heel nieuw soort van server architectuur mogelijk.
Het start snel op, het is veilig, het is lichtgewicht.
De opkomende FaaS (Functions as a Service) architectuur bijvoorbeeld, werkt erg goed met WebAssembly.
Zo bieden Amazon met Lambda en Cloudflare met hun Workers nu al manieren om server logica te schrijven met WebAssembly.
Daarnaast is WebAssembly ook een interessante taal om een plug-in architectuur te ontwikkelen.
Al met al zijn er heel veel toepassingen voor WebAssembly die nu komende jaren aan populariteit zullen groeien.

Een van de unieke voordelen aan Rust, is hoe goed het compileert naar WebAssembly.
De gegenereerde binaries zijn snel uit te voeren, starten snel op en zijn ook compact.
De community die werkt aan WebAssembly werkt ook grotendeels in Rust, en je ziet dan ook dat er veel goede tooling is voor Rust + WebAssembly.

## Combineren met...

Rust kan werken in vrijwel alle contexten, maar het is vooral handig in server-side of embedded applicaties.
Als je een webapplicatie wil maken, en de server schrijft in Rust, heb je alsnog front-end technologie nodig
Een paar geschikte opties (waar wij ook veel mee werken) zijn:

<TechWrapperSmall>
  <TechPill technology="react" />
  <TechPill technology="nextjs" />
</TechWrapperSmall>


Wat is Rust, en wanneer zou je het moeten gebruiken?

Software ontwikkelen met Rust


## Svelte

[Svelte](https://svelte.dev/) is een modern framework om websites en webapplicaties mee te ontwikkelen.
Je kunt het zien als een soort React of Angular, maar met een aantal innovaties die het sneller en fijner maken om mee te werken.
Wij hebben in de afgelopen jaren voornamelijk met React applicaties geschreven, maar we werden toch wel erg enthousiast over Svelte nadat we het hadden uitgeprobeerd.
We merken dat het ontwikkelen in Svelte nog sneller gaat dan in React.
En wij zijn niet de enige die positief zijn over Svelte; het is [verkozen tot meest geliefde web framework](https://insights.stackoverflow.com/survey/2021#section-most-loved-dreaded-and-wanted-web-frameworks).

## SvelteKit

[SvelteKit](https://kit.svelte.dev/) biedt extra mogelijkheden bovenop Svelte, zoals routing, statische site generation (SSG) en server-side rendering (SSR).
Als Svelte een soort React is, dan is SvelteKit een soort NextJS.
Het combineert de flexibiliteit van moderne webapplicaties met de snelheid van statische websites.

## Waarom SvelteKit

- **Zeer snel**. Zowel bij het inladen, als iedere volgende klik: met Svelte(Kit) krijg je een extreem snelle website.
- **Kies je eigen back-end**. Je kunt SvelteKit op verschillende databronnen aansluiten. Kies je eigen (Headless, open source) CMS, zoals Strapi of [Atomic-Server](), of gebruik een bestaande [RESTFul API](/en/blog/api-design)
- **Makkelijk naar de edge deployen**. Cloudflare, Netflify en Vercel ondersteunen Sveltekit. Zo deploy je zeer gemakkelijk naar alle uithoeken van de wereld.
- **Snelle ontwikkelling**. Doordat Svelte(Kit) een fijne workflow heeft, gaat de ontwikkeling lekker snel.

## Wil jij een Svelte of SvelteKit applicatie?

Neem [contact](/contact) op!


Wat is Svelte, en wanneer is het verstandig om te gebruiken?

Svelte / SvelteKit website development


Typescript is een programmeertaal die verschillende features toevoegt aan het populaire Javascript.
De meest belangrijke daarvan is _type-safety_, wat inhoudt dat je als ontwikkelaar het datatype van functies en variabelen kan vastleggen.
Hierdoor worden veel fouten in code veel eerder gezien, waardoor je applicaties minder bugs hebben.

## Waarom Typescript in plaats van Javascript

Wanneer wij kunnen kiezen tussen deze twee, gaan we praktisch altijd voor Typescript.
Deze website is bijvoorbeeld ook in Typescript (met [React](/nl/tech/react) en [NextJS](/nl/tech/nextjs)) geschreven

- **Minder bugs**. Doordat je veel fouten (type-gerelateerde bugs) veel eerder tegenkomt, heb je minder bugs in productie.
- **Sneller ontwikkelen**. Met Typescript geeft je code editor vaak veel betere _autocompletions_. Dat maakt ontwikkeling sneller.
- **Snel te leren**. Als je javascript kan, kan je al het grootste deel van Typescript.
- **Front-end en back-end**. Je kunt Typescript gebruiken in de browser, omdat het compileert naar Javacsript, maar je kunt er ook server side (Node of Deno) apps mee maken.

## Bestaand Javascript project omzetten naar Typescript

Strict gezien is het een _superset_ van Javascript, wat betekent dat alle Javascript ook geldige Typescript is.
Dit betekent dat het mogelijk is om een bestaand Javascript project te pakken, en stukje bij beetje om te zetten in Typescript.
Je kunt stap voor stap de _strictness_ omhoog schroeven, en zo langzaam maar zeker je codekwaliteit verbeteren.

## Op zoek naar een Typescript ontwikkelteam?

Ontola heeft veel ervaring met Typescript, zowel in de front-end als de back-end.
Neem [contact](/nl/contact) op om je wensen te bespreken!


Wanneer is het verstandig om te kiezen voor Typescript?