WAT ZIJN DE PRO’S EN CONTRA’S TUSSEN DE PROGRAMMEERTALEN SWIFT EN OBJECTIVE-C? PROMOTOR: MH DIETER DEPREESTER PROJECT PERFORMED BY
MICHIEL DE GEETER TO ACHIEVE THE DEGREE BACHELOR IN THE
NEW MEDIA AND COMMUNICATION TECHNOLOGY HOWEST | 2015-2016
WAT ZIJN DE PRO’S EN CONTRA’S TUSSEN DE PROGRAMMEERTALEN SWIFT EN OBJECTIVE-C? PROMOTOR: MH DIETER DEPREESTER PROJECT PERFORMED BY
MICHIEL DE GEETER TO ACHIEVE THE DEGREE BACHELOR IN THE
NEW MEDIA AND COMMUNICATION TECHNOLOGY HOWEST | 2015-2016
Woord vooraf Ik ben Michiel De Geeter, laatstejaars student New Media & Communication Technology. Voor deze opleiding is er een stage voorzien van 15 weken, waarbij je tijdens de eerste 5 weken stage een bachelorproef moet schrijven. Ik heb gekozen voor een bachelorproef met een onderwerp die een connectie heeft met het vak App Development for iOS. Dit vak heb ik als optie-vak gekozen in het eerste semester van het derde jaar. Bij dit vak leerde je onder andere de programmeertaal Swift. Swift is een relatief nieuwe taal voor het ontwikkelen van IOS en OSX applicaties. Voorheen gebeurde dit altijd in Objective-C. Deze laatst vernoemde taal zal ik bijgevolg vergelijken met de programmeertaal Swift. Ik wil weten waarom Apple een nieuwe taal heeft ontwikkeld. Is dit enkel voor de software developers om het ontwikkelen van apps eenvoudiger te laten verlopen, of heeft het ook met performantie te maken, of zijn er eventueel nog andere redenen? Om dit te achterhalen zal ik de voor- en nadelen tussen de 2 programmeertalen uitzoeken en opsommen. Ik wil mijn promotor Mh Dieter Depreester bedankten om mij bij te staan in het maken van deze bachelorproef. Ook wil ik mijn zus, broer en ouders bedanken om dit werk na te lezen en tips te geven.
Samenvatting Objective-C is een programmeertaal die ontwikkeld is door NeXTSTEP. Dit is een bedrijf van Steve Jobs nadat hij bij Apple vertrokken was. Later heeft Apple dit bedrijf opgekocht en is Objective-C gebruikt voor OSX en IOS als programmeertaal om apps te bouwen voor deze operating systems. Apple vond het in 2014 tijd voor een nieuwe taal te introduceren namelijk Swift. Swift wordt momenteel gebruikt voor IOS, OSX, tvOS en watchOS apps mee te ontwikkelen. Beide talen worden geleverd met het Cocoa en Cocoa touch framework. Wat het eenvoudig zou moeten maken om over te stappen van Objective-C naar Swift. Swift heeft vele voordelen ten opzichte van zijn voorganger maar niet alles is een verbetering. Zo is Swift niet in alle opzichten sneller dan Objective-C. Vooral bij het verwijderen van elementen uit een verzameling zoals een array, dictionary en set is Swift trager. Uit de tests blijkt dat het lezen en toevoegen van elementen en het updaten van een verzameling Swift wel sneller is. Als kijken naar de syntax van Swift en Objective-C dan zien we toch heel duidelijke verschillen. Swift is veel beter leesbaar en voelt aan als een veel natuurlijkere taal. Bij het declareren van variabelen ben je niet meer verplicht om een datatype mee te geven vermits de compiler de variabelen zelf een type kan toewijzen op basis van welke data er in de variabele zit. Methoden hebben in Swift geen vierkante haakjes meer nodig. Er is nu een duidelijk onderscheid tussen de methode naam maar ook worden de paramaters nu duidelijk gescheiden door een komma. Klassen bestaan bij Objective-C uit twee bestanden: een header en een implementatie bestand. Hierdoor heb je veel meer bestanden in eenzelfde project in vergelijking met Swift waardoor je in Objective-C het overzicht veel minder kan bewaren. In Swift is een klasse één bestand waardoor je sneller een methode in een klasse kan toevoegen vermits je die maar op één plaats moet toevoegen. Enumerations en de switch operator zijn in Swift veel uitgebreider en hebben meer mogelijkheden dan in Objective-C. De uitbreidingen zijn geen gemis in ObjectiveC maar eenmaal je ze gewoon bent in Swift kan je er niet meer zonder. De API’s die in Objective-C beschikbaar zijn, zijn herschreven in Swift. Voor thirthparty API’s heeft Apple dat niet in de hand maar vermits je Objective-C en Swift in éénzelfde project kan gebruiken. Doordat je Swift en Objective-C code in eenzelfde project kan gebruiken is het ook mogelijk om Objective-C code te migreren naar Swift in stukken. Je kan bijvoorbeeld een nieuwe functionaliteiten in Swift schrijven en beetje bij beetje ObjectiveC code herschrijven naar Swift. Op security vlak wordt doordat Swift een nieuwe taal is geacht dat deze dan ook veiliger is. Enkele beveiligingsrisico’s die Objective-C bezit, zitten ook in Swift zoals buffer overflow. Het beheer van het geheugen heeft Swift veel beter op orde dan Objective-C. Bij Objective-C moet je zelf zorgen dat je het geheugen vrijmaakt. Swift heeft ondersteuning voor Automatic Reference Counting wat wil zeggen dat indien variabelen niet meer gebruikt worden deze automatisch verwijderd worden uit het geheugen.
Afkortingen WWDC: Worldwide Developers Conference API: application programming interface ARC: Automatic Reference Counting
Verklarende woordenlijst -
-
Apple's Cocoa en Cocoa Touch frameworks: Cocoa en cocoa Touch zijn de app ontwikkelingsomgevingen voor IOS en OSX. Cocoa bevat Appkit frameworks voor OSX apps. Cocoa Touch is gemaakt voor IOS apps en bevat het UIKit framework. Compiler: Een compiler is een programma die de geschreven code omzet in een andere taal. Meestal word de code omgezet naar een taal die dichter licht bij computertaal (bv. assembly) Debugger: Een debugger wordt gebruikt bij het ontwikkelen van software. Met een debugger kan je zien waar een fout optreed bij het uitvoeren van de code. Frameworks: Een framework is een universele software omgeving waarmee je specifieke functionaliteiten kan maken. Concateneren van strings: Het samenvoegen van strings tot één string is het concateneren van string.
Inhoudsopgave 1
Onderzoeksvraag................................................................................. 1
2
Objective-C......................................................................................... 2
3
Swift .................................................................................................. 3
4 Swift vs Objective-C ............................................................................ 4 4.1 Snelheid ...................................................................................... 4 4.1.1 Tests .......................................................................................... 4 4.1.2 Conclusie tests ........................................................................... 14 4.2 Syntax ...................................................................................... 15 4.2.1 Variabelen ................................................................................. 15 4.2.2 Optionals ................................................................................... 16 4.2.3 Methoden .................................................................................. 17 4.2.4 Klassen ..................................................................................... 19 4.2.5 Enumeration .............................................................................. 21 4.2.6 Switch operator .......................................................................... 22 4.2.7 Syntax conclusie ........................................................................ 23 4.3 API’s ......................................................................................... 24 4.3.1 Migratie..................................................................................... 25 4.4 Security .................................................................................... 26 4.4.1 Integer Overflow ........................................................................ 26 4.4.2 Format String Attack ................................................................... 27 4.4.3 Buffer Overflow .......................................................................... 27 4.5 Geheugenbeheer ........................................................................ 28 5
Bespreking van het project ................................................................. 29
6
Conclusies ........................................................................................ 30
7
Bronnen- & literatuurlijst .................................................................... 31
1
Onderzoeksvraag
Wat zijn de voor en nadelen van de programmeertalen Swift en Objective-C? Waarom heeft Apple Swift (de nieuwe programmeertaal voor IOS en OSX) gemaakt? Dit zijn enkele vragen aan de hand van tests en opzoekingswerk zullen worden opgelost.
1
2
Objective-C
Objective-C is een programmeertaal die gebruikt wordt voor het schrijven van software voor OSX en IOS. Deze taal is gebaseerd op de programmeertaal C waarvan het de syntax, de primitieve types en de statements heeft overgeërfd. Het definiëren van klassen en methoden daarentegen zijn toegevoegd ten opzichte van C. Objective-C was oorspronkelijk ontwikkeld voor NeXTSTEP. NeXTSTEP is een objectgeoriënteerd en multitasking besturingssysteem van NeXT. OSX en IOS zijn afgeleiden van dit OS. Steve Jobs heeft NEXTSTEP opgericht in 1985 na zijn vertrek bij Apple. In 1997 werd NeXT overgenomen door Apple waardoor het dus automatisch ook Objective-C overnam. Binnen Objective-C worden twee soorten bestanden onderscheiden. Enerzijds zijn er de ‘.h’ bestanden dewelke header bestanden zijn. Anderzijds zijn er de ‘.m’ bestanden. Dit zijn implementatie bestanden die nuttig zijn voor het initialiseren van variabelen en functies waarin andere Objective-C bron bestanden worden gebruikt om naar het bestand te verwijzen. Het is een lastige taal om te leren omdat het een moeilijke syntax heeft. Sommigen zeggen dat dit één van de redenen is waarom Apple met Swift is komen opdraven. Andere stemmen zeggen dan weer dat de taalswitch doorgevoerd is om Android de pas af te steken. Deze insteek druist echter in tegen Appels visie waardoor dit in twijfel kan getrokken worden. Dat Apple met Swift is gekomen is een goed doordachte keuze geweest. Swift is ontwikkeld omdat Apple meer controle wou hebben over de programmeertaal. Apple wil zoveel mogelijk controle over alles wat ze maken en aanbieden. Objective-C is een taal die gebaseerd is op een andere taal en waar ze dus niet voor de volle 100% controle over hebben. Met Swift is dit anders want ze hebben namelijk deze taal volledig naar hun hand kunnen zetten.
2
3
Swift
Swift is een nieuwe programmeertaal die specifiek ontwikkeld is om software te schrijven voor IOS, OSX, tvOS en watchOS. De nieuwe taal is geïntroduceerd in 2014 op het WWDC van Apple. Swift is een taal die voortbouwt op Objective-C en C, zonder de compatibiliteit te verliezen met C. Het is ontworpen om samen te werken met de reeds bestaande Apple's Cocoa en Cocoa Touch frameworks. Swift is ontwikkeld met de gedachte dat de code minder fouten kan bevatten, eenvoudiger te schrijven is en eveneens ook beknopter is. Op deze manier wordt de taal ook leesbaar. Swift moet verder ook een lagere instapdrempel hebben voor developers die de taal willen leren. Apple heeft de reeds bestaande compiler, debugger en frameworks verbeterd om de basis te leggen voor Swift. Het beheer van het geheugen is vereenvoudigd doordat er nu wordt bijgehouden waar er nog referenties liggen tussen variabelen. Hierdoor kan het geheugen automatisch opgekuist worden als de variabelen nergens meer gebruikt worden. De framework stack is gebouwd op basis van Foundation en Cocoa, waarbij veel verbeteringen zijn aangebracht. Door deze nieuwe goede basis is Swift volgens Apple de taal van de toekomst voor Apple development. Met Swift introduceert Apple veel nieuwe functies en vereenvoudigt de reeds bestaande functies die overgenomen zijn van Objective-C. De editor Xcode is bij de introductie van Swift aanbeland aan versie 7 en kreeg hier live debuggen als handige extra functie. Bovendien is er nu een playground voorzien om snel eens wat code te testen zonder dat je daarvoor een app moet maken. Met live debuggen kan je de hiërarchie zien van de verschillende componenten in de design view. De bestandsextentie van een Swift bestand is ‘.swift’. Dit is een extensie waarvan je direct weet welke inhoud het bestand heeft. Dit is anders bij Objective-C. Bij Objective C kan je aan de hand van de extensie op zich niet weten dat het gaat over Objective-C bestanden, behalve indien je er in thuis bent en de extensies kent.
3
4
Swift vs Objective-C
4.1
Snelheid
Uit testen met een test app in Swift en een test app in Objective-C zal blijken dat Swift niet altijd sneller is dan Objective-C. De tests zijn gedaan met een iPhone 5 en iPhone 6s waarop IOS9.2 draait. Iedere test is uitgevoerd tot 500 elementen. Vooreerst zijn de testen uitgevoerd met arrays, om vervolgens door te gaan met dictionary’s en ten slotte met Sets. 4.1.1
Tests
Array
Een array is een verzameling dat bestaat uit verschillende elementen. Een array heeft een bepaalde lengte en ieder element heeft een unieke index.
Array Add 0.08E-06 0.07E-06
Uitvoer tijd
0.06E-06 0.05E-06 0.04E-06 0.03E-06 0.02E-06 0.01E-06 0.00E+00 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iPhone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
De eerste test bestaat uit het toevoegen van waardes in een array. Op deze grafiek kunnen we zoals verwacht aflezen dat de iPhone 5 beduidend trager is dan de iPhone 6S, zoals ook zal blijken uit de onderstaande grafieken. De oranje curves liggen veel lager op de verticale as dan de blauwe curves, wat duidt op een verschil in uitvoertijd. De verbetering in uitvoertijd is voor de iPhone 5 groter dan voor de iPhone 6S. Hieruit blijkt dat Swift zowel voor de iPhone 5 als voor de iPhone 6S in deze situatie veel sneller is in vergelijking met Objective-C.
4
Array Contains 0,00002 0,000018 0,000016
Uitvoer tijd
0,000014 0,000012 0,00001 0,000008 0,000006 0,000004 0,000002 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Bij de test waarbij er gezocht wordt naar waarden in een array, zien we dat bij weinig elementen, Swift en Objective-C een gelijklopende uitvoertijd hebben. Naargelang het aantal elementen in de array stijgt is Swift iets trager dan Objective-C. De grafiek stijgt duidelijk lineair, wat bij de vorige test niet het geval is. Het verschil tussen de iPhone 5 en 6s is niet heel groot wat je bij andere test wel ziet.
Array Delete 0,000002 0,0000018
0,0000016
Uitvoer tijd
0,0000014 0,0000012 0,000001 0,0000008 0,0000006 0,0000004 0,0000002 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Bij het verwijderen van waardes in een array zien we dat Swift een fractie sneller is dan Objective-C, maar naargelang het aantal elementen stijgen hebben Swift en Objective-C een nagenoeg gelijke uitvoertijd. 5
Array Read 2,5E-07
Uitvoer tijd
0,0000002
1,5E-07
0,0000001
5E-08
0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Het eerste wat opvalt in bovenstaande grafiek is dat de curves relatief vlak zijn. Dit betekent dat als je een waarde uit een array leest, het aantal elementen in een array weinig tot geen invloed hebben op de uitvoertijd. Verder kan uit deze test overduidelijk geconcludeerd worden dat Swift sneller is dan Objective-C.
Array Update 0,000006 0,000005
Uitvoer tijd
0,000004 0,000003 0,000002 0,000001 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Ook bij het updaten van een array is Swift hier beduidend sneller. Een terugkerend fenomeen die ook hier af te lezen valt van de grafiek is dat het verschil in snelheid tussen de iPhone 5 en 6 veel kleiner is bij Swift dan bij Objective-C. Daarnaast valt het ook op dat er veel minder fluctuaties aanwezig zijn bij Swift ten opzichte van Objective-C naarmate het aantal elementen toeneemt. 6
Dictionary
Een dictionary is een verzameling van elementen die elk bestaan uit een combinatie van key value pairs. Een dictionary wordt vaak gebruikt als je een list wil waarbij de key een bepaalde waarde moet bevatten. Bijvoorbeeld een lijst met stukken fruit en hun gewicht.
Dictionary Add 002E-04 001E-04
Uitvoer tijd
001E-04 001E-04 8 000E-08 6 000E-08 4 000E-08 2 000E-08 0 000E+00 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
In deze test is een miniem verschil te merken tussen Swift en Objective-C. Op deze grafiek valt dit echter niet zo goed af te lezen omdat Swift enkele excessen heeft. Hoe meer elementen er worden toegevoegd aan een array, hoe groter deze excessen worden en hoe minder groot de frequentie van de excessen wordt. Wel is het vreemd te noemen dat er een patroon in de excessen lijkt te zitten.
7
Dictionary Contains 0,00005
Uitvoer tijd
0,00004 0,00003 0,00002 0,00001 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Dit soort grafiek lijkt sterk op die van Array Contains, waaruit je kan besluiten dat Swift minder performant is in het kijken of iets al dan niet bestaat uit een verzameling. Naarmate het aantal elementen toeneemt is de uitvoertijd van de iPhone 6S verbeterd ten opzichte van de iPhone 5 met Objective C. Bij Swift is het verschil tussen de iPhone 5 en 6s hier niet zo duidelijk. De vaststellingen die kunnen gedaan worden bij deze test zijn toch verschillend met de meeste andere testen die voorheen al hebben plaatsgevonden.
8
Dictionary Delete 0,000007 0,000006
Uitvoer tijd
0,000005 0,000004 0,000003 0,000002 0,000001 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Bij het verwijderen van elementen uit een dictionary is Swift heel duidelijk trager dan Objective-C. Deze grafiek geeft een compleet ander beeld weer dan uit de testen kwam bij het verwijderen van elementen uit een array. Zoals we reeds konden vaststellen bij de vorige test en hier opnieuw observeren, heeft ObjectiveC een beduidend snellere uitvoertijd bij het verwijderen van elementen uit een array.
9
Dictionary Read 0,0000016 0,0000014
Uitvoer tijd
0,0000012 0,000001 0,0000008 0,0000006 0,0000004 0,0000002 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Ook het lezen van een dictionary gaat sneller in Objective-C dan in Swift. De iPhone 6s is redelijk constant bij Objective-C maar bij de iPhone 5 zijn er duidelijk pieken te zien. Dit wil zeggen dat een iPhone 5 het moeilijker heeft bij het lezen van een dictionary. Bij Swift zijn de verschillen dan weer minder groot tussen de 2 toestellen wat duidt op een geringe vooruitgang tussen de iPhone 5 en de iPhone 6S.
10
Dictionary Update 8E-06 7E-06 6E-06
Uitvoer tijd
5E-06 4E-06 3E-06 2E-06 1E-06 1E-20 0
50
100
150
-1E-06
Swift (iphone 5)
200
250
300
350
400
450
Aantal elementen Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Een update van een dictionary is sneller in Swift. Dit zie je doordat de oranje curves op de grafiek lager liggen dan de blauwe. Met de iPhone 5 is het verschil tussen Swift en Objective-C groter dan dat dit bij de iPhone 6 het geval is. Ook kan bij Swift een constantere curve vastgesteld worden terwijl dit bij Objective-C niet het geval is.
11
Set
Een set is een verzameling van unieke waarden die niet geordend zijn. Dit type lijsten wordt dus vooral gebruikt als je een lijst wenst waarbij geen dubbele waarden mogen in voorkomen.
Set Add 001E-04 001E-04
Uitvoer tijd
001E-04 8 000E-08 6 000E-08 4 000E-08 2 000E-08 0 000E+00 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
De grafiek voor het toevoegen van waarden in een set lijkt heel veel op die van het toevoegen van waarden in een dictionary. Swift heeft terug een paar grote excessen die toenemen naarmate het aantal elementen groter wordt. Bovendien kunnen we hier ook opnieuw constateren dat de frequentie in het aantal excessen daalt bij een toename van het aantal elementen. Bij Objective-C zijn er ook een paar excessen vast te stellen, maar die zijn veel kleiner dan bij Swift en hier is het moeilijker een vast patroon in vast te stellen. We besluiten hieruit dat een set in het toevoegen van waarden sterk lijkt op een dictionary.
12
Set Contains 0,0000035 0,000003
Uitvoer tijd
0,0000025 0,000002 0,0000015 0,000001 0,0000005 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Indien we bekijken of een waarde al dan niet voorkomt in een set is Swift beduidend trager dan de programmeertaal Objective-C. Bij een array en een dictionary zagen we dat de curves lineair stijgen. Dit kunnen we niet observeren bij een set. De curves bij een set blijven bijna vlak. Dit wil zeggen dat een set beter is dan een array en dictionary voor het bekijken of een waarde al dan niet voorkomt in een verzameling. Indien het aantal elementen richting de 380 gaat zien we een opmerkelijke wijziging van de curve bij Objective-C. Bij de meer dan 380 elementen stellen we een lichte stijging vast in de uitvoertijd terwijl we dit fenomeen niet kunnen vaststellen bij Swift. Bij Swift heeft het aantal elementen dus geen invloed op de uitvoertijd, terwijl dit bij Objective-C vanaf 380 elementen wel het geval is.
13
Set Delete 0,000006
Uitvoer tijd
0,000005 0,000004 0,000003 0,000002
0,000001 0 0
50
100
150
200
250
300
350
400
450
Aantal elementen Swift (iphone 5)
Swift (iphone 6s)
Objective-C (iPhone 5)
Objective-C (iPhone 6s)
Bij verwijderen van waarden in een set verlopen de curves van de iPhone 5 en 6s redelijk constant bij Objective-C. Als we dan naar Swift kijken zien we dat er grotere fluctuaties van de curves te zien zijn. We kunnen verder ook vaststellen dat naarmate het aantal elementen toeneemt, het verschil tussen Swift en ObjectiveC kleiner wordt. Dit komt door een lichte toename in uitvoertijd bij Objective_C en een lichte daling in de uitvoertijd bij Swift. Dit zou willen betekenen dat hoe meer waarden in een set verwijderd worden, hoe sneller de uitvoertijd bij Swift zal zijn. 4.1.2
Conclusie tests
Alle bewerkingen, behalve Contains bij arrays en dictionary, streven ernaar redelijk constant te blijven in uitvoertijd en dit in beide programmeertalen. Dit bewijst dat de algoritmes heel efficiënt werken. De verzameling die je het best gebruikt in Swift, is een Array. Deze gebruik je beter voor alle handelingen die je wenst uit te voeren, behalve als je zoekt in een grote verzameling van elementen. In dat geval is het aangewezen een set te gebruiken. Een dictionary gebruiken is af te raden, tenzij je geen alternatief hebt want deze collectie is de minst efficiënte van de drie die getest zijn. Als je een performante app wil, kan je bij gebruik van een dictionary en set, deze vooraf initialiseren met het maximumaantal waarden dat je er zal in steken. De app zal een iets grotere opstarttijd nodig hebben, maar tijdens het werken met de app zal dit uiteindelijk een grote tijdswinst opleveren. Op basis van snelheid alleen kan je geen taal afschrijven vermits er ook nog heel wat andere factoren meespelen, zoals eenvoudige en duidelijke syntax en een veilige code die leidt tot minder bugs.
14
4.2
Syntax
4.2.1
Variabelen
Een variabele heeft een naam en refereert naar één of meerdere plaats(en) in het geheugen. In een variabele kan er data gestopt worden. De naam is de identifier van de variabele. Hiermee kan je tijdens het programmeren de variabele aanspreken. int i = 3; bool b = true; float f = 6.2; char c = 'x'; NSString *s = @"Hello"; NSString *const MYFIRSTCONSTANT = @"FirstConstant"; Hierboven staan variabelen gedeclareerd en geïnitialiseerd in Objective-C. In Objective-C moet iedere variabele een datatype hebben. Enkele van deze datatypes zijn int, bool, float, char en NSString. In een int kan je gehele getallen kwijt, in een bool is dat true of false. Een float is een datatype voor kommagetallen, een NSString dient voor tekst en in een char kan je 1 karakter kwijt. Op de laatste lijn van het voorbeeld is een constante gedeclareerd. Een contante is een variabele die een waarde heeft dat niet gewijzigd kan worden. var i: Int = 3 var b: Bool = true var f: Float = 6.2 var c: Character = "x" var s: String = "Hello" let MYFIRSTCONSTANT: String = @"FirstConstant"; Dit stukje code is geschreven in Swift. Het zijn variabelen die reeds geïnitialiseerd zijn. Swift is iets slimmer dan Objective-C. Bij Swift moet je geen datatypes meegeven aan de variabelen maar dit mag wel indien je expliciet wil zeggen dat het een bepaald type moet zijn. In bovenstaand voorbeeld hebben alle variabelen een specifiek datatype gekregen. Je kan die weg laten door het type en de dubbele punt weg te laten. De compiler zal dan zelf bepalen welk datatype het moet zijn. Een constante variabele declareer je in Swift door het keyword var te vervangen door let.
15
4.2.2
Optionals
Constante variabelen moeten direct geïnitialiseerd worden als deze gedeclareerd worden en gewone variabelen moeten geïnitialiseerd worden voordat deze gebruikt kunnen worden. Het equivalent van nil in Objective-C, is in Swift optionals. Optionals kunnen een waarde bevatten of nil zijn. var s = "2016" var o = Int(s) print(o) // Optional(2016) var s = "abc" var x = Int(s) print(x) // nil In het eerste voorbeeld proberen we de string 2016 om te zetten naar een integer. Als we dit printen zien we dat variabele x een optional is en een waarde bevat. Het tweede voorbeeld toont aan dat een optional ook nil kan bevatten. Dit komt omdat “abc” niet kan omgezet worden in een integer. print(o?.successor) // Optional(2017) print(o!.successor) // 2017 print(x?.successor) // nil print(x!.successor) // error Als je op een optionele variabele een functie wil uitvoeren moet je tussen de variabele en het punt van de functie een vraagteken of een uitroepteken plaatsen. Als je een vraagteken plaatst dan probeert Swift dit uit te voeren en indien dit niet lukt zal er nil worden teruggegeven. Als je een vraagteken ertussen plaatst wordt de functie uitgevoerd. Als dit laatste slaagt krijg je geen optional meer terug maar een gewone variabele. Als de functie niet slaagt omdat de variabele nil is zal de applicatie crashen. Gebruik dus alleen het uitroepteken als je echt zeker bent dat de optional een waarde zal bevatten.
16
4.2.3
Methoden
De meeste codes die je schrijft zullen in een methode staan. Een methode of functie dient om op een eenvoudige manier code te groeperen, zodat je die eenvoudig op een andere plaats in je code kan oproepen. Zo kan je de methode ook meerdere keren gebruiken zonder dat je die opnieuw moet schrijven. Functies bevorderen dus de herbruikbaarheid van code. - (return_type) method_name:(argumentType1)argumentName1 externalParameterName:(argumentType2)argumentName2 { // body of the function } [self method_name: argument1 externalParameterName: argument2]; Methoden in Objective-C zijn in de vorm zoals hierboven weergegeven. Een methode begint met een minteken gevolgd door het return type tussen haakjes. Het return type is van hetzelfde type als de variabele die je wenst terug te geven. Als je geen waarde wenst terug te geven en enkel de functie wenst uit te voeren zet je void als return type. De naam van de methode is vrij te kiezen. Deze naam gebruik je dan als je de methode wenst op te roepen. Na de naam van de methode kan je argumenten meegeven met een functie. Dit zijn waarden die je in de functie kan gebruiken. Eerst geef je het type van de variabelen tussen haakjes, gevolgd door een vrij te kiezen naam, die je dan gebruikt in de functie om deze variabele te gebruiken. Je kan aan een parameter ook een externe parameter naam geven. Deze heeft geeft geen enkele toevoeging aan de functionaliteit van je code maar wel aan de leesbaarheid van je code als je een methode oproept. Tussen de accolades schrijf je de logica van de functie. Het gebruik van de methode is als volgt: tussen de vierkante haakjes komt eerst ofwel het keyword self als je de methode binnen dezelfde klasse gebruikt ofwel komt daar een instantienaam van de desbetreffende klasse gevolgd door de methode naam. Hierna geef je de parameters mee die de methode nodig heeft. Als de methode een waarde teruggeeft, kan je die opvangen door voor de vierkante haakjes een variabele te declareren met het datatype die de methode terug geeft, gevolgd door een gelijkheidsteken.
17
func method_name(argumentName1: argumentType1, externalParameterName argumentName2: argumentType2) -> return_type { // body of the function } var value = method_name("argument1", externalParameterName: 25) Een functie in Swift ziet er iets anders uit dan in Objective-C. Het is eenvoudiger te lezen en lijkt meer op programmeertalen als C# en Javascript. Een functie in Swift begint altijd met het keyword func gevolgd door de methode naam. Na de naam van de functie kan je tussen haakjes enkele argumenten meegeven en ook indien dit gewest een externe parameter naam opgeven. Na de haakjes kan je het return type van de methode opgeven door een pijltje gevolgd door het return type. Als je geen waarde wenst terug te geven, kan je dit stuk gewoon weglaten. Zoals dit bij Objective-C ook het geval is schrijf je de logica van de functie tussen accolades. De methode gebruiken kan je door de methodenaam gevolgd door haakjes. Tussen de haakjes plaats je de argumenten die de methode nodig heeft indien de methode argumenten heeft. Als de methode een waarde teruggeeft, vang je die op door een variabele te declareren en die gelijk te stellen aan de uitgevoerde methode. Als je de methode in een andere klasse wenst te gebruiken moet die public zijn en kan je die methode aanspreken door de naam van de gedeclareerde instantie van de klasse te gebruiken, gevolgd door een punt en de methode naam.
18
4.2.4
Klassen
Zowel Objective-C als Swift zijn object georiënteerde talen. Een klasse wordt gebruikt om een object te specifiëren. Een klasse bevat methodes en verscheidene properties. Een property is een variabele die een eigenschap is van een klasse. Een klasse kan ook een constructor bevatten. Standaard wordt deze achter de schermen gemaakt zonder inhoud en zonder argumenten. De constructor is een methode die wordt uitgevoerd als je een instantie maakt van een klasse. Hierin kan je logica schrijven die moet uitgevoerd worden bij het aanmaken van een instantie van de klasse. @interface UrlConnection : NSObject @property NSString *url; - (instancetype)initWithString:(NSString *)url; - (void)connect; - (BOOL)canHandleRequest:(NSString *)type forUrl:(NSString *)url; @end testObject @implementation UrlConnection -(instancetype)initWithString:(NSString *)url { self = [super init]; if (self) { self.url= url; } return self; } - (void)connect { } - (BOOL)canHandleRequest:(NSString *)type forUrl:(NSString *)url { } @end UrlConnection connection = [[UrlConnection alloc] initWithString:@"http://www.michieldegeeter.be"]; In Objective-C maak je een interface aan met de naam van de klasse gevolgd door een type waarvan de klasse overerft. In deze interface geef je het geraamte mee van de klasse. Je kan er properties in definiëren en methoden, alsook een constructor. Er zijn verschillende constructors mogelijk. In dit voorbeeld wordt er een string meegegeven in de constructor, wat de init methode genoemd wordt. Je kan ook andere types meegeven met een init methode. Er bestaat ook een init zonder argument. Onder de init methode staan er 2 methoden. End sluit de interface af. Nu kan je de implementatie van de klasse maken. In de implementatie kan je de logica schrijven die je in de klasse wenst. De laatste lijn van de code is het initialiseren en declareren van de klasse. Bij het initialiseren zie je dat de init methode zal uitgevoerd worden.
19
class UrlConnection: NSObject { var url: String init(string url: String) { self.url = url } func connect() { } func canHandleRequest(type: String, forUrl url: String) -> Bool { return true; } } var connection = UrlConnection(string: "http://www.michieldegeeter.be") Bovenstaande code is in Swift geschreven. Een klasse in Swift bestaat maar uit één stuk. Je moet niet eerst een interface schrijven om daarna de implementatie te schrijven, zoals dit wel het geval is bij Objective-C. Een klasse in Swift begint met het keyword class gevolgd door de naam van de klasse. We kunnen dit verduidelijken aan de hand van bovenstaand voorbeeld. Na de naam van de klasse, in dit geval UrlConnection, komt NSObject. Dit is een klasse waarvan de eerdergenoemde UrlConnection overerft. Tussen de accolades komen de methoden, properties en de constructor. Anders dan bij Objective C is bij Swift de constructor altijd init ongeacht de parameters. Het declareren en initialiseren van een instantie van de klasse gebeurt op de manier die je op de laatste lijn van het voorbeeld ziet. Door de initialisatie van de klasse die je na het gelijkheidsteken ziet, zal de init methode van de klasse uitgevoerd worden.
20
4.2.5
Enumeration
Een enumaration is een datatype die een opsomming bevat. Een enumation bestaat uit een vooraf bepaald aantal waarden die met een identifier opgeroepen kunnen worden. Een enumeration wordt veel gebruikt indien een variabele maar enkele vaste waarden kan bevatten. Het is dan eenvoudig om de waarden te vergelijken en dit zonder een typefout te maken. enum MobileDevice : String { case iPhone = "iPhone", Android = "Android", WP8 = "Windows Phone8", BB = "BlackBerry" func name() -> String { return self.rawValue } } let m = MobileDevice.Android print(m.name()) // "Android" enum Location { case Address(street:String, city:String) case LatLon(lat:Float, lon:Float) func description() -> String { switch self { case let .Address(street, city): return street + ", " + city case let .LatLon(lat, lon): return "(\(lat), \(lon))" } } } let loc1 = Location.Address(street: "2070 Fell St", city: "San Francisco") let loc2 = Location.LatLon(lat: 23.117, lon: 45.899) print(loc1.description()) // "2070 Fell St, San Francisco" print(loc2.description()) // "(23.117, 45.988)" Enumerations zijn heel krachtig in Swift. In Swift kan een enum methoden bevatten. Ook een enumaration kan een waarde bevatten die op hun beurt verschillende datatypes kunnen zijn zoals strings, chars, integers en floats.
21
4.2.6
Switch operator
Een Switch kan je in Swift op veel meer manieren gebruiken in vergelijking met Objective-C. Een Switch operator kan je nu niet enkel gebruiken met integers of strings maar ook met ranges, lists en ook met een case waarbij er een voorwaarde aan vasthangt. let somePoint = (-0.5, 0.5) switch somePoint { case (0, 0): print("\(0, 0) is at the origin") case (_, 0): //_ is a wildcard and matches anyting print("\((somePoint.0), 0) is on the x-axis") case (0, _): print("\(0, (somePoint.1)) is on the y-axis") case (1,1), (-1,-1), (-1,1), (1,-1): // values list print("\((somePoint.0), (somePoint.1)) is in the corner of the half-sized square") case (_,_) where abs(somePoint.0) == abs(somePoint.1): // wildcard with condition print("\((somePoint.0), (somePoint.1)) is on the diagonal") case (-2...2, -2...2): print("\((somePoint.0), (somePoint.1)) is inside the box") default: print("\((somePoint.0), (somePoint.1)) is outside of the box") } //prints "(-0.5, 0.5) is on the diagonal" Hierboven staat een switch volledig uitgeschreven in Swift. Een punt “somePoint” is gedeclareerd en geïnitialiseerd. Dit is een nieuw feature in Swift namelijk een tuple. Een tuple is een eenvoudige manier om meerdere waarden samen in één entiteit te bewaren. De verschillende waarden, die je in een tuple steekt moeten niet van hetzelfde datatype zijn. Na de declaratie en initialisatie begint het switch statement. Tussen de accolades zijn enkele cases te vinden. Zoals je ziet zijn er heel wat vreemde cases te zien. De tweede en derde heeft een variabele die alles mag zijn. Hiervoor wordt een underscore gebruikt. Bij de vierde case zijn er meerdere voorwaarden. Het punt moet aan 1 van de voorwaarden voldoen voordat deze case zal uitgevoerd worden. De vijfde case is een heel speciaal geval. Het punt mag om het even welke waarden bevatten maar de absolute waarden moeten overeenkomen voordat de case uitgevoerd zal worden. De laatste case zal uitgevoerd worden als de waarden van het punt tussen -2 en 2 zitten met -2 en 2 erbij. Als het punt aan voorwaarden van verschillende cases voldoet dan zal de eerste case waaraan het punt aan de voorwaarden voldoet uitgevoerd worden. Indien geen van de cases uitgevoerd wordt zal de default uitgevoerd worden.
22
struct Point { float x; float y; } struct Point somePoint; somePoint.x = -0.5; somePoint.y = 0.5; if (somePoint.x == 0 && somePoint.y == 0) { NSLog(@"(0, 0) is at the origin"); } else if (somePoint.y == 0) { NSLog(@"(%d,0) is on the x-axis", somePoint.x); } else if (somePoint.x == 0) { NSLog(@"(0,%d) is on the y-axis", somePoint.y); } else if ((somePoint.x == 1 && somePoint.y == 1) || (somePoint.x == -1 && somePoint.y == 1) || (somePoint.x == -1 && somePoint.y == 1) || (somePoint.x == 1 && somePoint.y == -1)) { NSLog(@"(%d,%d) is in the corner of the half-sized square", somePoint.x, somePoint.y); } else if (abs(somePoint.x) == abs(somePoint.y)) { NSLog(@"(%d,%d) is on the diagonal", somePoint.x, somePoint.y); } else if (somePoint.x >= -2 && somePoint.x <= 2 && somePoint.y >= -2 && somePoint.y <= 2) { NSLog(@"(%d,%d) is inside the box", somePoint.x, somePoint.y); } else { NSLog(@"(%d,%d) is outside the box", somePoint.x, somePoint.y); } //output "(-0.5, 0.5) is on the diagonal" In Objective-C bestaat een Switch ook, maar die heeft veel minder mogelijkheden. Het voorbeeld die in Swift met een Switch is getoond kan dus niet in Objective-C. Je moet dit probleem oplossen met “if else statements” wat veel minder overzichtelijk is en ook trager uitgevoerd zal worden. Ook bestaat een tuple niet in Objective-C en moet je een struct aanmaken om in dit geval het probleem op te lossen. Ook zie je dat het aan elkaar plakken van verschillende variabelen tot één string op een totaal andere manier gebeurt dan in Swift. Waar je in Swift een variabele aan elkaar kan plakken tot een string met een plus of via de backslash gevolgd door de variabele tussen haakjes, is dit bij Objective-C via format specifiers. 4.2.7
Syntax conclusie
Algemeen genomen is Swift code compacter dan Objective-C. Hierdoor is de code ook beter leesbaar en eenvoudiger te begrijpen. Met Swift zijn puntkomma’s niet meer nodig aan het einde van een regel. Ook moet een methode niet meer genest worden tussen vierkante haakjes. Doordat de syntax eenvoudiger is, is Swift een duidelijkere taal. Swift is eenvoudiger aan te leren en voelt veel vertrouwder aan voor programmeurs die reeds JavaScript, Java, Python, C# of C++ kennen. 23
4.3
API’s
Een API (application programming interface) is een bibliotheek waar klassen inzitten die functionaliteiten bevatten. De werking van de functionaliteit van een API is meestal niet beschikbaar. Je kan de API enkel aanspreken om de functionaliteit te gebruiken. Iedere API die in Objective C beschikbaar is, is dat ook in Swift. Apple heeft alle standaard API’s herschreven in Swift. Voor de thirth-party API’s is dit nog niet altijd het geval maar ook dan is dit geen groot probleem voor de app ontwikkelaar. Ja kan namelijk zonder problemen Swift en Objective-C code gebruiken in een zelfde project. SWIFT: let view = UIView(frame: CGRectMake(0, 0, 200, 200)) view.backgroundColor = UIColor.blueColor() OBJECTIVE-C: UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 200, 200)]; view.backgroundColor = [UIColor blueColor]; Hierboven een stukje code waar een view wordt geïnitialiseerd in Swift en Objective-C code. Dit is één voorbeeld van code die omgezet is van Objective-C naar Swift. Een developer die Objective-C schrijft zal de Swift code verstaan en zal ook snel zien dat je de code sneller schrijft in Swift dan in Objective-C als je de nieuwe taal onder de knie hebt.
24
4.3.1
Migratie
Doordat je Swift en Objective-C code kan gebruiken in hetzelfde project kan je een app ook in stukken migreren van Objective-C naar de nieuwe taal. Swift code kan je niet schrijven in Objective-C code. De twee talen moet je scheiden in verschillende bestanden maar ze kunnen wel samen in hetzelfde project zitten. Je kan in een Swift bestand de code aanspreken van in een Objective-C bestand en omgekeerd. SWIFT: class testObjectSwift: NSObject { func test(){ } } OBJECTIVE-C: @class testObjectSwift @interface testObjectObjectiveC: NSObject - (void)test; @end @implementation testObjectObjectiveC - (void)hallo { testObjectSwift *tOS = [[testObjectSwift alloc] init]; [tOS test] } @end Hierboven zie je een voorbeeld hoe je een Objective-C klasse kan gebruiken in Swift. Je zou kunnen denken dat er geen code moet geïmporteerd worden. Dit is inderdaad het geval maar dit gebeurt met een bridging header bestand. Dit is een Objective-C bestand die je aanmaakt en waarin je de bestanden importeert die je wenst te gebruiken in Swift. Dit bestand moet je ingeven onder build settings Swift_obj_bridging_header van je project. Vanaf nu kan je in Swift alle codes aanspreken die je hebt geïmporteerd in het bridge header bestand.
25
OBJECTIVE-C: @interface testObjectObjectiveC: NSObject - (void)test; @end @implementation testObjectObjectiveC - (void)test { } @end SWIFT: class testObjectSwift: NSObject { override init(){ var v = testObjectObjectiveC() v.test() } } Dit is Swift klasse die gebruikt word in een Obective-C klasse. In het header bestand van de Objective-C klasse moet je “@class” schrijven gevolgd door de Swift klassenaam. Bij het implementation bestand moet je een import doen van een bestand die automatisch gegenereerd wordt. Het bestand heeft als naam: projectnaam-swift.h. Nu kan je in Objective-C je Swift klasse met functions en properties gebruiken.
4.4
Security
Swift is een nieuwe taal en wordt dan ook geacht veiliger te zijn dan Objective-C. Enkele beveiligingsrisico’s die in Objective-C zitten nemen we onder de loep in Swift. Zitten deze risico’s ook in Swift? 4.4.1
Integer Overflow
Een integer overflow kan optreden als je een waarde in een integer stopt die te groot is. Een integer heeft standaard een bepaalde grootte, namelijk 32bit. De grootste waarde die je er kan in stoppen is 2147483647. Als je in Objective-C deze waarde in een integer stopt en daar 1 bij optelt dan zal dit geen error geven, maar zal het resultaat van deze optelling -2147483648 teruggeven. Als iemand van kwade wil hiervan op de hoogte is, dan kan hij ervoor zorgen dat er een negatief getal in een variabele zit terwijl je in je programma een positieve waarde verwacht. Dit kan lijden tot een heap overflow vermits het programma het negatief getal kan interpreteren als een te groot getal waarvoor hij een buffer probeert aan te maken van die grootte. Dit kan in principe niet lukken. In Safari kan dit in oudere versies leiden tot het overschrijven van geheugenlocaties. In Swift kan een Integer overflow niet misbruikt worden. Swift zal bij het overschrijden van de waarde 2147483647 een runtime error geven, waardoor het onmogelijk is om dit te misbruiken door mensen die van kwade wil zijn. Als je wil dat je programma niet crasht zal je wel nog altijd aan foutafhandeling moeten doen. Dit zou je bijvoorbeeld met een try catch kunnen doen. 26
4.4.2
Format String Attack
Als je een gebruiker in een app een inputveld geeft waar iets ingegeven kan worden, dan kan deze persoon om het even wat invullen. De ontvangen string van het inputveld kan dus om het even wat bevatten. Als je hierop nu een functie op de string loslaat die bepaalde delen vervangt door variabelen, kan het fout lopen en kunnen bepaalde geheugenlocaties overschreven worden. NSString *evilString = @”Evil things %x%x%x%x%x”; printf([evilString UTF8String]); //output: Evil things 80001009621e5aa2d970023a5529b0 printf(“%s”,[evilString UTF8String]); //output: Evil things %x%x%x%x%x In Objective-C kan je variabelen samenvoegen met stukken tekst door gebruik te maken van een % gevolgd door bepaalde letters. Als iemand ditzelfde ingeeft in een input veld dan kunnen er bepaalde geheugenlocaties overschreven worden en kan je bepaalde geheugenlocaties printen indien je dit helemaal niet wenst. In de test die je hierboven ziet zie je dat het belangrijk is om strings juist te behandelen. De evilString kan van een input komen, als je die dan print zonder je voorzorgen te nemen dan zie je dat de “%x” vervangen wordt. De getallen die in de output staan zijn hexadecimale waarden die uit bepaalde geheugenlocaties komen. Dit zou bijvoorbeeld een wachtwoord kunnen bevatten wat je natuurlijk niet zou willen. var evilString = "Evil things %x%x%x%x%x" print(evilString); //output: Evil things %x%x%x%x%x In Swift heeft men dit beter aangepakt. Als je bepaalde waarden in een string wenst toe te voegen, kan je deze tussen haakjes zetten en een backslash ervoor plaatsen. In Swift wordt niet meer gewerkt met de zogenaamde procent tekens. In het voorbeeld zie je dan ook dat er niets gebeurt met de “%x” en deze gewoon geprint wordt. 4.4.3
Buffer Overflow
Een buffer overflow treedt op wanneer een applicatie data probeert te schrijven in een tijdelijke gegevensruimte na het einde van de buffer. Deze overflows kunnen de applicatie laten crashen maar kunnen ook misbruikt worden door hackers en virussen. Deze security issue kan je in beide talen zowel in Objective-C als in Swift voorhebben als je de fout niet correct opvangt. Een mogelijkheid om deze fout te voorkomen is op voorhand controleren of de buffer groot genoeg is voor de data die je er wenst in de stoppen.
27
4.5
Geheugenbeheer
Het geheugenbeheer in Objective-C moet de developer zelf beheren, bij het aanmaken van variabelen worden de geheugenlocaties niet automatisch vrijgemaakt als deze niet meer gebruikt worden. Swift ondersteunt Automatic Reference Counting (ARC). Dat wil zetten dat in Swift wordt bijgehouden hoeveel referenties een variabele nog heeft. Als een variabele geen referenties meer heeft zal de variabele vernietigd worden en komt de geheugenlocatie vrij. In Objective-C kon het weleens gebeuren dat je geheugenlekken had doordat variabelen niet opgeruimd worden. In Swift is dit zo goed als verleden tijd. Er is nog 1 voorbeeld waar de variabelen voor eeuwig blijven bestaan als je die niet manueel uitkuist. class Vader:NSObject{ var kinderen = [Kind]() } class Kind:NSObject{ init(let vader:Vader){ self.vader = vader } var vader:Vader } var vader = Vader() var kind = Kind(vader: vader) vader.kinderen.append(kind) In bovenstaande codevoorbeeld staan twee klassen namelijk Vader en Kind. Een instantie van vader maak je aan en een instantie van kind. Kind heeft een referentie naar vader en vader heeft een referentie naar kind. Hierdoor zal er altijd 1 referentie blijven met de objecten. Je moet de variabelen zelf nog manueel verwijderen, tenzij je in de klasse Vader voor ‘var kinderen’ weak plaatst, ofwel door bij de klasse Kind bij de variabele vader, weak ervoor te plaatsen. Slechts één van de twee is nodig. Door dit te doen zal de garbage collector deze variabelen wel opruimen als deze niet meer gebruikt worden.
28
5
Bespreking van het project
De doelstelling van het project was om programmeertalen te vergelijken en te begrijpen waarom Apple Swift ontwikkeld heeft als een logische evolutie op Objective-C waarbij ik de pro’s en contra’s van beide talen wou bekijken. Dit project heeft de nodige inzichten meegebracht in deze, waardoor het duidelijk wordt dat Swift Objective-C zal laten uitdoven. Swift is in veel opzichten gebruiksvriendelijker, veiliger, makkelijker te leren en tilt de programmeertaal naar een hoger niveau. Apple heeft met Swift een sterke taal in handen voor de toekomst en is dan ook een tal die op veel vlakken bij developers goed aan komt.
29
6
Conclusies
Swift en Objective-C hebben elk hun voor- en nadelen. Swift is in vele zaken sneller maar dan weer niet als het aankomt op het verwijderen van variabelen in verzamelingen. De syntax van Objective-C is heel lastig om te leren. Waar je bij Objective-C veel gebruit moest maken van vierkante haakjes zijn die in Swift nergens te bespeuren. Dit is bij veel programmeurs een hele opluchting. Ook is het concateneren van strings veel eenvoudiger in Swift dan in Objective-C. De taal Swift is ook veel beter leesbaar dan Objective-C. In Swift zijn we gelukkig ook van de header en implementatie bestanden af. Een Swift bestand bevat zowel de functionaliteit als de structuur van een klasse. Dit maakt het eenvoudiger om te programmeren en is ook beter voor de algehele leesbaarheid van de code vermits je maar 1 bestand moet open staan hebben om de volledige klasse te lezen. De verschillende uitbreidingen die niet in Objective-C zitten maar nu wel in Swift zoals de Switch Case of enumeration uitbreiding zijn geen musts in een taal maar ze zijn wel mooi meegenomen en krikken de taal op naar een hoger level. Dat Swift een veiligere taal is dan Objective-C is zeker waar. Niet alleen omdat de taal zelf veiliger is maar omdat programmeurs minder fouten zullen maken. Je hoeft bijna niet meer te denken aan geheugenlocaties die je vrij moet maken wat één van de vele voordelen is. Doordat de taal ook heel wat leesbaarder is zullen er automatisch minder fouten geschreven worden. Er zijn inderdaad nog issues in die kunnen optreden in Swift zoals buffer overflow maar dit heb je in vele andere talen ook en weet je dus ook dat je hier rekening moet mee houden. Programma’s die nu nog in Objective-C zijn geschreven kunnen in stukken omgezet worden naar Swift vermits je Swift code en Objective-C code in eenzelfde project kan gebruiken. Dit maakt het aantrekkelijk voor programmeurs om te proeven van de taal en de nieuwe functionaliteiten in Swift te schrijven en beetje bij beetje de Objective-C code te vervangen door Swift code. Iemand die als beginnend programmeur graag een IOS of OSX app wil schrijven zal sneller met Swift weg zijn dan met Objective-C omdat deze taal veel natuurlijker aanvoelt. Ook focust Apple zich vooral op Swift en zal Objective-C in de toekomst belangrijke functionaliteiten missen die je met Swift wel hebt. Het ziet er ook dan naar uit de Objective-C rustig uitgefaseerd zal worden en uiteindelijk zal de taal volledig uitdoven.
30
7
Bronnen- & literatuurlijst
About Objective-C. (n.d.). Retrieved February 25, 2016, from https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011210-CH1-SW1 An iOS Developer’s Guide: From Objective-C to Learning Swift. (n.d.). Retrieved February 25, 2016, from http://www.toptal.com/swift/from-objective-c-to-swift Apple Inc. (2015, September 17). Swift - Apple Developer. Retrieved October 11, 2015, from https://developer.apple.com/swift/ Apple Inc. (n.d.). The Swift Programming Language (Swift 2): About Swift. Retrieved October 11, 2015, from https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ CODE | Smashing Boxes. (n.d.). Retrieved February 28, 2016, from http://smashingboxes.com/blog/apples-swift-should-beginners-still-learn-objective-c CodeNewbie. (n.d.). Retrieved February 25, 2016, from http://www.codenewbie.org/blogs/getting-started-with-ios-objective-c-vs-swift Difference between Swift and Objective-C. Titans of iOS development | Redwerk. (n.d.). Retrieved March 19, 2016, from http://redwerk.com/blog/10-differencesobjective-c-swift How to import Swift code to Objective-C - Stack Overflow. (n.d.). Retrieved March 19, 2016, from http://stackoverflow.com/questions/24102104/how-to-importswift-code-to-objective-c Is Swift Faster Than Objective-C? How We Measured Performance. (n.d.). Retrieved February 25, 2016, from https://yalantis.com/blog/is-swift-faster-than-objectivec/ Paul Solt. (2015, May 11). Swift vs. Objective-C: 10 reasons the future favors Swift. Retrieved October 11, 2015, from http://www.infoworld.com/article/2920333/mobile-development/swift-vs-objective-c-10-reasons-the-future-favors-swift.html Prateek Malik. (2014, June 9). Should I use Swift or Objective-C to learn iOS development? - Quora. Retrieved October 11, 2015, from https://www.quora.com/Apple-Swift-programming-language/Should-I-use-Swiftor-Objective-C-to-learn-iOS-development Security Issues in Swift: What the New Language Did Not Fix | Dr Dobb’s. (n.d.). Retrieved March 19, 2016, from http://www.drdobbs.com/security/security-issuesin-swift-what-the-new-la/240168882 Some Reasons Why Swift is Better than Objective-C. (2015, January 8). Retrieved from http://thenewstack.io/some-reasons-why-swift-is-better-than-objective-c/ Swift (programming language). (2016, February 18). In Wikipedia, the free encyclopedia. Retrieved from https://en.wikipedia.org/w/index.php?title=Swift_(programming_language)&oldid=705523817 tutorialspoint.com. (n.d.-a). Objective-C Tutorial. Retrieved February 25, 2016, from http://www.tutorialspoint.com/objective_c/ tutorialspoint.com. (n.d.-b). Swift Tutorial. Retrieved February 25, 2016, from http://www.tutorialspoint.com/swift/ 31
Why would people build native mobile applications for Android/iOS using Java/Objective-C when they could use Xamarin/C# for all platforms if license cost isn’t an issue? - Quora. (n.d.). Retrieved February 25, 2016, from https://www.quora.com/Why-would-people-build-native-mobile-applications-forAndroid-iOS-using-Java-Objective-C-when-they-could-use-Xamarin-C-for-allplatforms-if-license-cost-isnt-an-issue Xcode. (2016, February 24). In Wikipedia, the free encyclopedia. Retrieved from https://en.wikipedia.org/w/index.php?title=Xcode&oldid=706665927
32
