JarnoVogelzang

Tijdens het bouwen van webapplicaties bouw ik vaak hetzelfde type applicaties. Meestal gaat het om een REST API backend samen met een frontend gebouwd in een van de vele Javascript frameworks. Voor de backend kies ik graag Symfony en voor de frontend VueJS. Tijdens het ontwikkelen bouw ik vaak dezelfde functionaliteit. Het opzetten van de REST API vereist namelijk altijd authenticatie, authorizatie en het omzetten van de database data naar API data. Nu denk ik dat dit bouwproces effectiever kan. Vandaar mijn tip: maak slim gebruik van de juiste libraries bij het opzetten van webapplicaties.

Waarom zou je niet alles zelf bouwen?

Waarom zou je gebruikmaken van bibliotheken in plaats van alles zelf te bouwen? Ik denk dat daar 3 goede redenen voor zijn:

• Bibliotheken en vooral frameworks hebben vaak een groot ecosysteem rondom zich. Neem nu bijvoorbeeld Symfony. Symfony heeft heel veel Bundles waarmee je gemakkelijk veelvoorkomende functionaliteit toevoegd aan jouw applicatie. Hierdoor hoef je veel componenten niet zelf te schrijven en kun jij je focussen op de belangrijkere zaken.
• Bibliotheken zijn goed getest door vele gebruikers. Wanneer je zelf code schrijft en daarvoor ook de tests schrijft, benader je de applicatie op 1 specifieke manier. Wanneer je meerdere miljoenen gebruikers hebt die dezelfde bibliotheken al getest hebben, kun je er zeker van zijn dat deze code robuust is.
• Door gebruik te maken van standaardoplossingen, bespaar je veel tijd en geld. Stel je voor dat je tijdens het bouwen van de applicatie alleen dat gedeelte hoeft te bouwen die de extra waarde voor jouw eindgebruiker toevoegd. Dat scheelt tijd, geld en maakt het werk denk ik een stuk leuker.

Ik denk zelf dat de derde reden vooral een goede is. Als je sneller applicaties kunt bouwen, kan de eindgebruiker de applicatie ook sneller gebruiken. En daardoor kun jij weer sneller aan nieuwe projecten werken. Kortom, iedereen wint. En daar gaat het voor mij om in de softwareontwikkeling.

Hoe werkt dat specifiek?

Eigenlijk is het gebruiken van de juiste bibliotheken best eenvoudig. Stel, je komt erachter dat je steeds dezelfde functionaliteit bouwt tijdens het ontwikkelen. Dan ga je natuurlijk kijken of er standaardoplossingen zijn die deze functionaliteit al ingebakken hebben en gebruik je die. Een voorbeeld hiervan is een Symfony dependency die ik zelf vaak gebruik genaamd ‘Api Platform‘. Api Platform is een framework binnen Symfony wat het ontwikkelen van HTTP API’s (erg) versnelt.

Als je Api Platform gebruikt hoef je zelf niet meer de REST endpoints te bouwen voor jouw applicatie. Api Platform genereert op basis van metadata de endpoints automatisch. Dat gebeurd door middel van PHP Annotations. Een voorbeeld hiervan is de volgende code. Dit is een zogeheten Doctrine entity die een to-do entiteit representeert:

<?php

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Serializer\Annotation\Groups;
use ApiPlatform\Core\Annotation\ApiResource;

/**
 * @ApiResource
 * @ORM\Entity
 */
class ToDo {
  /** 
   * @ORM\Column(type="string") 
   * @Assert\NotBlank
   * @Groups({"todo:read", "todo:write"})
   */
  private string $name;

  public function getName(): string 
  {
     return $this->name;
  } 

  public function setName(string $name): void 
  {
     $this->name = $name;
  }
}

Zoals je kunt zien is de code geannoteerd met zowel Doctrine als Api Platform annotations. Api Platform ‘leest’ deze annotations en genereert op basis daarvan een REST API. Hoe werkt dat? In dit scenario is de class geannoteerd met ‘@ApiResource’. Hierdoor weet Api Platform dat deze resource een REST resource is. Vervolgens bouwt het hiervoor de CRUD (Create, Read, Update, Delete) operations. Deze kun je vervolgens in jouw front-end code gebruiken.

Het idee van automatiseren van deze ontwikkelprocessen komt denk ik vaak neer op het schrijven van de juiste metadata. In het voorbeeld hierboven genereert Doctrine alle databasetabellen op basis van de annotations die ze uitleest. Deze annotations zijn de metadata die Doctrine nodig heeft. Doctrine ziet bijvoorbeeld dat de entiteit ToDo (en daarmee de tabel ’todos’) een kolom ‘name’ heeft wat een ‘string’ type is. Door deze specifieke metadata is een groot gedeelte van de code te genereren en daar zit denk ik de sleutel.

Dus de volgende keer dat je denkt: ik bouw wel heel vaak hetzelfde, vraag jezelf dan af of je dit proces kunt automatiseren. Dat kan door middel van een goeie bibliotheek, maar je kunt uiteraard ook zelf een abstractie schrijven die dit proces automatiseert. Tot volgende week!