1  H1: Xcode en Swift — je eerste app

Voordat we beginnen met bouwen, hebben we gereedschap nodig. Een timmerman heeft een hamer, een kok heeft een mes — en een programmeur gebruikt een code-editor. De code-editor gebruiken we om onze code te schrijven. Programmacode kan in veel verschillende talen worden geschreven. Programmeertalen zijn vergelijkbaar met de verschillende talen die jij kent (Frans, Engels, Nederlands). De taal die wij in dit boek gebruiken zijn Swift en SwiftUI. Onze code schrijven we in Xcode. In dit boek leer jij programmeren in de taal Swift en SwiftUI.

Swift is de programmeertaal die we in dit boek gebruiken. Apple bracht Swift uit in 2014, en sindsdien is het een open source project — iedereen kan meekijken en meewerken aan de taal via swift.org. De naam is niet toevallig: swift is Engels voor snel. Het logo is een gierzwaluw — een vogel die bekendstaat als een van de snelste ter wereld.

SwiftUI is het onderdeel waarmee je bepaalt hoe je app eruitziet — knoppen, teksten, lijsten, alles wat je op het scherm ziet. SwiftUI is van Apple en werkt nauw samen met Swift.

Het Swift-logo

1.1 Wat is een app?

Een app is een afkorting van applicatie — gewoon een ander woord voor programma. Een app is een lijst stappen die je aan de computer geeft. Denk aan een recept: een recept vertelt een kok stap voor stap wat hij moet doen. Een app doet hetzelfde, maar dan voor een computer.

Die stappen schrijf je in een programmeertaal. Er bestaan veel verschillende programmeertalen. In dit boek gebruiken wij de programmeertaal Swift. Een computer begrijpt Swift niet rechtstreeks. Een computer werkt alleen met enen en nullen: schakelaartjes die aan of uit staan. De Swift code die jij schrijft wordt in Xcode vertaald naar die enen en nullen. Het resultaat is een programma, dat is dus een bestand dat de computer kan uitvoeren.

Op een Mac eindigt zo’n bestand op .app. Als je op het icoontje dubbelklikt, voert de computer alle stappen precies zo uit als jij ze hebt opgeschreven.

1.2 Wat gaan we bouwen?

Aan het einde van dit hoofdstuk heb je een werkende app op je Mac staan. De app doet nog niet veel — hij toont een tekst op het scherm — maar alles wat we later bouwen, begint hier.

Dit gaat niet vanzelf. Je zult dingen tegenkomen die je nog niet begrijpt, en dat is precies de bedoeling. Programmeren leer je niet door te lezen, maar door te doen. Typ de code over, kijk wat er gebeurt, en pas iets aan. Als het fout gaat, zoek je uit waarom. Zo leer je het snelst.

De app die we aan het einde van dit hoofdstuk bouwen

1.3 Xcode installeren

Xcode is het programma waarmee je Swift-apps maakt. Het is gratis en staat in de App Store. Xcode is een IDE — een Integrated Development Environment, of geïntegreerde ontwikkelomgeving. Dat betekent gewoon dat alles wat je nodig hebt op één plek zit: een editor om code te schrijven, een manier om je app te starten, en hulp bij het opsporen van fouten.

1. Open de App Store op je Mac
2. Zoek op Xcode
3. Klik op Installeren (het bestand is groot — dit duurt even)

Als Xcode klaar is kun je het vinden in de map Applicaties of open je het via Spotlight: druk op Cmd+Spatie en typ “Xcode”.

NoteVerdieping: wat doet een IDE?

Xcode is een IDE — een Integrated Development Environment. Dat is één programma met verschillende functies:

• Schrijven van code — wij schrijven in de talen Swift en SwiftUI
• Testen — ingebouwde mogelijkheden om je app te testen
• Debuggen — opsporen en corrigeren van fouten
• Compileren en uitvoeren — code vertalen naar iets wat de computer begrijpt, en dan starten

1.4 Playground-voorbeeld

Voordat we in de app duiken, probeer je dit in een Xcode Playground. Een Playground is een plek binnen Xcode waar je code kunt uitproberen zonder een hele app te hoeven bouwen. Je typt een regel, drukt op play, en ziet meteen het resultaat. Ideaal om nieuwe dingen te leren.

