Weinig technische keuzes roepen zoveel sterke meningen op als deze. Vraag een zaal vol ontwikkelaars of een nieuwe app native of cross-platform moet worden. Je hoort over prestaties, over „gevoel”, over een framework dat iemand in 2019 in de steek liet. Wat je minder vaak hoort, is de vraag die meestal de doorslag geeft: wat heeft deze app nodig?

Voor de meeste producten is het eerlijke antwoord minder dramatisch dan het debat doet denken. Zo denken wij erover.

Waar de keuze echt over gaat

Native betekent elk platform bouwen in een eigen taal en gereedschap: Swift en SwiftUI voor iOS, Kotlin en Jetpack Compose voor Android. Twee codebases, elk met directe toegang tot alles wat het platform biedt.

Cross-platform betekent één codebase die op allebei draait. De twee frameworks die de meeste teams overwegen, werken verschillend. React Native, dat wij gebruiken, toont echte componenten van het platform en laat je native code schrijven waar dat nodig is. Flutter tekent een eigen interface met een eigen engine. Het ziet er dus overal hetzelfde uit, tenzij je het laat aanpassen.

Er is ook een derde optie die je makkelijk vergeet: het web. Een goed gebouwde webapp die op het beginscherm wordt gezet, dekt verrassend veel gevallen. Zolang hij geen diepe toegang tot het apparaat nodig heeft.

Daartussen zit een vierde aanpak: deel de logica, niet de interface. Met Kotlin Multiplatform bijvoorbeeld gebruiken beide apps dezelfde bedrijfsregels en dezelfde omgang met gegevens. Elke app tekent zijn schermen met het gereedschap van het eigen platform. Het past bij teams die een volledig native interface willen, zonder alles daaronder twee keer te schrijven.

Dit zijn geen kwaliteitsniveaus. Elk is een andere afweging, en welke past, hangt af van het product.

Waar cross-platform de juiste standaard is

Een groot deel van de apps bestaat onder de motorkap uit formulieren, lijsten, detailschermen, accounts en een verbinding met een server. De moeilijke delen zijn de gegevens, de stappen en de woorden. Die zijn op beide platforms hetzelfde.

Voor zo’n product heeft één codebase echte voordelen:

  • Eén team, één set besluiten. Een functie wordt één keer ontworpen, gebouwd, getest en nagekeken.
  • Beide platforms blijven gelijk op. Geen release waarbij Android op iOS wacht, of andersom.
  • Logica gedeeld met het web. Met React Native kunnen validatieregels, datatypes en bedrijfslogica in gedeelde TypeScript-pakketten staan, die de webapp ook gebruikt.
  • Lagere kosten van verandering. In het begin van een product, als alles nog beweegt, telt dat zwaarder dan bijna iets anders.

De componenten van het platform zijn nog steeds native. Een goed gemaakte React Native-app scrolt, navigeert en reageert dus zoals mensen op hun telefoon verwachten.

Waar native de kosten waard is

Native ontwikkeling is de extra kosten waard als het product afhangt van iets wat een cross-platformlaag moeilijker maakt:

  • Veel gebruik van platformfuncties. Widgets, apps voor horloges, schermen in de auto, diepe koppelingen met het systeem. Ze kunnen vanuit cross-platformcode, maar elk ervan betekent toch native werk.
  • Zware graphics of verwerking in realtime. Games, augmented reality, verwerking van geluid en beeld, waar elk beeld en elke milliseconde telt.
  • Als eerste nieuwe functies van het besturingssysteem hebben. Nieuwe mogelijkheden komen eerst in de native gereedschappen. Concurreert je product erop dat het ze op de eerste dag heeft, dan wil je geen laag ertussen.
  • Twee verschillende producten. Moeten de versies voor iOS en Android wezenlijk anders werken, niet alleen in details, dan levert een gedeelde codebase weinig meer op.

Past geen van deze bij je product, dan koop je met native vooral twee keer alles.

Wanneer het web genoeg is

Voordat je kiest tussen twee soorten apps, is het de moeite waard om te vragen of je wel een app nodig hebt. Het web heeft een groot deel van de achterstand stilletjes ingehaald. Een webapp kan op het beginscherm, offline werken en de camera gebruiken. Op iPhones kan hij sinds iOS 16.4 ook pushmeldingen ontvangen, als hij is geïnstalleerd.

Wat het web nog minder goed doet, zijn de randen. Langdurig werk op de achtergrond, diepe koppeling met het besturingssysteem, sommige toegang tot hardware, en een plek in de appwinkels, waar veel mensen nog eerst kijken. Heeft je product niets daarvan nodig, dan bereikt een webapp elk apparaat met één codebase en zonder beoordeling door een winkel. En elke update bereikt iedereen zodra hij uitkomt.

Voor ons eigen product is het openbare paspoort dat een QR-code opent, bewust een webpagina. Een koper naast een tweedehands e-bike hoort niets te hoeven installeren om de accu te controleren.

Wat mensen echt merken