Open Xcode, kies File > New > Playground, selecteer het platform macOS en het template Blank. Sla het op als MyPlayground.

Je ziet nu twee regels standaardcode:

import Cocoa

var greeting = "Hello, playground"

import Cocoa laadt een verzameling macOS-functies. Je hoeft nu nog niet te begrijpen wat dat precies betekent — het staat er omdat Xcode het automatisch invult voor macOS. De tweede regel maakt een variabele aan, iets wat we zo meteen uitleggen.

1.4.1 De Playground-indeling

Een Playground bestaat uit drie delen:

De indeling van een Xcode Playground

• Links: de code-editor — hier schrijf je je Swift-code
• Rechts: de resultaten — Xcode toont per regel de uitkomst van je code, direct naast de regel zelf
• Onderaan: de uitvoer — hier zie je wat print() op het scherm zet

Zie je de resultaten aan de rechterkant niet? Druk eerst op de play-knop zodat de code eenmalig draait — pas daarna worden de resultaten zichtbaar. Zet ze aan of uit via Editor > Results of met de sneltoets Option+Cmd+Enter.

Zie je de uitvoer onderaan niet? Klik dan op View > Debug Area > Show Debug Area of gebruik de sneltoets Cmd+Shift+Y.

import Cocoa

var greeting = "Hello, playground"

Wat gebeurt er als je "Hello, playground" vervangt door "Hello world!"?

NoteVerdieping: waarom “Hallo wereld”?

Bijna elk programmeerboek begint met het woord “Hallo wereld!” op het scherm zetten. Dat is geen toeval. In 1978 schreven Brian Kernighan en Dennis Ritchie het boek The C Programming Language — een van de meest invloedrijke programmeerboeken ooit. Zij gebruikten “Hello, World!” als eerste voorbeeld. Sindsdien is het een traditie geworden: je eerste programma laat de computer iets zeggen. Het is een manier om te bewijzen dat alles werkt — de code-editor, de vertaling naar enen en nullen, en het scherm. Als “Hallo wereld!” verschijnt, weet je: het werkt.

1.4.2 Eerste code

Je mag zelf code schrijven. Je leert het beste door zelf de code over te typen en te zien wat er gebeurt. Verwijder alle regels code en vervang ze door:

var naam = "Pim"
var score = 42
print(naam)
print(score)

Hieronder leggen we uit wat er allemaal gebeurt. Geef niet op, alles wordt duidelijk. Echt waar.

De computer kan in het geheugen dingen onthouden. Het geheugen kan je je voorstellen als een rij met allemaal vakjes. In die vakjes kan je iets opslaan. De Swift code die je net hebt getypt wordt door de computer van boven naar beneden gelezen, net als een boek. Lees maar mee.

De computer slaat het woord "Pim" op in een geheugen vakje en dat vakje noemen we naam. Ook slaan we het getal 42 op in een vakje, dat vakje noemen we score. De naam en de score staan nu in het geheugen van de computer. Later kunnen we weer aan de computer vragen wat de naam was en wat de score was.

Met print(naam) vragen we de computer om de inhoud van het vakje naam te laten zien. Met print(score) vragen we de computer om de inhoud van het vakje score te laten zien.

Later zullen we uitleggen waarom we het woordje var gebruiken en waarom de tekst "Pim" wel aanhalingstekens heeft en het getal 42 niet.

1.5 Iets onthouden

1.5.1 Heb jij commentaar?

Je ziet in veel codevoorbeelden regels die beginnen met //. Dat zijn commentaarregels. Swift leest ze wel, maar doet er niets mee — ze zijn puur voor jou als lezer. Als je naar je code kijkt die je vroeger hebt geschreven weet je soms niet meer waar het over gaat. Commentaar helpt je herinneren. Commentaar is een geheugen steuntje voor jezelf en andere die jou code lezen.

Swift kent drie soorten commentaar:

• // — alles op deze regel na de twee schuine strepen is commentaar
• /* ... */ — alles tussen deze tekens is commentaar, ook als het meerdere regels beslaat
• /// — documentatiecommentaar, bedoeld om functies en types te beschrijven (gebruikt Xcode voor zijn ingebouwde hulp)

In dit boek gebruik je vrijwel alleen //. Je ziet het ook terug in codevoorbeelden om te laten zien wat een regel oplevert, zoals // Hallo. De andere twee soorten kom je soms tegen als je de code van anderen leest.

1.5.2 Variabelen: var

Stel je voor dat in het geheugen van je computer heel veel vakjes staan, allemaal naast elkaar. Elk vakje heeft een label bovenop, zodat je weet wat erin staat. Stel je voor dat je een vakje wilt gebruiken om de leeftijd van iemand op te slaan. Je geeft dat vakje dan het label score. In dat vakje zet je het getal 42. Later kun je de inhoud van dat vakje veranderen, bijvoorbeeld naar 43. In Swift noem je zo’n vakje met een label een variabele. Een variabele maak je met het woord var. Dat is een afkorting voor “veranderlijke waarde.”

var naam = "Pim"
var score = 42
print(naam)
print(score)

Hierboven hebben we 2 verschillende variabelen gemaakt. 1 variabele met het label naam en 1 variabele met het label score. De variabelen naam en score zijn aangemaakt door het woord var. Dus je typt var om een variabele te maken. Daarna typ je hoe de variabele moet heten, bijv. naam. Dan kun je aan de andere kant van het = teken beschrijven wat er in de variabele moet staan.

De naam van elke variabele moet uniek zijn, er mag maar 1 vakje naam heten en er mag maar 1 vakje score heten. Als je toch een variabele wil maken die al bestaat zal je een fout zien. De computer stopt dan met het lezen van je code.

var naam = "Pim"
var naam = "Bas" // dit kan niet, 'naam' bestaat al
var score = 42
print(naam)
print(score)

Hierboven maken we twee keer een variabele naam. Je zult zien dat Xcode in de code met een rood kruis en in de uitvoer aangeeft dat iets niet goed is. Probeer het zelf. Je gaat steeds beter leren om fouten te herkennen.

Twee variabelen met de zelfde naam in een Xcode Playground

Je kunt dus niet een variabele met dezelfde naam maken. Je kunt de inhoud van een variabele wel veranderen. Typ het volgende over en probeer te volgen wat er gebeurt.

var naam = "Pim"
var score = 42
print(naam)
print(score)

// hier krijgt Pim 1 extra punt
score = score + 1
print(score)

We lezen de code van boven naar beneden. Er zijn 2 variabelen: naam en score. De variabele score heeft de waarde 42 gekregen toen hij gemaakt werd. We zien dat de eerste print(score) bij de uitvoer laat zien dat de waarde 42 is. Daarna gaan we een nieuwe waarde in score zetten. We slaan de som van score + 1 op in de variabele score. Nu is de score 43 geworden.

De score verandert in de Playground

1.5.3 Constanten: let

Een var kun je later nog veranderen, de score mag van 42 naar 43 gaan. Maar soms wil je dat een waarde nooit meer verandert — zoals je geboortedatum. Om informatie op te slaat die nooit meer mag veranderen gebruik je let — Engels voor “laten”, zoals in “laat dit altijd zo zijn”.

let naam = "Pim"
let geboorteJaar = 2016
print(naam)
print(geboorteJaar)

Typ het bovenstaande in bij je Xcode Playground en dan gaan we daarmee aan de slag.

Constanten in een Xcode Playground

Het geboorteJaar is aangemaakt als een let, een waarde die nooit meer verandert. Nu willen we toch het geboorteJaar van Pim aanpassen. Als we dit proberen, geeft Swift meteen een foutmelding:

let naam = "Pim"
let geboorteJaar = 2016
print(naam)
print(geboorteJaar)
geboorteJaar = 2015

Swift geeft een fout als je een constante probeert te veranderen

Dat is precies de bedoeling. Swift beschermt je: als iets niet mag veranderen, zorg je ervoor dat het ook echt niet kan veranderen. Dit voorkomt verrassingen later in je code.

De vuistregel: gebruik let tenzij je zeker weet dat de waarde moet kunnen veranderen. Je naam verandert niet, dus let naam = "Pim" klopt. Je score verandert wel, dus var score = 0 klopt. Swift waarschuwt je zelfs als je var gebruikt maar nooit iets verandert.

1.6 Types