Mensen die je app gebruiken, weten niet waarmee hij is gebouwd, en het kan ze ook niet schelen. Wat ze merken, is concreet. Hoe lang het openen duurt. Of het scrollen hapert. Of tekstvelden werken zoals elk ander veld op hun telefoon. Of het terugveeggebaar gaat waar ze verwachten. Een native app kan dat allemaal fout doen, en een cross-platformapp kan het allemaal goed doen. Het framework bepaalt het plafond. De zorg daarbinnen bepaalt waar de app echt uitkomt.

Van gedachten veranderen is duur

Deze keuze is moeilijk terug te draaien. Van cross-platform naar native gaan, of andersom, betekent meestal de interfacelaag opnieuw bouwen, wat het migratieplan ook belooft. Kies daarom voor het product dat je over twee jaar verwacht, niet voor het product dat je over tien jaar zou willen hebben.

Het pleit er ook voor om de nooduitgangen open te houden. Met React Native kun je één scherm of module native schrijven als dat nodig is. Kiezen voor cross-platform sluit native dus niet uit waar het ertoe doet.

Wat we kozen voor onze eigen app

De mobiele app van het E-Bike Battery Passport is gebouwd met Expo en React Native, in dezelfde TypeScript als het webportaal ernaast. Hij scant QR-codes met de camera en houdt een versleutelde cache bij, zodat een werkplaats dossiers zonder verbinding kan openen. Ook ontvangt hij pushmeldingen. Elk daarvan is een native mogelijkheid, en ze werken allemaal vanuit de gedeelde codebase via native modules.

De native delen verdwijnen niet

Cross-platform betekent niet dat je nooit aan het platform komt. De versleutelde offline cache van de app hangt af van een native databasemodule. Daarom draait de app niet in een webbrowser, ook al kan Expo voor het web bouwen. Een build zonder die module moet dat merken voordat hij hem probeert te gebruiken, niet door te crashen:

import { requireOptionalNativeModule } from 'expo';

// Vraag of deze build de native database heeft, voordat je hem laadt.
// Hem importeren op een build zonder zou bij het laden mislukken; dit geeft null.
async function loadSqlite() {
  if (!requireOptionalNativeModule('ExpoSQLite')) return null;
  return import('expo-sqlite');
}

Zulke controles zijn gewoon in een cross-platformapp. Het zijn de naden waar één codebase twee platforms raakt, en ze verdienen dezelfde zorg als elke andere grens.

Apparaten hebben nog steeds het laatste woord

Geautomatiseerde tests die schermen tonen, vertellen je wat een scherm laat zien en wat een tik verandert. Ze zien niet het camerabeeld, de sleutelopslag, een vraag om toestemming of hoe een indeling op een echt scherm staat. Daar is nog steeds een echte telefoon in een echte hand voor nodig, bij elke wijziging die het apparaat raakt. Eén codebase halveert de code. Het testen halveert hij niet.

Eén codebase, twee platforms, verschillende kosten

Uitbrengen in beide winkels is meer dan code. Elk platform heeft een eigen ontwikkelaarsprogramma, beoordeling, ondertekening en verspreiding voor tests. Android en iOS kunnen op verschillende momenten komen, om redenen die niets met de app zelf te maken hebben. Voor onze eigen app kwam Android eerst. iOS volgt zodra de verspreiding aan de kant van Apple op orde is. Een cross-platformcodebase maakt dat tweede platform veel goedkoper, maar niet gratis.

De afwegingen naast elkaar

AfwegingCross-platformNative
CodebaseEén, gedeeld, vaak met het webEén per platform
TeamEén team voor beide platformsSpecialisten per platform, of twee keer het werk
Uiterlijk en gedragNative componenten met React Native; getekend door FlutterPrecies dat van het platform zelf
Functies van het apparaatVia modules, met native code waar nodigDirect, en als eerste bij nieuwe
PrestatiesGenoeg voor de grote meerderheid van appsRuimte voor graphics en werk in realtime
Kosten van veranderingEén wijziging, beide platformsElke wijziging twee keer

Vragen voordat je kiest

Begin niet bij een technologie, maar bij het product:

  1. Wat heeft de app nodig van het apparaat? Zet de mogelijkheden op een rij: camera, locatie, werk op de achtergrond, opslag, meldingen. Controleer elk ervan bij het framework dat je overweegt.
  2. Hoe verschillend moeten de twee versies zijn? Is het antwoord „alleen in kleine details”, deel dan de code.
  3. Is er een webproduct naast? Gedeelde types en logica voor web en mobiel zijn een van de sterkste argumenten voor React Native.
  4. Wie onderhoudt het over twee jaar? Een codebase die het team gezond kan houden, wint van een theoretisch betere die het niet kan.
  5. Wat kost het om te laat te zijn? Doet een nieuwe functie van het besturingssysteem op de eerste dag ertoe voor je gebruikers, dan wijst dat naar native.

Het antwoord is meestal saai

Voor de meeste zakelijke apps is cross-platform de verstandige standaard, met native code op de paar plekken waar het product het apparaat direct nodig heeft. Voor producten waarvan de waarde de ervaring op het apparaat zelf is, betaalt native zich terug. De fout is een van beide kiezen voordat je weet wat voor product je bouwt.

De beste keuze is die waar je niet meer aan denkt als hij eenmaal is gemaakt. Omdat de app werkt, het team hem kan veranderen, en de mensen die hem gebruiken zich nooit afvragen waarmee hij is gebouwd.