In Swift heeft elke waarde een type — het soort waarde dat erin past. Je kunt geen getal opslaan waar tekst verwacht wordt — dat is alsof je je naam invult op een plek waar je leeftijd hoort. Er bestaan veel verschillende soorten types, dit zijn de belangrijkste om mee te beginnen.

Type	Wat het is	Voorbeeld
String	Tekst	"Hallo", "EnergyClock"
Int	Heel getal	42, -5, 0
Double	Getal met decimalen (achter de komma)	3.14, 98.6
Bool	Waar of niet waar	true of false

De namen van de types hebben elk een herkomst: String is Engels voor “reeks” — een reeks tekens achter elkaar. Int is een afkorting van het Latijnse integer, dat “heel” of “ongedeeld” betekent. Double staat voor double precision (dubbele precisie), waarmee je getallen met cijfers achter de komma nauwkeurig kunt opslaan. Bool is vernoemd naar de wiskundige George Boole (1815–1864), die de logica van waar en niet-waar als wiskundig systeem beschreef.

Swift bepaalt zelf het type op basis van wat je invult. Schrijf je var leeftijd = 9, dan ziet Swift een getal zonder komma en kiest Int. Dit heet type-inferentie.

Je mag het type ook zelf opschrijven, achter een dubbele punt:

var leeftijd: Int = 9
var naam: String = "Pim"
var temperatuur: Double = 36.6
var isActief: Bool = true

Dat is meer schrijfwerk, maar soms maakt het de code duidelijker — zeker als de waarde niet meteen voor de hand ligt.

Typen mogen niet wisselen. Zodra Swift het type van een variabele weet — of je het nu zelf opschrijft of Swift het afleidt — zit dat vast. Je kunt daarna niet wisselen naar een ander type. Dit geeft een fout:

var score: Int = 10
score = "tien"  // Fout: een Int accepteert geen tekst

score is een Int, en dat blijft zo. Je kunt de String “tien” niet in een Int stoppen.

1.7 Regels voor toewijzen

De aanhalingstekens om "tien" zijn belangrijk. De aanhalingstekens om “tien” zorgt ervoor dat Swift weet dat het een String is (door type-inferentie). Zonder aanhalingstekens denkt Swift dat tien de naam van een variabele is — en die bestaat niet. Met aanhalingstekens weet Swift: dit is gewoon tekst. Zo schrijf je altijd tekst in Swift: “tussen dubbele aanhalingstekens”.

Een naam mag niet beginnen met een cijfer. var 2deNaam = "Bastiaan" geeft een fout. Swift zou dan niet meer weten of 2 een getal is of het begin van een naam. Daarom moet een naam altijd beginnen met een letter.

Spaties om het = teken mogen, maar hoeven niet. var naam = "Pim" en var naam="Pim" zijn voor Swift precies hetzelfde. Met spaties is het wel makkelijker te lezen, dus dat doen we in dit boek altijd zo.

Namen mogen geen spaties bevatten. Dat klinkt lastig, maar programmeurs hebben daar een oplossing voor bedacht: camelCase. Je plakt alle woorden aan elkaar en begint elk volgend woord met een hoofdletter. Zo wordt “is klaar” dus isKlaar, en “maximale score” wordt maximaleScore. De naam komt van de kameel: die hoofdletters in het midden zijn de bulten. Een kameel met één bult (isKlaar) heet een dromedaris, maar dat zegt niemand hardop tijdens het programmeren.

Al deze regels klinken streng, maar het is een voordeel: Swift pakt dit soort fouten al tijdens het schrijven van de code, nog voordat je de app ooit opstart.

NoteVerdieping: types, geheugen en snelheid

Het geheugen van een computer slaat informatie op in bits. Een bit kan aan of uit staan — ook wel 1 of 0, of waar of niet waar. Een groep van 8 bits noemen we een byte. Moderne computers verwerken informatie in grote groepjes tegelijk — een huidige Mac werkt met 64 bits (8 bytes) per stap.

Elk type neemt een vaste hoeveelheid geheugen in. Een Bool bevat maar één bit aan informatie, maar neemt net als andere kleine types toch een hele byte in het geheugen in. Een Int en een Double gebruiken allebei 8 bytes (64 bits), maar een Double vraagt meer rekenkracht omdat getallen achter de komma lastiger te berekenen zijn dan hele getallen. Een String is het meest wisselvallig: hoe langer de tekst, hoe meer bytes hij inneemt.

Omdat een Int 64 bits gebruikt, kan hij heel grote getallen bijhouden. Met 64 bits kun je 2⁶⁴ combinaties maken — dat zijn ruim 18 triljoen mogelijke waarden. De helft daarvan is negatief, zodat het grootste positieve getal uitkomt op 9.223.372.036.854.775.807. Ter vergelijking: als je elke seconde één getal optelt, duurt het meer dan 290 miljard jaar voordat je dat getal bereikt. Voor bijna alle programma’s is dat meer dan genoeg.

Toch heeft Swift ook kleinere varianten: Int8 (8 bits, dus 2⁸ = 256 waarden, maximaal 127), Int16 (maximaal 32.767) en Int32 (maximaal ruim twee miljard). Die gebruik je wanneer geheugen echt kostbaar is — bijvoorbeeld in een app voor een klein apparaatje dat duizenden metingen per seconde opslaat. Op een gewone Mac kies je standaard gewoon Int.

Voor één variabele maakt dat nauwelijks verschil. Maar stel dat je app een lijst bijhoudt van een miljoen stroomprijzen. Dan is het verschil tussen Int en Double ineens merkbaar — zowel in geheugengebruik als in snelheid.

Daarom is het goed om het juiste type te kiezen. Gebruik Int als je geen cijfers achter de komma nodig hebt, en Double alleen als de precisie echt nodig is. Swift helpt je daarbij: als je var score = 10 schrijft, kiest Swift automatisch Int en niet Double. Dat is niet toevallig — het is de slimmere keuze.

1.8 Apple documentatie

Bij elk programma hoort documentatie: een beschrijving van hoe alles werkt. Denk aan een handleiding, maar dan voor andere programmeurs. Als je een nieuwe functie tegenkomt en je weet niet wat hij doet, zoek je het op in de documentatie. Dat is normaal — ook ervaren programmeurs doen dat elke dag. Je hoeft niet alles te onthouden; je moet alleen weten waar je het kunt vinden.

Je zult merken dat Swift vol staat met Engelse termen: var, let, print, String. Dat is geen toeval. Programmeren is ontstaan in de Engelstalige wereld, en Swift is gemaakt door Apple — een Amerikaans bedrijf. De hele programmeergemeenschap wereldwijd gebruikt Engels als gemeenschappelijke taal. Een Nederlandse developer en een Japanse developer kunnen elkaars code lezen, juist omdat alles in het Engels staat.

De documentatie van Apple is dan ook volledig in het Engels. Kom je een term tegen die je niet begrijpt, kijk dan in de woordenlijst achter in dit boek. Daar staan de belangrijkste termen kort uitgelegd in het Nederlands.

Apple heeft documentatie voor alles in Swift en SwiftUI:

developer.apple.com/documentation/swift

Hoe gebruik je die? Zoek op de naam van iets wat je wilt begrijpen — bijvoorbeeld String of Int. Je vindt dan een uitleg en voorbeelden van Apple zelf.

Handige truc in Xcode: houd Option ingedrukt en klik op een woord in je code. Er verschijnt direct een klein venster met uitleg — zonder dat je naar de browser hoeft.

Documentatievenster na Option+klik op print()

1.9 Je eerste Xcode-project

Nu je de basis kent, is het tijd om een echt Xcode-project aan te maken. Een project is de map waarin Xcode alle bestanden van je app bewaart.

Als je Xcode opstart, zie je een welkomstscherm. Klik op Create New Project.

Kies daarna platform macOS en het template App:

Kies macOS en App als template

Vul de gegevens in en laat de rest op de standaardwaarden staan:

Projectopties invullen

Veld	Wat je invult
Product Name	MijnEersteApp
Organization Identifier	com.jouwnaam (gebruik je eigen naam, zonder spaties)
Interface	SwiftUI
Language	Swift

De andere velden — Team, Testing System en Storage — laat je op de standaardwaarden staan. Het Bundle Identifier vult Xcode zelf in op basis van wat je hierboven invult.

Klik op Next en sla het project op.

1.9.1 De drie belangrijkste onderdelen

Xcode heeft veel onderdelen, maar je hebt er maar drie nodig:

De drie zones van Xcode

1. Links: de bestandenlijst — hier staan alle bestanden van je project
2. Midden: de code-editor — hier schrijf je je code
3. Rechts: de preview — hier zie je direct hoe je app eruitziet

1.9.2 Je eerste App

Klik op ContentView.swift in de bestandenlijst. Je ziet zoiets:

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
        }
        .padding()
    }
}

Verander "Hello, world!" in "Hallo, ik programmeer Swift!". Kijk rechts in de preview — Xcode vernieuwt die automatisch.

Zie je de preview niet? Zet de canvas aan met Option+Cmd+Enter, of via het menu Editor > Canvas.

Soms stopt de preview met herladen, ook als je gewoon typt. Klik dan op de knop Resume die in beeld verschijnt, of gebruik de sneltoets Option+Cmd+P. Dat herstart de preview zonder dat je de hele app opnieuw hoeft te starten.

Later in het boek leggen we precies uit wat struct, View, VStack en Text betekenen. Voor nu is het genoeg om te weten dat dit de bouwstenen zijn van je app.

Xcode met je eerste app en de preview

Je ziet rechts in de preview een voorbeeld van de code die je hebt geschreven maar dit is nog geen app. Je kunt je app bouwen door op de Play-knop te drukken, of te kiezen voor Product > Run, of te drukken op Command+R. Je eerste app zal opstarten. Erg mooi hoor en geniet er maar even van, dat heb je verdiend.

Je eerste app draait op je Mac

NoteVerdieping: compileren en uitvoeren

Voordat Swift-code op je Mac of iPhone kan draaien, wordt hij omgezet naar een taal die de processor begrijpt. Dat heet compileren. Xcode doet dit met een Build. Als je op Run klikt (Play-knop, via het menu of Command+R) dan doet Xcode een Build en Run.

Tijdens het compileren controleert Swift ook alle types. Klopt er iets niet — een String waar een Int verwacht wordt — dan stopt de compiler met een foutmelding. Dit heet een compile-time error, in tegenstelling tot een runtime error die pas opduikt als de app al draait.

Dit is een van de grote sterktes van Swift: veel fouten worden al tijdens het bouwen gevonden, niet pas door een gebruiker van je app.

1.10 Samenvatting

In dit hoofdstuk heb je Xcode geïnstalleerd en je eerste Swift-code geschreven. Je hebt geleerd hoe je informatie opslaat: met var voor iets wat later kan veranderen, en let voor iets wat vaststaat. Elke waarde heeft een type — zoals tekst of een getal — en Swift kiest dat type meestal automatisch. Je hebt Xcode Playground en Xcode gebruikt. Tot slot heb je je eerste SwiftUI-app gemaakt en een tekst op het scherm gezet.

Begrip	Betekenis
IDE	Programma dat alles voor softwareontwikkeling op één plek samenbrengt
var	Variabele — mag veranderen
let	Constante — verandert nooit
String	Tekst
Int	Heel getal
Double	Getal met cijfers achter de komma
Bool	true (waar) of false (niet waar)
Compileren	Swift-code omzetten naar iets wat de computer begrijpt
print()	Toon een waarde op het scherm
//	Commentaar — Swift negeert deze regel, hij is voor de lezer
Type-inferentie	Swift bepaalt zelf het type op basis van de waarde
camelCase	Schrijfwijze voor namen zonder spaties: eerste woord klein, elk volgend woord met hoofdletter

1.11 Opdracht

Maak een nieuwe Xcode Playground aan via File > New > Playground (of Option+Shift+Cmd+N), kies platform macOS en template Blank. Geef hem de naam MyPlayground. Schrijf daarna een mini-programma dat drie dingen over jezelf opslaat: je naam, je leeftijd en of je al eerder geprogrammeerd hebt (true of false). Gebruik let voor dingen die niet veranderen, en var voor dingen die wel kunnen veranderen. Druk alles af met print(). Weet jij welk type de verschillende variabelen zijn?

let naam = "Pim"
var leeftijd = 12
var heeftAlGeprogrammeerd = false

print(naam)
print(leeftijd)
print(heeftAlGeprogrammeerd)

Het resultaat van de opdracht in Xcode Playground