*STICKY - Summary of all Entries!*
*STICKY - Summary Of ALL Entries!*
Not so much of an update actually but more of a checkpoint/summary to show what I have achieved and where I am with my Swift understanding at this point.
Basically, at around Christmas time, 2017, I felt the urge to resume my Swift journey. It had been very patchy - at best - for the two and a half years prior to then. For a time - approximately April to August 2015, I was on a real roll. As I've already outlined before (so will keep it brief here), coming to Dubai put a hold on that progress.
Happily, I can genuinely say - after 5 months of consistent practice - that I know much more than I ever have and am at a much more advanced point than I was in August 2015. The real turning point was in June, after a couple of pointless, sporadic entries based on an eBook, I decided to do a total reset. This did seem to be a step backwards initially, but my rebuilding was essential. Using Treehouse was the key here.
So this entry will summarise my Swift journey from 4th June to today. I will break it down into the courses used to bundle together (like a class or struct!) the key lessons and points covered.
*My first 10 entries were as follows:
Entries 1 to 4 - My history of Swift and what I know so far
Entries 5 to 10 - Specifically linked to 'Learning to Code in Swift4' by Kevin McNeish (with one update entry within this)
STAGE 1
Treehouse (4.6.2018 to 18.7.2018)
Going back to the basics is always a little humbling but I'm so glad I did. This did mean a cost of $25 a month, but boy was it worth it.
Entry 11 - history of Swift and what variables are. Equals being the assignment operator - wow this really was basic!
Entry 12 - constants and immutability, concatenation and string interpolation. Unsure of why 'let' is the same as constant.
Entry 13 - numbers and booleans, type safety - how errors will come up if the wrong type is used/changed
Entry 14 - arithmetic operators - not just the basic 4 operations but putting together variables too, needing to use the same type for calculations i.e. not being able to use Int with Double. Difference of assignment (=) and is equal to (==). Remainder operator (%). Operator precedence - different to BODMAS in that it is mult, div, modular (%), add, sub. Finally unary operators - += 1, this is unary as there is only one value mentioned! Lots more here in this entry!
Entry 15 - collections (arrays, dicts and sets). With arrays, adding to them, modifying, mutating...then removing or inserting values within the array. Count can be used too. OK, all fine.
Entry 16 - dictionaries specifically. The key-value pair syntax. Modifying items including using 'nil'. Dictionaries are technically optionals so can contain nil!
Entry 17 - Loops - for/in etc. Closed/open range - if it is closed then it is e.g. 1...7; half open is e.g. 1..<7 - so half-open means it will be less than one of the number at the end of the range. While and repeat while. With repeat while, you carry out the block of code, then test the condition. In practice, for in seems to be the most useful of these.
Entry 18 - If statements - again, linked to conditionals. If statements used with print statements. Logical operators - && meaning and; | | meaning or. This is used for including multiple conditions. Not operator ! before something. != meaning not equal to. Or !isRaining would mean the opposite of the bool for isRaining. Etc. Switch statements - syntax of case and default. Has to be exhaustive. Use of switch statements in arrays and in for-in loops.
Entry 19 - Functions. Syntax for first of all no parameters to building up to these. All this seems easy now.
Entry 20 - Functions again. Naming conventions (link to grammar). Argument labels. Outside ones - for used outside the block (external); inside - local. Switch statements within functions. Scope - how variables within a block cannot be used outside of it.
Entry 21 - structs - coordinates example. Instance methods - functions associated with a particular type. Init method - this is used to set initial values or to list which variables need values adding to them.
Entry 22 - classes. Looking at this now, what a confusing way to introduce classes! Combining the point struct with this...lots of values to make sense with. Helper methods - created in order to help with another one. E.g. to obtain a bool or specific value.
Entry 23 - Inheritance - the point of this is not to create new classes every time but to use inheritance when there are enough shared properties that makes this worthwhile. Override - this keyword is essential and I totally get the point of it now but did not back then! The point of this is that you need to do this as the init has changed from the original super class init. This definitely wasn't clear the first time around and has actually confused me a bit. Value vs reference - no real details at this stage.
Entry 24 - *Interim practice - this was as I was confused by initialization for class/struct. To have this clarified - the examples show some values all declared within the class, so no init needed! For just the type but no initial value, that's when init is needed. Superclass init a bit clearer too.
Entry 25 - Enums. Good as you can select from other options. Using the cases and the .case syntax etc. Functions used with enums. Switch used for this. Custom enums - avoids errors as there are finite options.
Entry 26 - Enums again. Associated values - you can declare the types for cases basically. From Ibrahim's course, variations with having tuples for a case (including parameters), also for anything numerical e.g. months, Xcode figures out that all the cases will follow a numerical order.
Entry 27 - Optionals! Avoiding forced unwrapping. Optional binding - using if/let for this. Link to dictionaries too (complex example!). Haven't mentioned that this implicit unwrapping.
Entry 28 - More on optionals. Other options - for guard statement. No need for nested (brackets within brackets).
Entry 29 - Enumerations. Default values given. The example was with coins - nickel, dime etc. It is better to set default/raw values than it is to do the switch statement - checking each case then giving a value based on that. The link here is that error codes can be created as an enum. Then used for optionals. Optional chaining - list of values looked at together. Arrays - used for items in enum etc. Nil coalescing - the use of the ?? - using a value or the optional.
Entry 30 - protocols. This being a blueprint for behaviour. Link to get here. OK, so link to computed properties too - how there needs to be some computation etc.
Entry 31 - long-winded example here. I think the point is that protocols are easier to use to show some behaviour than creating multiple classes etc.
Entry 32 - Three types of protocols: can do, is a and can be...not too sure about these. I think the idea here was a function in a protocol can then be used in other class/struct etc. As long as it conforms to the protocol mentioned, then it's OK. These examples are not clear though!
Entry 33 - Last one on protocols! The point is that they ENCAPSULATE an aspect of behaviour. It avoids inheritance, if there is just ONE PARTICULAR THING that is desired. E.g. bird/plane - it is just the 'fly' behaviour needed. Get and set not too clear at this point.
Entry 34 - Using Xcode for a project. Just an intro here.
Entry 35 - Continuing Xcode. Info about view controllers - link between app data and the visual appearance. IBOutlets - weak a they don't have any functionality and just display. IBActions - these do!
Entry 36 - More on the app project. Use of an array within the project (facts). The facts array needs to be outside of the function (global not local!). MVC - important this! Model - being key classes and data; View - what is seen on the app and Controller - mediates between the two.
Entry 37 - Next part of app. So this brings up auto layout and the use of colour. This is something I am in need of looking at again.
Entry 38 - final part. Running the app on a device and adding an app icon. I'm sure there's a bank of the latter that I could get when it comes to doing my own!
Entry 39 - Error handling. Different types of errors - quite confusing way to introduce this! Would have been better to have explained that we need to build in error code!
Entry 40 - Debugging code for app (F1 Facts) and more error handling. Not much on the latter as I didn't really get this. It mentions Defer - now I know that you leave that statement until last.
Entry 41 - first of Vending Machine app. Something has clicked into place - the use of get/get and set for protocols are then left blank because the actual code is not needed there. Get - read only. P-list - way of organising the information in a clearer table. Using XML - language for reading these. Type method - used directly on the type itself not on an object. Static keyword. Type alias mentioned - alternative name for existing type. NS - a prefix for using older Objective C types. SO much here!
Entry 42 - Next one of the app. Type casting used. Wasn't even aware of it! Would understand the context of down casting and the as keyword much more now! The rest of this did not look verbose and confusing - I think I gave up on trying to understand it at that point!
Entry 43 - Next one of app. Displaying icons - obviously pictures were already saved for me. Steppers - now these did look cool. Being able to select different values on a display.
Entry 44 - penultimate one of app. Design views - aspects to consider - clarity, deference and depth. Alert views - this is where we can choose from options of what can come up when alerts are needed.
Entry 45 - last part. Some links to error handling but not very clear what I learned here. That was it fr the app I think!
Entry 46 - All about auto layout. Layout considerations - position and size. All quite vague and from this point, the pictures I put in cannot be seen! This was resolved more recently.
Entry 47 - Layout margins. Red lines used to show inequality relationship - so something needs to change basically. Leading - left/up, trailing - right/down. Again, this seems vague as I haven't used the actual Xcode program for a while! Stack views but don't know much about this from the blog info.
Entry 48 - Programmatic auto layout. I remember this now - all views programmed specifically by code. Really technical and pointless from what I remember!
Entry 49 - Similar to above.
Summary - 39 entries
Breakdown -
Entries 11 to 24 - Fundamentals
Entries 25 to 33 - More Intermediate
Entries 34 to 49 - using Xcode for projects/auto layout (apart from 39 and some of 40)
So there was a lot of useful stuff here. My understanding of syntax of the basic principles really strengthened. I got caught up with initializers - had to get my head around these especially with the override after inheritance. Error handling was baffling but is a lot clearer now. The projects were a mixed bag - the fun facts was a great introduction but the vending machine was mostly confusing. And auto layout - some useful tips but not the programmatic ones.
STAGE 2
So from 18th July, I switched from Treehouse to Udemy! Having a plethora of courses already purchased, the issue I had was that none of them seemed that good. It also didn't help that they were mostly out of date. The most recent one was actually purchased around a year ago (I think) so was not too outdated. It turned out to be the right move - overall her course has been easily the best one I've seen on Udemy (no offence, Bob, Ray et al).
The next set of summarises are for her course - not a whole stage required for this.
2.1 - Angela's Course (18.7.18 to 29.7.18)
Only actually 11 days in total, but so much learned in that time!
Entry 50 - *First Angela course. An introduction to the course - as you'd expect! Making the 'I am Rich App' - basic introduction to using Xcode with the storyboard, the points/pixels. Introduction to what Github is.
Entry 51 - Use of the image views, logos etc. for the Dicee app. Debugging - when SIGABRT comes up, that usually means an object has not been connected properly. That used to happen to me a lot with labels/buttons. Randomisaiton - arc4random. Best way of randomising with the dice was an array (not the switch statement that I did initially).
Entry 52 - Use of DRY (don't repeat yourself) - good concept! Function use for the dice changing. Motion detection added. Magic 8 ball - same concept as Dicee but to randomise statements. Scope for usage of function (local/global etc.)
Entry 53 - This is more recap of basic code. One key point here was order of statements executed - always start with the top line and work down.
Entry 54 - BMI checker - good example of function. For in loop - bottles of beer challenge.
Entry 55 - Tags - these are really useful on Xcode. They are properties to be accessed to switch between values. Stack overflow - place to ask questions. Use of App Developer forums, Apple Website, AV Foundation...all ways of BORROWING (STEALING!) code. Catch/Do/Try for error handling. Finally scope - local/global. Tree analogy.
Entry 56 - My experimenting with 'Yahtzee' app. I want to return to that soon. Perhaps that could be my Xcode project for the week! Quizzler app....first of all MVC. Data model - created in a separate subfolder with a dictionary of key-value pair for question-answer.
Entry 57 - OOP. Some background about this. Restaurant analogy - love it! Different jobs - different objects. Modularising - splitting different jobs into different objects. A class as a blueprint - instructions for how to create objects. Got it. Properties, actions events...good stuff here. Format for question bank class. MVC - having files in separate folders for each of these.
Entry 58 - Use of question bank again for Quizzler app. Tracking score etc. Randomized responses - something I came up with myself.
Entry 59 - Destini app for creating own story. Remember working on this on the way to Eastbourne on the train! Key error here was creating a new if statement for each code line rather than the else if. Sender.tag - again the use of the tag. Restart/page number - lots of logistics her.e
Entry 60 - Auto layout and constraints. Need to look at this properly at some point. Best to do so in practice.
Entry 61 - Stack views - again can't remember this in detail.
Entry 62 - More complex aspects of Swift - classes including inheritance, initializers. Optional binding too. *Would be good to do this again as a general summary now I know more about it.
Entry 63 - *First Ray course! At this point, I wanted to get a fresh take on Xcode projects and code. General introduction then the use of outlets, actions. Ray did this all via code rather than connecting the objects to the code by clicking and dragging. Some orientation stuff for the device. Use of slider.
Entry 64 - Use of slider and updating values. Global/local - the latter within a particular method.
Entry 65 - Use of methods. These are used to then update something. Calling the method in a certain place each time. Putting methods together if they're always going to be called together.
Entry 66 - Working out the difference. Interesting how there were lots of ways of doing this - if statements etc. But the use of abs (absolute value) was by far the quickest! Then if statements for what the score is and the title changing accordingly.
Entry 67 - Use of closures - alert action etc. Function for starting over. New screens - this was a revelation at the time: being able to switch between different screens! Lots of syntax/knowledge needed to utilise these.
Entry 68 - Web views (didn't work!), auto layout...images and labels but looks complex.
Entry 69 - 'nextRound' function. Using an if statement to change the titles; linked to the round number. Rest is a recap of basic code principles. Ternary (or tertiary?) operator. Use of ? to compare values. Scope.
Entry 70 - Loops - for loops, while loops. And switch statements too!
Entry 71 - Functions (getting quite complex - good to check over) and optionals.
Entry 72 - Collections. Some about closures in collections - complicated stuff.
Entry 73 - Properties - details of computed ones. Some about protocols too.
Entry 74 - Classes vs structures including initialisers and inheritance. *Again a good one to check over to consolidate with.
Entry 75 - Still Ray's course but stuff from Brian. This is where it sadly started going downhill....
Entry 76 - MVC but again, quite tedious stuff.
Entry 77 - Some about protocols, delegates...to be honest at that point I gave up. *Last one of Ray/Brian's course.
So at that point I felt the need to change - to move away from copying out code that I couldn't really made sense of. It was the right move in a way, though conceptually a step backwards. Anyway, I felt the need to have the mini challenges built in with feedback to see how I was doing and test myself. So back to Treehouse - intermediate level!
Summary - 28 entries
Breakdown
Angela - 13 entries (50 to 62)
Ray - 15 entries (63 to 77)
STAGE 3
3.1 Treehouse (23.8.2018 to 4.9.2018)
Entry 78 - computed properties and how these compare to stored properties. Static - keyword used for type properties (only used within the function rather than with an object).
Entry 79 - reading modes (no idea what these are). Lazy SP - used for var. Ones that don't use any memory until they are used. Property observers - willSet and didSet.
Entry 80 - failable init - using keyword of throws to test for errors. Multiple inits - not too clear.
Entry 81 - *Extra entry - great to have these consolidation ones! Then delegation is clarified with the use of convenience init.
Entry 82 - Designated and convenience init. Designated - at least one needed (doesn't need keyword). Convenience covered. Required init - used as part of inheritance. Keyword needed.
Entry 83 - Semantics - getting mix of value and reference types. If you have a struct within a class for example. Value types (struct). Constants of structs can't have values changed. Reference (class) ones can!
Entry 84 -Type methods - use of static keyword. Nested ones - same for them too, Final keyword - e.g. used for functions or classes to show that they cannot be changed. No overriding.
Entry 85 - Extensions - changing a native type e.g. Int, String. Some computation/other features can be added. Protocols too with extensions - another way of adding and building them up.
Entry 86 - Memory management. MRR - used to be the case for counting objects etc. ARC - references/deinit method etc. Weak references - you see these with optionals and variables.
Entry 87 - Access control and access levels. Access levels go from open i.e. totally public to private. Guidelines/naming types - quite dull to be honest.
Entry 88 - Naming methods and fluid usage...at this point I gave up with Treehouse! It was getting too dull and tedious. I haven't actually been back since...at the point of writing this at least. *Made a list of what to cover for the Chris Ching course after trying the challenges and finding the second and third ones too tricky.
Anyway, at this point I was done with Treehouse - the content had been repetitive and away from interesting challenges for a little while. So I wanted to use my Udemy courses so I could focus on challenges to put my knowledge to the test. This started with the Chris Ching course...
3.2 - Chris Ching Course (7.9.2018 to 14.9.2018)
Entry 89 - Lots of recap - data types, switch, loops...all going over what I already knew really. Functions too - arguments labels and parameter names.
Entry 90 - All sorts here. Classes, inheritance, init, optionals...unwrapping including with guard.
Entry 91 - Properties, designated/convenience inits, arrays and dicts.
Entry 92 - Challenges 1 and 2. Challenge 1 - easy enough. Combining arrays with function and if statements.. no problems really. Challenge 2 - class with strings and characters, plus function...tricky stuff!
Entry 93 - Challenge 3. Lots of classes, functions...complex syntax to have arrays/dicts used with the square brackets. I remember struggling with lots of this! But good practice!
Entry 94 *Brief return to Angela Yu's course - one entry to focus on the use of APIs and CocoaPads - the idea of getting and using code that is already online
After the return to Angela, I felt instead the need to do more challenges and tasks that tested out my understanding of the syntax. It made sense at that point to go to Nick Walter's course, as it had plenty of challenges built in along the way...
3.3 - Nick Walter Course (15.9.2018 to 26.9.2018)
Entry 94 - *Joint with the previous entry of Angela's. Basics of using main types - ints, strings etc.
Entry 95 - print and comments, use of boolean and if statements. Good challenges to use hasSuffix property.
Entry 96 - Switch statements, arrays, dictionaries, loops, including challenge combining that with dicts.
Entry 97 - Functions, optionals and structures/classes. Functions within the struct/class. Optionals with some implicit unwrapping.
Entry 98 - computed properties, lazy stored properties, property observers. Syntax for this is making more and more sense, looking over it.
Entry 99 - inheritance, overriding - including use of final that prevents this, inits, deinits, failable *use of ? and isEmpty - for error throwing,
Entry 100 - Enumerations including those with (default values?). Type explicit for those. Error handling - using error protocol to conform to. Then use of throws within function for error testing. Custom built in errors.
Entry 101 - Extensions - doing so with custom types as well as native types. Challenges tricky but with rewarding!
Entry 102 - Protocols. Key point here is not to put the actual code in but what needs to be returned or the outcome. Delegation - using protocols to do different tasks within classes.
Entries 103 and 104 - EDU courses. Far too technical, poorly explained and escalated in difficulty very suddenly. Not worth it looking at it now!
Entries 105 and 106 - Angela course return (again!) - use of Alamofire, APIs, JSON...all things linked to making a weather reading app. But it didn't work properly - something out of date properly
It was at that point I realised that going through complicated projects was quite unfulfilling, especially when the code had become outdated. Going over syntax challenges from earlier, beginner courses was no point as I had evolved my understanding past that. So what I needed was a genuine Intermediate course, where I could really tighten my skills...
Summary - 27 entries
Breakdown
Treehouse - 11 entries (78 to 88)
Chris Ching - 6 entries (89 to 94)
Angela - 3 entries (1 shared; 94 and 105-106)
Nick Walter - 9 entries (1 shared; 94 to 102)
EDU - 2 entries (103 to 104)
STAGE 4
At this point, I was still confused about several key concepts, so the idea of doing an Xcode hands on project didn't really appeal. I went to Bob Lee as I had enjoyed his down-to-earth, relatable explanations of things before. So I purchased his intermediate course, which was three times the price as the others I had bought on the cheapest deals.
Bob Lee Course (2.10.2018 to 2.12.2018)
*Plus own project - How Many Letters - done towards the end!*
Entry 107 - Optionals including unwrapping. Difference between forced and implicit (using if/let). Optional binding too.
Entry 108 - Optional chaining. Use of guard and defer statements. Multiple values - putting them onto one line rather than nesting them.
Entry 109 - Error Handling - custom built errors, error testing using specific do/catch/try syntax. Putting in if statement in init part of class.
Entry 110 - Type casting - up and down casting. How you can go from native to 'any' type and then back. Using them as part of an array and down casting them to appropriate int or string. Custom types put in an array so that they become the same type as shared parent class.
Entry 111 - generics. How code can be used for any type. So for printing elements in an array - could be used for string or int array. Rather than creating one for each. Use of mutating func - changing the value of one of the properties. <Any> used.
Entry 112 - consolidation of previous 5 entries. Always useful!
Entry 113 - subscripts. Very much like functions. Class vs struct - key point her is even a constant with class can be changed. Mutability. Mutability for structs - can't be done or for any other value types that are constants.
Entry 114 - Sets - used for removing duplicated items; specific code (from NS) can be used e.g. insert, contains, symmetricdifference...Tuples - combining types!
Entry 115 - Extensions. Doing so for native types. Unary/binary/ternary (or tertiary) operators. Use of nil coalescing operator....used to choose between value and optional. Type alias - don't see the point of that but using another keyword for a value.
Entry 116 - consolidation of entire chapter 1 - lots here!
Entry 117 - Convenience init, computed properties - gettable and settable...
Entry 118 - Property observers - use of didSet and willSet. Failable init - used with throws used.
Entry 119 - Consolidation of last couple of lessons. Good stuff!
Entry 120 - Use of override method - what then is kept after inheritance. Two phase Initialization - example with struct for feet/metres (imperial/metric). Basically with structs, two different inits to choose from - DIFFERENT to convenience init in classes!
Entry 121 - Singleton pattern. Never made that clear!
Entry 122 - Consolidation entry of chapter 2 - from convenience init, computed properties, property observers, failable init...all that was generally fine. Also type methods - using keywords such as static so it's only used within the type, not on an instance. Classes also use class and final...Singleton again - something about tracking when it has been used...more for when sharing a project?
*Own Xcode project* - entries interspersed amongst Bob! Asterisked on each side of the name to make that clearly separate.
*Entry 123* - Letters in Words project. Basic setup of main view.
Entry 124 - Intro to closures - first two parts. Complex stuff and I will need to come back to this at some point!
Entry 125 - concept of lazy. Keyword used so that it's only accessed only when needed it. Saving memory. Some practice with 'We Heart Swift'. Use of Stephen De Stefano course - still not clear! Some key differences between functions and closures.
*Entry 126* - Letters in Words. Array of words, repositioning of labels on view. Function to reveal word from array - randomisation etc. Use of alert (taken from Bullseye app) to signal end of game (up to 5 questions). Updating and resetting scores functions. This was a big session!
*Entry 127* - Letters in Words. Use of number pad and text field, including adapting code to press enter! Finding and using a timer - a fruitless, endless search online for getting one of these! One link found to be tried next time...
*Entry 128* - Letters in Words. Timer worked! Lots of code to get the resetting, linking it to the alert. A lot of time needed to sort all of that.
*Entry 129* - Letters in Words. Last part on this! Though I have since tweaked the view one more time! This was changing the positions of the labels and buttons, the font - making it all more user friendly.
Entry 130 - (Bob Lee Course) - capture lists, trailing closures, completion handlers - all very confusing and enough to convince me that I had to stop with Bob here!
4.2 - Sandra Lee Course (2.12.2018 to 21.12.2018)
Entry 131 - Recap of variables and constants, type inference, operators and type conversion. Good for consolidation.
Entry 132 - Collections, functions, with different return types. Again, all consolidation here.
Entry 133 - Parameter labels, challenge of dice rolling (randomisation), use of arc4random updated, for loops, while loops, repeat while loops.
Entry 134 - If/else statements, switch statements, structures and classes and enumerations. Again, more consolidation than new stuff here.
Entry 135 - Object Oriented Programming, objects, classes and class inheritance, pizza restaurant challenge and example.
Entry 136 - Quiz App example including stack views, constraints, outlets and actions, control flow and modelisation. Ultimately disappointing but at least an opportunity to work on an Xcode project. End of Sandra's course for now!
Sandra's Quiz app was so flawed that it means I need to work on my own separately, rather than use the ideas from hers! Also, rather than just going back to Angela's (excellent) quiz - back from entry 56 - I'm going to branch out and try my own ideas for this. Then I will supplement the app with her ideas as they are simply better!
4.3 - Own Xcode Project 2 - Quiz App! (21.12.2018 to 2.1.2019)
Entry 137 - Start of second own project! F1 quiz - main view with constraints sorted, model of question bank, outlets and actions connected.
Entry 138 - F1 Quiz part 2! Big switch to have to simplify to true/false quiz. Four options proved too complicated! Managed to get 10 questions - similar to Angela's Quizzler app (entries 56 to 58!).
Entry 139 - F1 Quiz part 3! Various functions and logic needed for this. Had lots of issues with the wrong question/answer combo coming up. Managed to solve in the end. App pretty much complete!
Entry 140 - F1 Quiz part 4! Updated a few things - arrays for pos/neg messages and the final messages being more specific (f1 related). Got stuck with trying to get different classes of questions accessed. I'm sure there's a clever code for that, but I'm not there yet!
So after failing to 'complete' my own App, I figured I need to complete a course in its entirety. The advantage of this is that I can actually get/seek help wherever necessary and learn through more projects. In this stage, Bob Lee's course was ultimately disappointing, Sandra's was so illogical with her Quiz app that it made me move away from both courses. It makes total sense at this point to go to Angela's updated course, which will be a chance to refresh anything with the latest Xcode but also build more apps, which will then give more ideas for my own projects. I can also come back to the F1Quiz app once I have the technical knowledge for the difficulty levels. So here we are, back to Angela but this time to see the WHOLE course through!
Summary - 34 entries
Breakdown
Bob Lee- 19 entries (107 to 122 (one shared); 124-5; 130 )
*Own Project - How Many Letters* - 6 entries (122-3 (one shared); 126-9)
Sandra Lee - 6 entries (131 to 136)
*Own Project - F1 Quiz* - 4 entries (137 to 140)
STAGE 5
5.1 - Angela Yu Course - updated with XCode 12! - (2.1.2019 to 21.2.2019)
Entry 141 - Introduction stuff. Just getting this out of the way before the actual coding etc.! Freebies - always welcome.
Entry 142 - lots of useful design elements mentioned here. Websites included for app icon design and for generating relevant picture files and app icons. Picked up a lot more this time than last time!
*Called part 1 again by mistake!
Entry 143 - Sideloading (getting app onto phone), App Dev account, challenges (should I look at these at some point...), GitHub. More general stuff for this one. Start of Dicee App project.
Entry 144 - Dicee App continued. Lots about assets and getting the right picture files and app icons files. *Really useful stuff for getting all those bits for an app - using the websites as well as designing bits for free. Randomisation too - easier way without using arc4random.
Entry 145 - Arrays. Using an array of images in this case - neat idea! DRY principle for function use. Separate function - then used within the button pressed. Motion detection (not a big deal for me at the moment at least).
Entry 146 - Magic 8 Ball Challenge. Did well to get this set up on my own - didn't use Angela's step-by-step as was confident enough without this. Use of functions again logically with DRY, use of commenting out in one go - command function + \.
Entry 147 - Conditionals - used within love calculator and BMI challenge. And bottle of beer (conceptually tough). All good applications of if/else and for...in.
Entry 148 - Fibonacci sequence - always outfoxes me! But gave it a good go. Use of tags - REALLY useful concept. Error catching.
Entry 149 - Property list (p list) - status bar linked to this, OOP (use of classes), MVC; skim through of quiz app as done my own recently and used some ideas here.
Entry 150 - Destini app. Aced the logic with the if/else (MUCH better than 6 months ago!), use of functions again with DRY, auto layout and stack views - good challenges.
Entry 151 - Intermediate Swift concepts - classes including inheritance, properties, init, use of methods, enums, application of a lot of this with optionals and optional binding. Not project related but useful stuff.
Entry 152 - Clima App! It's about at this point that the 'new stuff' came in. So 11 entries of consolidation from before basically. Yes this was fiendishly tricky and ultimately unsuccessful for some reason. But I learned a lot of new concepts here about APIs and the use of Cocoa Pads. Much higher-level stuff.
Entry 153 - So about some delegation - still part of the Clima app. JSON brought into this - the java script, which is needed to get the info from the actual website.
Entry 154 - Segues - changing between the different screens with the actual CODE! I've tried this before without checking the code properly. Short entry this.
Entry 155 - Combination of delegates, protocols, segues...at this point I was pretty flummoxed but kept persevering with the project.
Entry 156 - Going over delegates and protocols again. Let's see....Ok so protocol is a bit like the offer for a job contract. Doesn't have the finer details just the position and income! Taking up the contract...the delegate being used here as a method...yep confusing as hell!
Entry 157 - A bit of a sidenote about command line terminal - what you can use it for, jumping around files, creating them...interesting but I don't see the point of actually using this regularly to be honest.
Entry 158 - Somewhere along the way, the Clima App just didn't work and I sucked it up - checked everything several times! So the next mini-challenge was a Bitcoin (relevant!) tracker, which I nailed! So that was cool. Again, use of podfile via the terminal program.
5.2 - Own Xcode Project 3 - Times Tables App! (25/2/2019 to 23/3/2019)
Going over Angela's course was rewarding, especially as everything made even more sense the second time around. However, from 152 - the Clima App and APIs - it cranked it up a massive conceptual leap. I struggled but just about coped. At this point, I really wanted to get into another own project - something simple but achievable. A times table app - perfect for combining various skills!
Entry 159 - This was a very, very brief entry (12 minutes!) just to lay out the MVC requirements.
Entry 160 - I then spent an hour getting the views and constraints set up properly. Constraints are a real bugbear of mine and I need to go back over the most logical, systematic way of putting these in.
Entry 161 - so the actual coding - the model! I started by trying to create a custom class, a bit like the quiz app. This did not work! So I left it there, with some ideas but no actual model for the times table generating.
Entry 162 - Simplified view - just a white background. Buttons and labels all connected. Timer all in, alerts, random number generation....wow a lot was achieved here! This was a 2+ hour entry, so it's where the project basically came together.
Entry 163 - Bugs fixed including why the pop up was coming up too late. Keyboard code not even needed apparently! Code cleaned up and working well! App complete!
5.3 - Angela Yu Course - updated with XCode 12, continued! - (23/3/2019 to 10/4/2019)
Entry 164 - Now into a new project - Flash chat! Firebase account - created for the first time and this did take a while to work! It did in the end. Must remember to use this again for something... Online database - a way of tracking and monitoring the usage of the app too.
Entry 165 - Registering users. All part of the Flash chat project and various issues with the code. I persevered though!
Entry 166 - Closures (I still find these so mind boggling), completion handlers (messages coming when tasks completed) and navigation controllers - embedding this next to the view controller. Not sure about much of this.
Entry 167 - Still part of Flash chat - logging in, table views....a lot to get sorted but eventually it worked!
Entry 168 - UI animations, the user interface/experience with sending messages. I did a random colour array to change the message colour for each user, but didn't quite make sense! At least it was all working.
So, I felt like the conceptual stuff was going way above my head. I had to get to grips with closures and other aspects before plowing straight on into another project! I also had been slacking in terms of regular entries so felt the need to focus more on syntax than projects.
5.4 - Consolidation - (4/5/2019 to 5/5/2019)
Entry 169 - Consolidation entry for closures. For some reason I went back to Bob Lee! No offence Bob, but his stuff is just so vague and hard to follow. I tried some other bits but still couldn't make much more sense.
Entry 170 - Final bit of attempted consolidation. Not much joy again!
5.5 - Nick Walter Course Swift 5 - (3/6/2019 to 10/6/2019)
Entry 171 - A big gap between entries and not feeling prepared to take on Angela's higher order stuff, I thought it good to go for a course that specialised in Swift 5! For this first part, it was all recap. I did two hours worth and went through all the basics and moved on to more complex stuff with conditionals.
Entry 172 - This was a 'bonus' entry, just to do a summary of what I had achieved over a year. I had different dates as headings and checkpoints.
Entry 173 - Back to Nick Walter's course. Tuples, sets, functions, optionals, classes, enums... All good. The challenge was again very manageable so mostly recap here.
Entry 174 - Well this had a much tougher challenge! Really outfoxed me - basically had to do a word counter for a text, which turned out being harder as doing a .count on strings does the characters!
Entry 175 - Consolidation entry - went over the challenge from 174 again, which was much needed as I made better sense of it and did not rush. Still found it hard and needed help but ended up picking up some useful stuff here.
Entry 176 - Various bits and pieces about what is new in Swift 5. Useful to get a summary.
Entry 177 - A mixture of recap and about making a package/using other people's code.
Entry 178 - So part of the project, this was basic stuff about having a button run a function to change the background colour to red.
Entry 179 - If statement used in conjunction with randomisation to vary background colour (at random!). Actually, it was just a set order - I came up with the randomised element, put that as a comment on his course, which he was impressed by!
So a productive week with pretty much daily entries - sometimes more than one per day! That is the way to go - the learning moves on so much more as there isn't that need to make sense of it all again each time. I thought to crack on with another course on Udemy, rather than Angela's. I found another that promised a Swift 5 compatibility.
5.6 Stephen DeStefano Course Swift 5 - (11/6/2019 to 25/7/2019)
Entry 180 - Like with Nick's course, more recap of basics, which is healthy to do to be fair. Quizzes after every lecture or two, which was a good way to check understanding.
Entry 181 - Quick session focused on tuples.
Entry 182 - Functions - quickly becoming technical with inout and other keywords.
Entry 183 - Properties. First session in a little while and first being back in UK for summer.
Entry 184 - Lots about value vs reference and initialisation. Again, very technical stuff - not as accessible as Nick's and nowhere near Angela!
Entry 185 - Optionals and control flow. Fairly brief session but covered a lot.
Entry 186 - If/else and switch statements. Guard statements. Then loads on strings which I skimmed through.
Entry 187 - Collections, enums and error handling. All pretty involved stuff.
Entry 188 - What is new in Swift 4.1 and 4.2. Bit of a con, considering that the course is supposedly updated to Swift 5! Good though to find out about more recent features.
Entry 189 - So breaking point! I honestly thought the practical would be fun and useful. It wasn't! From strangely different options on Xcode to ridiculous amounts of code to copy and poor explanations, I am totally put off Stephen!
So that covers the 'intermediate and project' learning phase, which has been a long and, mostly, fruitless stage really. I may be being harsh on myself, but I feel little has been achieved in nearly 7 months of learning. So this is why the next move makes sense....summary to do first!
Summary - 49 entries
Breakdown
Angela Yu- 23 entries (141 to 158; 164 to 168)
*Own Project - Times Tables* - 5 entries (159 to 163)
*Consolidation*- 2 entries (169 to 170)
Nick Walter - 9 entries (171 to 179)
Stephen DeStefano - 10 entries (180 to 189)
So there we have it. Looking at it, Stage 5 was where APIs really kicked in with Angela's course, I had another successful own project - with little to go on, and I consolidated lots of intermediate features. Stage 6 is all about it having it on one format. One method, one site. Treehouse! Yes, back to where it began! Last time I was here, it was August - end of summer holidays so nearly a year ago. It would be naive to think it will suddenly be great, as I was so exasperated with it before. But I have a new mission now, to complete the Intermediate Swift Track! Yes, that is what Stage 6 is all about!
STAGE 6
6.1 Treehouse Course - Intermediate Track (29/7/2019 to 30/8/2019)
Entry 190 - All about API guidelines - certain rules to use to ensure consistency and transparency. Certain rules for protocol naming conventions e.g. -ible, -able etc. For functions, to use as a verb and clear argument labels that are logical. Grammatically sound, which I love to hear!
Entry 191 - More on API guidelines. Certain rules like use of prepositions - to, at etc. Used after base (function) name if multiple argument labels. OK, I've just got the mutated/non-mutated bit. Mutated - more present tense whereas non-mutated past e.g. sort vs sorted.
Entry 192 - First part of generics! So starts off with using the <T> for a function that multiple types could use. E.g. swapping values for Ints/Strings/Doubles etc. Use of 'Any' type. Other syntactical things like use of & (ampersand). From further reading, a key point is that other types e.g. optionals, arrays, dictionaries are all generic types too - e.g. an array of ints all have to be ints.
Entry 193 - More on generics. Long-winded code to show how map features can be created from scratch. Use of equatable protocol - so that you can compare values for a new, custom type.
Entry 194 - Next generics. More of creating functions from scratch with generic type e.g. largest, which must follow comparable protocol. Passing a function as a parameter...this will link to the future closures stuff! Now info on generic types - e..g Array is a type and an array can be created with different syntax using that keyword.
Entry 195 - Linked lists! These were so confusing and I still don't see the point. Stuff about single/double linked lists...nodes being each item...all very confusing. SO you can create your own linked list...but so much code to add to this. Mental stuff here.
Entry 196 - Associated types (still on generics here!)...This was also confusing. A bit about type alias, which I TOTALLY get now! That is useful. The key thing here is using associated type is useful because you still can inherit the behaviour of a specific type, rather than using 'any', which has no specifics for type behaviour.
Entry 197 - Lots more about protocols and some extending the generic type...but all seems pretty vague looking at it again.
Entry 198 - Consolidation entry on generics.
Entry 199 - First part of closures! More about functions for this first part - how you can have a value declared as a function then use it etc. Then putting in functions as parameters...More use of type alias, which makes more sense. Return type as a function...lots of stuff.
Entry 200 - Next closures! Showing the increasing shorthand of writing a closure to the dollar signs!
Entry 201 - Use of 'map'! OK, so that's a closure that can be used on arrays. Use of trailing closures - when the closure statement is at the end of the line/last thing in the line of code.
Entry 202 - Other built-in features like flat map, filter, reduce...various aspects here.
Entry 203 - Extensions on ints....use of throw and throws which was confusing!! Memory consideration - use of the @escaping... unowned vs weak keywords. That was it on closures.
Entry 204 - First of delegation! Design pattern with the really cool example of race horses! It was a shame that I couldn't develop this as much as I would've liked.
Entry 205 - next delegation. Info on why these are good for the long term strangely lacking...not actually clear why we're bothering with delegation at all! A strange example in lots of ways! I did however have fun with changing the code to make it F1-related.
Entry 206 - CL location manager and text field delegation - the concept of this was clearer. If you wanted to advertise a job out, you would put in the specifications. A delegate is technically a protocol that fulfils those requirements. Last one on delegation by the way!
Entry 207 - First part of the interactive story - this was all dandy to begin with! Use of navigation controller made sense - having it embedded in. I like the idea of the view controllers all coming off the NC. The NC becomes the Root controller. The segue show - has automatic features like a back button. All fine.
Entry 208 - Second part of the story app project. A cool intro with having a pipe dream plan of how I can progress with my Swift journey! Then a LOT of code for the classes and various bits for having the story. It was a lot but I did like the structure to it all. Better than Angela's having it as separate values!
Entry 209 - Third part of interactive story...and the last it turned out! I found the programmatic part so confusing and difficult to make sense of. It seemed deliberately verbose and I realised I didn't have the time nor patience to see it through. End of Treehouse, and this sub-stage!
6.2 - Lynda.com free trial (31/8/2019 to 21/9/2019)
Entry 210 - Unofficial first entry! This started as a line drawn under Treehouse, with no aim to return! I can't return there - it's too out of date and it won't help long term. Nice to visit it for a month though!
Entry 211 - So this was a new exciting platform to explore that only ended up with one really decent course worth completing, which was a shame. Anyway, real basics covered here - variables, constants etc.
Entry 212 - Continuing on with collections, tuples etc. Some good detail with nested dictionaries.
Entry 213 - Loops, optional binding and switch statements.
Entry 214 - Overloading functions (functions with the same name but with unique signatures), closures and type alias
Entry 215 - Type alias - needed to go over this as didn't get it right first time.
Entry 216 - Custom types - classes, structs, use of static, private, subclassing - quite a lot of complex stuff here
Entry 217 - Enumerations, including raw values, protocols, extensions and error handling
Entry 218 - Final challenge that had various bits to it. Did a final wrap up of where to go next. Went for RW.com, which ends this brief section!
Entry 219 - One final part - a useful going over of the whole yet, picking out the key aspects. This is worth revisiting again in fact as there are various elements to look at here.
6.3 - Raywenderlich.com: Swift UI intro (30/9/2019 to 25/12/2019)
It took a bit of time to get full functionality of latest Xcode but I did and it was onto rw.com! Having assessed all of the options, it was between this and the Reinder guy. Initially, I went for a monthly payment but once the annual subscription came down significantly in cost, I went for that.
The first few of these were all the Swift basics recap, using most up to date language features.
Entry 220 - Setting up and overview for what I will be learning.
Entry 221 - All basics of Swift.
Entry 222 - Collections and loops - including nested ones.
Entry 223 - More collections: dictionaries and sets.
Entry 224 - Functions and use of ternary operator in these. Also type alias for shorthand use.
Entry 225 - Structures and classes
Then it was project time - building the bullseye app, one which I did before with UIKit.
Entry 226 - Objects, data and methods - all core to object-oriented programming. Changes to other bits - buttons not needing 'connecting' etc. 'State' - a bit like an on/off switch on a car dashboard. So an intro to the new features of SwiftUI.
Entry 227 - Swift UI Views - very easy to put in labels and sliders etc. The use of stacks and spacers too.
Entry 228 - Binding the state var with an object - in this case a slider. Basics mentioned. Methods - main difference I've noticed with previous Xcode is the function returning something. A bit about type inference and var scope.
Entry 229 - More on basics and function to update score.
Entry 230 - Images - getting the three different x1, x2 and x3 versions and putting into assets. View modifiers - code to change appearance of text/images etc. Styling buttons and sliders - various options.
That was the end of a successful start to SwiftUI. I continued with the next logical project - a to-do app from Jessy Catterwaul.
Entry 231 - Started fine with what a model is, then went into very technical stuff...I stuck with it but am still not sure what dependency injection is. Lots of tricky bits just in the first few lessons.
Entry 232 - Modal views... all very hard again. Also, whatever I did, the project was riddled with errors. So abandon ship on this one!
So the above was way too hard! A good time now to try making a project - updating one I'd done before (HowManyLetters?) to SwiftUI!
Entry 233 - A great effort with getting all of the texts, stacks etc. Discovery of actually setting the spacing (but that may not translate well to other devices)
Entry 234 - The 'model' part made - nice and easy. And actually I did it as a struct, then created an instance in the main Content View. That was something I never managed to do before - keeping the array of words separate to the main body of code! Gave up as I tried all I could but to no avail to get editing of text box. But good practice!
It made sense now to focus on learning more about SwiftUI - so many differences after all! Laurie's course below was technical but useful.
Entry 235 - Biggest difference - no view controller! View is updated automatically...live update...a bit about the stacks. Lots of cool things basically in SwiftUI.
Entry 236 - Features with images - resizing, aspect, clipping, styles, then some about buttons.
Entry 237 - Sliders and steppers; date pickers and toggles...lots of cool, easy things to create here. A lot easier than all of the VC stuff from before.
Entry 238 - Stacks - about the use of ZStack in particular as this hadn't been gone into as much before.
Entry 239 - ForEach - an alternative to for...in... And some on lists and forms - other keywords used to create objects/layouts on SwiftUI.
Entries 240 and 241 - *bonus entries to consolidate everything from previous 5 lessons. Good practice, using F1 drivers as the content to play around with.
Entry 242 - Use of scroll views which included use of Geometry Reader and proxy. Technical but useful!
Entry 243 - Navigation view. Use of new Swift files to put in certain bits of code - tidying up the main file. Tab bar as well but I don't remember much about that.
Entries 244 - 246 - *bonus entries! A lot of great putting into practice - my F1 driver scroll through app. I used the previous two entries and the images/ideas from the other bonus project to make something pretty cool.
So a lot learned from Laurie's course - plenty of info and practice with the different properties and features of SwiftUI. At this point, it was the right time to go into some technical stuff.
6.4 - Raywenderlich.com: Technical Code and Layout (8/1/2020 to 13/3/2020)
The first course during this time (Catie Catterwaul) was all about functions and types. More complex stuff, including closures.
Entry 247 - Intro to functions - mostly recap including overloading and default values.
Entry 248 - Advanced parameters - variadic, in/out including the ampersand (&), that functions are a compound type - they have their own SIGNATURE. Use of type alias instead of using that complicated signature each time; closures being similar but key differences.
Entry 249 - Closure syntax - tricky! But the usual stuff of going from more verbose to the use of $0 and $1. ForEach (new in Swift 5) and use of maps as closures for arrays.
Entry 250 - More on maps - compact and flat maps.
Entry 251 - Filter, reduce and sort - all specific uses of map.
Entry 252 - Enums and the use of allCases if made of type of string and case iterable. Also raw values mentioned.
Entry 253 - Use of switch statements. Switch within function. Use of value binding - use of let and where for storing a temporary value in a switch statement.
Entry 254 - Properties and methods. Stored props, computed props and lazy props.
Entry 255 - Use of mutating func (when the parameter value will change). Other stuff with caseIterable again too.
Entry 256 - Class inheritance and a bit about polymorphism (up/down casting)
Entry 257 - Initialisation - designated, convenience...required...a bit on protocols too.
Entry 258 - Extensions - a neat tidy way of adding to a type. Protocols - requirements laid out that have to be satisfied. Value vs reference type - Objects are technically classes and values are structs. Best for each class to have a single concern.
Entry 259 - Consolidation on the above!
So lots of useful stuff in this course. Got to grips with the more technical aspects of functions and types - and should refer to this stuff whenever needed. Then it was Catie with Jessy for auto layout...
Entry 260 - Stack alignment - use of the V and H stacks to put together different bits of text and pictures.
Entry 261 - Alignment guide - having the line go through the object, or through the top or low points; custom alignment - coding this for something more specific.
Entry 262 - ZStacks - think of it as the background. Padding - made more sense (barrier around the object). Geometry reader - a view; proxy provides access to it as it's an instance of the view.
Entry 263 - *So next three lessons are back to UIKit. Autoresizing, stack views - grouping views together.
Entry 264 - Intrinsic content size - the size that will fit into the view. Content hugging and compression resistance - vertical and horizontal settings for each, so four options to set. When priority of CH and CR is the same - ambiguity! Nesting stack views.
Entry 265 - Constraints - adding in new ones in one go; minimum font scale; using highest level stack to set the constraints - rather than each item (that's where I've gone wrong before!)
Entry 266 - Consolidation of all of the above.
So that was layout - both in SwiftUI and UIKit. So plenty of good stuff! From here, I had realised that there was so much Beginner content unexplored, things I needed to look at before considering Intermediate. And enough on this stage of learning.
Summary - 77 entries
Breakdown
Treehouse - 20 entries (190 to 209)
Lynda - 11 entries (210 to 220)
Raywenderlich.com - 45 entries (221 to 266 bar two) including consolidations!
*Own Project - HowManyLetters* - 2 entries (233 to 234)
STAGE 7
Total sense to see this as a new stage! I've learned a lot about the technical aspects of Swifts, have worked on various projects - to differing degrees of success - and got a grasp of the new SwiftUI.
The key in Stage 7 is to be confident with ALL of the beginner-level aspects of Swift, ready to move on to what is considered 'Intermediate'. It's taking a while to break through but I know that I'm not ready to be considered at that level yet. I'm going to complete anything else, relevant and recent on rw.com that is beginner, then proceed on to the next stage. Stage 6 took AGES and was meandering - no real focus.
So in Stage 7 I want to pick up specific new skills from the articles (stage 7.1), then in 7.2 complete ANY other courses that I haven't and seem relevant. 7.3 will then be a big old consolidation - going through everything on Swift that I can remember, giving myself challenges and mini projects. I want to be ready for Stage 8 at the start of May!
7.1 RayWenderlich.com: articles (14/3/2020 to present)
Entry 267 - Storyboard intro article - all setting up using Storyboards and use of VC, NC, segues...all interesting to practice.
Entry 268 - The second part of the above. Connecting it all together.
Entry 269 - More on segues and having a whole app connected with code. Lots of technical code starting to be put in.
Entry 270 - Putting it all together including purpose of different parts like the text field; lots of settings and code needed for this.
Entry 271 - Consolidation of previous two entries - what the code actually means!
Entry 272 - Swift UI animation part 1 - modifiers, transitions, state changes.
Entry 273 - Combining transitions together; asynchronous animations - second and final part of this article
Entry 274 - Navigation tutorial. Using UUID to identify specific objects; navigating to a detail view all with Swift UI
Entry 275 - *Final entry to wrap things up after hiatus*
So, the final 'proper' entry was 274. This was back on 20th March, so the entire blog lasted for nearly two years! I could continue and add to this one, but after several months of being unable code, it feels more appropriate to start a new blog - explained in entry 275. So signing off here but the new blog will start now!
Not so much of an update actually but more of a checkpoint/summary to show what I have achieved and where I am with my Swift understanding at this point.
Basically, at around Christmas time, 2017, I felt the urge to resume my Swift journey. It had been very patchy - at best - for the two and a half years prior to then. For a time - approximately April to August 2015, I was on a real roll. As I've already outlined before (so will keep it brief here), coming to Dubai put a hold on that progress.
Happily, I can genuinely say - after 5 months of consistent practice - that I know much more than I ever have and am at a much more advanced point than I was in August 2015. The real turning point was in June, after a couple of pointless, sporadic entries based on an eBook, I decided to do a total reset. This did seem to be a step backwards initially, but my rebuilding was essential. Using Treehouse was the key here.
So this entry will summarise my Swift journey from 4th June to today. I will break it down into the courses used to bundle together (like a class or struct!) the key lessons and points covered.
*My first 10 entries were as follows:
Entries 1 to 4 - My history of Swift and what I know so far
Entries 5 to 10 - Specifically linked to 'Learning to Code in Swift4' by Kevin McNeish (with one update entry within this)
STAGE 1
Treehouse (4.6.2018 to 18.7.2018)
Going back to the basics is always a little humbling but I'm so glad I did. This did mean a cost of $25 a month, but boy was it worth it.
Entry 11 - history of Swift and what variables are. Equals being the assignment operator - wow this really was basic!
Entry 12 - constants and immutability, concatenation and string interpolation. Unsure of why 'let' is the same as constant.
Entry 13 - numbers and booleans, type safety - how errors will come up if the wrong type is used/changed
Entry 14 - arithmetic operators - not just the basic 4 operations but putting together variables too, needing to use the same type for calculations i.e. not being able to use Int with Double. Difference of assignment (=) and is equal to (==). Remainder operator (%). Operator precedence - different to BODMAS in that it is mult, div, modular (%), add, sub. Finally unary operators - += 1, this is unary as there is only one value mentioned! Lots more here in this entry!
Entry 15 - collections (arrays, dicts and sets). With arrays, adding to them, modifying, mutating...then removing or inserting values within the array. Count can be used too. OK, all fine.
Entry 16 - dictionaries specifically. The key-value pair syntax. Modifying items including using 'nil'. Dictionaries are technically optionals so can contain nil!
Entry 17 - Loops - for/in etc. Closed/open range - if it is closed then it is e.g. 1...7; half open is e.g. 1..<7 - so half-open means it will be less than one of the number at the end of the range. While and repeat while. With repeat while, you carry out the block of code, then test the condition. In practice, for in seems to be the most useful of these.
Entry 18 - If statements - again, linked to conditionals. If statements used with print statements. Logical operators - && meaning and; | | meaning or. This is used for including multiple conditions. Not operator ! before something. != meaning not equal to. Or !isRaining would mean the opposite of the bool for isRaining. Etc. Switch statements - syntax of case and default. Has to be exhaustive. Use of switch statements in arrays and in for-in loops.
Entry 19 - Functions. Syntax for first of all no parameters to building up to these. All this seems easy now.
Entry 20 - Functions again. Naming conventions (link to grammar). Argument labels. Outside ones - for used outside the block (external); inside - local. Switch statements within functions. Scope - how variables within a block cannot be used outside of it.
Entry 21 - structs - coordinates example. Instance methods - functions associated with a particular type. Init method - this is used to set initial values or to list which variables need values adding to them.
Entry 22 - classes. Looking at this now, what a confusing way to introduce classes! Combining the point struct with this...lots of values to make sense with. Helper methods - created in order to help with another one. E.g. to obtain a bool or specific value.
Entry 23 - Inheritance - the point of this is not to create new classes every time but to use inheritance when there are enough shared properties that makes this worthwhile. Override - this keyword is essential and I totally get the point of it now but did not back then! The point of this is that you need to do this as the init has changed from the original super class init. This definitely wasn't clear the first time around and has actually confused me a bit. Value vs reference - no real details at this stage.
Entry 24 - *Interim practice - this was as I was confused by initialization for class/struct. To have this clarified - the examples show some values all declared within the class, so no init needed! For just the type but no initial value, that's when init is needed. Superclass init a bit clearer too.
Entry 25 - Enums. Good as you can select from other options. Using the cases and the .case syntax etc. Functions used with enums. Switch used for this. Custom enums - avoids errors as there are finite options.
Entry 26 - Enums again. Associated values - you can declare the types for cases basically. From Ibrahim's course, variations with having tuples for a case (including parameters), also for anything numerical e.g. months, Xcode figures out that all the cases will follow a numerical order.
Entry 27 - Optionals! Avoiding forced unwrapping. Optional binding - using if/let for this. Link to dictionaries too (complex example!). Haven't mentioned that this implicit unwrapping.
Entry 28 - More on optionals. Other options - for guard statement. No need for nested (brackets within brackets).
Entry 29 - Enumerations. Default values given. The example was with coins - nickel, dime etc. It is better to set default/raw values than it is to do the switch statement - checking each case then giving a value based on that. The link here is that error codes can be created as an enum. Then used for optionals. Optional chaining - list of values looked at together. Arrays - used for items in enum etc. Nil coalescing - the use of the ?? - using a value or the optional.
Entry 30 - protocols. This being a blueprint for behaviour. Link to get here. OK, so link to computed properties too - how there needs to be some computation etc.
Entry 31 - long-winded example here. I think the point is that protocols are easier to use to show some behaviour than creating multiple classes etc.
Entry 32 - Three types of protocols: can do, is a and can be...not too sure about these. I think the idea here was a function in a protocol can then be used in other class/struct etc. As long as it conforms to the protocol mentioned, then it's OK. These examples are not clear though!
Entry 33 - Last one on protocols! The point is that they ENCAPSULATE an aspect of behaviour. It avoids inheritance, if there is just ONE PARTICULAR THING that is desired. E.g. bird/plane - it is just the 'fly' behaviour needed. Get and set not too clear at this point.
Entry 34 - Using Xcode for a project. Just an intro here.
Entry 35 - Continuing Xcode. Info about view controllers - link between app data and the visual appearance. IBOutlets - weak a they don't have any functionality and just display. IBActions - these do!
Entry 36 - More on the app project. Use of an array within the project (facts). The facts array needs to be outside of the function (global not local!). MVC - important this! Model - being key classes and data; View - what is seen on the app and Controller - mediates between the two.
Entry 37 - Next part of app. So this brings up auto layout and the use of colour. This is something I am in need of looking at again.
Entry 38 - final part. Running the app on a device and adding an app icon. I'm sure there's a bank of the latter that I could get when it comes to doing my own!
Entry 39 - Error handling. Different types of errors - quite confusing way to introduce this! Would have been better to have explained that we need to build in error code!
Entry 40 - Debugging code for app (F1 Facts) and more error handling. Not much on the latter as I didn't really get this. It mentions Defer - now I know that you leave that statement until last.
Entry 41 - first of Vending Machine app. Something has clicked into place - the use of get/get and set for protocols are then left blank because the actual code is not needed there. Get - read only. P-list - way of organising the information in a clearer table. Using XML - language for reading these. Type method - used directly on the type itself not on an object. Static keyword. Type alias mentioned - alternative name for existing type. NS - a prefix for using older Objective C types. SO much here!
Entry 42 - Next one of the app. Type casting used. Wasn't even aware of it! Would understand the context of down casting and the as keyword much more now! The rest of this did not look verbose and confusing - I think I gave up on trying to understand it at that point!
Entry 43 - Next one of app. Displaying icons - obviously pictures were already saved for me. Steppers - now these did look cool. Being able to select different values on a display.
Entry 44 - penultimate one of app. Design views - aspects to consider - clarity, deference and depth. Alert views - this is where we can choose from options of what can come up when alerts are needed.
Entry 45 - last part. Some links to error handling but not very clear what I learned here. That was it fr the app I think!
Entry 46 - All about auto layout. Layout considerations - position and size. All quite vague and from this point, the pictures I put in cannot be seen! This was resolved more recently.
Entry 47 - Layout margins. Red lines used to show inequality relationship - so something needs to change basically. Leading - left/up, trailing - right/down. Again, this seems vague as I haven't used the actual Xcode program for a while! Stack views but don't know much about this from the blog info.
Entry 48 - Programmatic auto layout. I remember this now - all views programmed specifically by code. Really technical and pointless from what I remember!
Entry 49 - Similar to above.
Summary - 39 entries
Breakdown -
Entries 11 to 24 - Fundamentals
Entries 25 to 33 - More Intermediate
Entries 34 to 49 - using Xcode for projects/auto layout (apart from 39 and some of 40)
So there was a lot of useful stuff here. My understanding of syntax of the basic principles really strengthened. I got caught up with initializers - had to get my head around these especially with the override after inheritance. Error handling was baffling but is a lot clearer now. The projects were a mixed bag - the fun facts was a great introduction but the vending machine was mostly confusing. And auto layout - some useful tips but not the programmatic ones.
STAGE 2
So from 18th July, I switched from Treehouse to Udemy! Having a plethora of courses already purchased, the issue I had was that none of them seemed that good. It also didn't help that they were mostly out of date. The most recent one was actually purchased around a year ago (I think) so was not too outdated. It turned out to be the right move - overall her course has been easily the best one I've seen on Udemy (no offence, Bob, Ray et al).
The next set of summarises are for her course - not a whole stage required for this.
2.1 - Angela's Course (18.7.18 to 29.7.18)
Only actually 11 days in total, but so much learned in that time!
Entry 50 - *First Angela course. An introduction to the course - as you'd expect! Making the 'I am Rich App' - basic introduction to using Xcode with the storyboard, the points/pixels. Introduction to what Github is.
Entry 51 - Use of the image views, logos etc. for the Dicee app. Debugging - when SIGABRT comes up, that usually means an object has not been connected properly. That used to happen to me a lot with labels/buttons. Randomisaiton - arc4random. Best way of randomising with the dice was an array (not the switch statement that I did initially).
Entry 52 - Use of DRY (don't repeat yourself) - good concept! Function use for the dice changing. Motion detection added. Magic 8 ball - same concept as Dicee but to randomise statements. Scope for usage of function (local/global etc.)
Entry 53 - This is more recap of basic code. One key point here was order of statements executed - always start with the top line and work down.
Entry 54 - BMI checker - good example of function. For in loop - bottles of beer challenge.
Entry 55 - Tags - these are really useful on Xcode. They are properties to be accessed to switch between values. Stack overflow - place to ask questions. Use of App Developer forums, Apple Website, AV Foundation...all ways of BORROWING (STEALING!) code. Catch/Do/Try for error handling. Finally scope - local/global. Tree analogy.
Entry 56 - My experimenting with 'Yahtzee' app. I want to return to that soon. Perhaps that could be my Xcode project for the week! Quizzler app....first of all MVC. Data model - created in a separate subfolder with a dictionary of key-value pair for question-answer.
Entry 57 - OOP. Some background about this. Restaurant analogy - love it! Different jobs - different objects. Modularising - splitting different jobs into different objects. A class as a blueprint - instructions for how to create objects. Got it. Properties, actions events...good stuff here. Format for question bank class. MVC - having files in separate folders for each of these.
Entry 58 - Use of question bank again for Quizzler app. Tracking score etc. Randomized responses - something I came up with myself.
Entry 59 - Destini app for creating own story. Remember working on this on the way to Eastbourne on the train! Key error here was creating a new if statement for each code line rather than the else if. Sender.tag - again the use of the tag. Restart/page number - lots of logistics her.e
Entry 60 - Auto layout and constraints. Need to look at this properly at some point. Best to do so in practice.
Entry 61 - Stack views - again can't remember this in detail.
Entry 62 - More complex aspects of Swift - classes including inheritance, initializers. Optional binding too. *Would be good to do this again as a general summary now I know more about it.
Entry 63 - *First Ray course! At this point, I wanted to get a fresh take on Xcode projects and code. General introduction then the use of outlets, actions. Ray did this all via code rather than connecting the objects to the code by clicking and dragging. Some orientation stuff for the device. Use of slider.
Entry 64 - Use of slider and updating values. Global/local - the latter within a particular method.
Entry 65 - Use of methods. These are used to then update something. Calling the method in a certain place each time. Putting methods together if they're always going to be called together.
Entry 66 - Working out the difference. Interesting how there were lots of ways of doing this - if statements etc. But the use of abs (absolute value) was by far the quickest! Then if statements for what the score is and the title changing accordingly.
Entry 67 - Use of closures - alert action etc. Function for starting over. New screens - this was a revelation at the time: being able to switch between different screens! Lots of syntax/knowledge needed to utilise these.
Entry 68 - Web views (didn't work!), auto layout...images and labels but looks complex.
Entry 69 - 'nextRound' function. Using an if statement to change the titles; linked to the round number. Rest is a recap of basic code principles. Ternary (or tertiary?) operator. Use of ? to compare values. Scope.
Entry 70 - Loops - for loops, while loops. And switch statements too!
Entry 71 - Functions (getting quite complex - good to check over) and optionals.
Entry 72 - Collections. Some about closures in collections - complicated stuff.
Entry 73 - Properties - details of computed ones. Some about protocols too.
Entry 74 - Classes vs structures including initialisers and inheritance. *Again a good one to check over to consolidate with.
Entry 75 - Still Ray's course but stuff from Brian. This is where it sadly started going downhill....
Entry 76 - MVC but again, quite tedious stuff.
Entry 77 - Some about protocols, delegates...to be honest at that point I gave up. *Last one of Ray/Brian's course.
So at that point I felt the need to change - to move away from copying out code that I couldn't really made sense of. It was the right move in a way, though conceptually a step backwards. Anyway, I felt the need to have the mini challenges built in with feedback to see how I was doing and test myself. So back to Treehouse - intermediate level!
Summary - 28 entries
Breakdown
Angela - 13 entries (50 to 62)
Ray - 15 entries (63 to 77)
STAGE 3
3.1 Treehouse (23.8.2018 to 4.9.2018)
Entry 78 - computed properties and how these compare to stored properties. Static - keyword used for type properties (only used within the function rather than with an object).
Entry 79 - reading modes (no idea what these are). Lazy SP - used for var. Ones that don't use any memory until they are used. Property observers - willSet and didSet.
Entry 80 - failable init - using keyword of throws to test for errors. Multiple inits - not too clear.
Entry 81 - *Extra entry - great to have these consolidation ones! Then delegation is clarified with the use of convenience init.
Entry 82 - Designated and convenience init. Designated - at least one needed (doesn't need keyword). Convenience covered. Required init - used as part of inheritance. Keyword needed.
Entry 83 - Semantics - getting mix of value and reference types. If you have a struct within a class for example. Value types (struct). Constants of structs can't have values changed. Reference (class) ones can!
Entry 84 -Type methods - use of static keyword. Nested ones - same for them too, Final keyword - e.g. used for functions or classes to show that they cannot be changed. No overriding.
Entry 85 - Extensions - changing a native type e.g. Int, String. Some computation/other features can be added. Protocols too with extensions - another way of adding and building them up.
Entry 86 - Memory management. MRR - used to be the case for counting objects etc. ARC - references/deinit method etc. Weak references - you see these with optionals and variables.
Entry 87 - Access control and access levels. Access levels go from open i.e. totally public to private. Guidelines/naming types - quite dull to be honest.
Entry 88 - Naming methods and fluid usage...at this point I gave up with Treehouse! It was getting too dull and tedious. I haven't actually been back since...at the point of writing this at least. *Made a list of what to cover for the Chris Ching course after trying the challenges and finding the second and third ones too tricky.
Anyway, at this point I was done with Treehouse - the content had been repetitive and away from interesting challenges for a little while. So I wanted to use my Udemy courses so I could focus on challenges to put my knowledge to the test. This started with the Chris Ching course...
3.2 - Chris Ching Course (7.9.2018 to 14.9.2018)
Entry 89 - Lots of recap - data types, switch, loops...all going over what I already knew really. Functions too - arguments labels and parameter names.
Entry 90 - All sorts here. Classes, inheritance, init, optionals...unwrapping including with guard.
Entry 91 - Properties, designated/convenience inits, arrays and dicts.
Entry 92 - Challenges 1 and 2. Challenge 1 - easy enough. Combining arrays with function and if statements.. no problems really. Challenge 2 - class with strings and characters, plus function...tricky stuff!
Entry 93 - Challenge 3. Lots of classes, functions...complex syntax to have arrays/dicts used with the square brackets. I remember struggling with lots of this! But good practice!
Entry 94 *Brief return to Angela Yu's course - one entry to focus on the use of APIs and CocoaPads - the idea of getting and using code that is already online
After the return to Angela, I felt instead the need to do more challenges and tasks that tested out my understanding of the syntax. It made sense at that point to go to Nick Walter's course, as it had plenty of challenges built in along the way...
3.3 - Nick Walter Course (15.9.2018 to 26.9.2018)
Entry 94 - *Joint with the previous entry of Angela's. Basics of using main types - ints, strings etc.
Entry 95 - print and comments, use of boolean and if statements. Good challenges to use hasSuffix property.
Entry 96 - Switch statements, arrays, dictionaries, loops, including challenge combining that with dicts.
Entry 97 - Functions, optionals and structures/classes. Functions within the struct/class. Optionals with some implicit unwrapping.
Entry 98 - computed properties, lazy stored properties, property observers. Syntax for this is making more and more sense, looking over it.
Entry 99 - inheritance, overriding - including use of final that prevents this, inits, deinits, failable *use of ? and isEmpty - for error throwing,
Entry 100 - Enumerations including those with (default values?). Type explicit for those. Error handling - using error protocol to conform to. Then use of throws within function for error testing. Custom built in errors.
Entry 101 - Extensions - doing so with custom types as well as native types. Challenges tricky but with rewarding!
Entry 102 - Protocols. Key point here is not to put the actual code in but what needs to be returned or the outcome. Delegation - using protocols to do different tasks within classes.
Entries 103 and 104 - EDU courses. Far too technical, poorly explained and escalated in difficulty very suddenly. Not worth it looking at it now!
Entries 105 and 106 - Angela course return (again!) - use of Alamofire, APIs, JSON...all things linked to making a weather reading app. But it didn't work properly - something out of date properly
It was at that point I realised that going through complicated projects was quite unfulfilling, especially when the code had become outdated. Going over syntax challenges from earlier, beginner courses was no point as I had evolved my understanding past that. So what I needed was a genuine Intermediate course, where I could really tighten my skills...
Summary - 27 entries
Breakdown
Treehouse - 11 entries (78 to 88)
Chris Ching - 6 entries (89 to 94)
Angela - 3 entries (1 shared; 94 and 105-106)
Nick Walter - 9 entries (1 shared; 94 to 102)
EDU - 2 entries (103 to 104)
STAGE 4
At this point, I was still confused about several key concepts, so the idea of doing an Xcode hands on project didn't really appeal. I went to Bob Lee as I had enjoyed his down-to-earth, relatable explanations of things before. So I purchased his intermediate course, which was three times the price as the others I had bought on the cheapest deals.
Bob Lee Course (2.10.2018 to 2.12.2018)
*Plus own project - How Many Letters - done towards the end!*
Entry 107 - Optionals including unwrapping. Difference between forced and implicit (using if/let). Optional binding too.
Entry 108 - Optional chaining. Use of guard and defer statements. Multiple values - putting them onto one line rather than nesting them.
Entry 109 - Error Handling - custom built errors, error testing using specific do/catch/try syntax. Putting in if statement in init part of class.
Entry 110 - Type casting - up and down casting. How you can go from native to 'any' type and then back. Using them as part of an array and down casting them to appropriate int or string. Custom types put in an array so that they become the same type as shared parent class.
Entry 111 - generics. How code can be used for any type. So for printing elements in an array - could be used for string or int array. Rather than creating one for each. Use of mutating func - changing the value of one of the properties. <Any> used.
Entry 112 - consolidation of previous 5 entries. Always useful!
Entry 113 - subscripts. Very much like functions. Class vs struct - key point her is even a constant with class can be changed. Mutability. Mutability for structs - can't be done or for any other value types that are constants.
Entry 114 - Sets - used for removing duplicated items; specific code (from NS) can be used e.g. insert, contains, symmetricdifference...Tuples - combining types!
Entry 115 - Extensions. Doing so for native types. Unary/binary/ternary (or tertiary) operators. Use of nil coalescing operator....used to choose between value and optional. Type alias - don't see the point of that but using another keyword for a value.
Entry 116 - consolidation of entire chapter 1 - lots here!
Entry 117 - Convenience init, computed properties - gettable and settable...
Entry 118 - Property observers - use of didSet and willSet. Failable init - used with throws used.
Entry 119 - Consolidation of last couple of lessons. Good stuff!
Entry 120 - Use of override method - what then is kept after inheritance. Two phase Initialization - example with struct for feet/metres (imperial/metric). Basically with structs, two different inits to choose from - DIFFERENT to convenience init in classes!
Entry 121 - Singleton pattern. Never made that clear!
Entry 122 - Consolidation entry of chapter 2 - from convenience init, computed properties, property observers, failable init...all that was generally fine. Also type methods - using keywords such as static so it's only used within the type, not on an instance. Classes also use class and final...Singleton again - something about tracking when it has been used...more for when sharing a project?
*Own Xcode project* - entries interspersed amongst Bob! Asterisked on each side of the name to make that clearly separate.
*Entry 123* - Letters in Words project. Basic setup of main view.
Entry 124 - Intro to closures - first two parts. Complex stuff and I will need to come back to this at some point!
Entry 125 - concept of lazy. Keyword used so that it's only accessed only when needed it. Saving memory. Some practice with 'We Heart Swift'. Use of Stephen De Stefano course - still not clear! Some key differences between functions and closures.
*Entry 126* - Letters in Words. Array of words, repositioning of labels on view. Function to reveal word from array - randomisation etc. Use of alert (taken from Bullseye app) to signal end of game (up to 5 questions). Updating and resetting scores functions. This was a big session!
*Entry 127* - Letters in Words. Use of number pad and text field, including adapting code to press enter! Finding and using a timer - a fruitless, endless search online for getting one of these! One link found to be tried next time...
*Entry 128* - Letters in Words. Timer worked! Lots of code to get the resetting, linking it to the alert. A lot of time needed to sort all of that.
*Entry 129* - Letters in Words. Last part on this! Though I have since tweaked the view one more time! This was changing the positions of the labels and buttons, the font - making it all more user friendly.
Entry 130 - (Bob Lee Course) - capture lists, trailing closures, completion handlers - all very confusing and enough to convince me that I had to stop with Bob here!
4.2 - Sandra Lee Course (2.12.2018 to 21.12.2018)
Entry 131 - Recap of variables and constants, type inference, operators and type conversion. Good for consolidation.
Entry 132 - Collections, functions, with different return types. Again, all consolidation here.
Entry 133 - Parameter labels, challenge of dice rolling (randomisation), use of arc4random updated, for loops, while loops, repeat while loops.
Entry 134 - If/else statements, switch statements, structures and classes and enumerations. Again, more consolidation than new stuff here.
Entry 135 - Object Oriented Programming, objects, classes and class inheritance, pizza restaurant challenge and example.
Entry 136 - Quiz App example including stack views, constraints, outlets and actions, control flow and modelisation. Ultimately disappointing but at least an opportunity to work on an Xcode project. End of Sandra's course for now!
Sandra's Quiz app was so flawed that it means I need to work on my own separately, rather than use the ideas from hers! Also, rather than just going back to Angela's (excellent) quiz - back from entry 56 - I'm going to branch out and try my own ideas for this. Then I will supplement the app with her ideas as they are simply better!
4.3 - Own Xcode Project 2 - Quiz App! (21.12.2018 to 2.1.2019)
Entry 137 - Start of second own project! F1 quiz - main view with constraints sorted, model of question bank, outlets and actions connected.
Entry 138 - F1 Quiz part 2! Big switch to have to simplify to true/false quiz. Four options proved too complicated! Managed to get 10 questions - similar to Angela's Quizzler app (entries 56 to 58!).
Entry 139 - F1 Quiz part 3! Various functions and logic needed for this. Had lots of issues with the wrong question/answer combo coming up. Managed to solve in the end. App pretty much complete!
Entry 140 - F1 Quiz part 4! Updated a few things - arrays for pos/neg messages and the final messages being more specific (f1 related). Got stuck with trying to get different classes of questions accessed. I'm sure there's a clever code for that, but I'm not there yet!
So after failing to 'complete' my own App, I figured I need to complete a course in its entirety. The advantage of this is that I can actually get/seek help wherever necessary and learn through more projects. In this stage, Bob Lee's course was ultimately disappointing, Sandra's was so illogical with her Quiz app that it made me move away from both courses. It makes total sense at this point to go to Angela's updated course, which will be a chance to refresh anything with the latest Xcode but also build more apps, which will then give more ideas for my own projects. I can also come back to the F1Quiz app once I have the technical knowledge for the difficulty levels. So here we are, back to Angela but this time to see the WHOLE course through!
Summary - 34 entries
Breakdown
Bob Lee- 19 entries (107 to 122 (one shared); 124-5; 130 )
*Own Project - How Many Letters* - 6 entries (122-3 (one shared); 126-9)
Sandra Lee - 6 entries (131 to 136)
*Own Project - F1 Quiz* - 4 entries (137 to 140)
STAGE 5
5.1 - Angela Yu Course - updated with XCode 12! - (2.1.2019 to 21.2.2019)
Entry 141 - Introduction stuff. Just getting this out of the way before the actual coding etc.! Freebies - always welcome.
Entry 142 - lots of useful design elements mentioned here. Websites included for app icon design and for generating relevant picture files and app icons. Picked up a lot more this time than last time!
*Called part 1 again by mistake!
Entry 143 - Sideloading (getting app onto phone), App Dev account, challenges (should I look at these at some point...), GitHub. More general stuff for this one. Start of Dicee App project.
Entry 144 - Dicee App continued. Lots about assets and getting the right picture files and app icons files. *Really useful stuff for getting all those bits for an app - using the websites as well as designing bits for free. Randomisation too - easier way without using arc4random.
Entry 145 - Arrays. Using an array of images in this case - neat idea! DRY principle for function use. Separate function - then used within the button pressed. Motion detection (not a big deal for me at the moment at least).
Entry 146 - Magic 8 Ball Challenge. Did well to get this set up on my own - didn't use Angela's step-by-step as was confident enough without this. Use of functions again logically with DRY, use of commenting out in one go - command function + \.
Entry 147 - Conditionals - used within love calculator and BMI challenge. And bottle of beer (conceptually tough). All good applications of if/else and for...in.
Entry 148 - Fibonacci sequence - always outfoxes me! But gave it a good go. Use of tags - REALLY useful concept. Error catching.
Entry 149 - Property list (p list) - status bar linked to this, OOP (use of classes), MVC; skim through of quiz app as done my own recently and used some ideas here.
Entry 150 - Destini app. Aced the logic with the if/else (MUCH better than 6 months ago!), use of functions again with DRY, auto layout and stack views - good challenges.
Entry 151 - Intermediate Swift concepts - classes including inheritance, properties, init, use of methods, enums, application of a lot of this with optionals and optional binding. Not project related but useful stuff.
Entry 152 - Clima App! It's about at this point that the 'new stuff' came in. So 11 entries of consolidation from before basically. Yes this was fiendishly tricky and ultimately unsuccessful for some reason. But I learned a lot of new concepts here about APIs and the use of Cocoa Pads. Much higher-level stuff.
Entry 153 - So about some delegation - still part of the Clima app. JSON brought into this - the java script, which is needed to get the info from the actual website.
Entry 154 - Segues - changing between the different screens with the actual CODE! I've tried this before without checking the code properly. Short entry this.
Entry 155 - Combination of delegates, protocols, segues...at this point I was pretty flummoxed but kept persevering with the project.
Entry 156 - Going over delegates and protocols again. Let's see....Ok so protocol is a bit like the offer for a job contract. Doesn't have the finer details just the position and income! Taking up the contract...the delegate being used here as a method...yep confusing as hell!
Entry 157 - A bit of a sidenote about command line terminal - what you can use it for, jumping around files, creating them...interesting but I don't see the point of actually using this regularly to be honest.
Entry 158 - Somewhere along the way, the Clima App just didn't work and I sucked it up - checked everything several times! So the next mini-challenge was a Bitcoin (relevant!) tracker, which I nailed! So that was cool. Again, use of podfile via the terminal program.
5.2 - Own Xcode Project 3 - Times Tables App! (25/2/2019 to 23/3/2019)
Going over Angela's course was rewarding, especially as everything made even more sense the second time around. However, from 152 - the Clima App and APIs - it cranked it up a massive conceptual leap. I struggled but just about coped. At this point, I really wanted to get into another own project - something simple but achievable. A times table app - perfect for combining various skills!
Entry 159 - This was a very, very brief entry (12 minutes!) just to lay out the MVC requirements.
Entry 160 - I then spent an hour getting the views and constraints set up properly. Constraints are a real bugbear of mine and I need to go back over the most logical, systematic way of putting these in.
Entry 161 - so the actual coding - the model! I started by trying to create a custom class, a bit like the quiz app. This did not work! So I left it there, with some ideas but no actual model for the times table generating.
Entry 162 - Simplified view - just a white background. Buttons and labels all connected. Timer all in, alerts, random number generation....wow a lot was achieved here! This was a 2+ hour entry, so it's where the project basically came together.
Entry 163 - Bugs fixed including why the pop up was coming up too late. Keyboard code not even needed apparently! Code cleaned up and working well! App complete!
5.3 - Angela Yu Course - updated with XCode 12, continued! - (23/3/2019 to 10/4/2019)
Entry 164 - Now into a new project - Flash chat! Firebase account - created for the first time and this did take a while to work! It did in the end. Must remember to use this again for something... Online database - a way of tracking and monitoring the usage of the app too.
Entry 165 - Registering users. All part of the Flash chat project and various issues with the code. I persevered though!
Entry 166 - Closures (I still find these so mind boggling), completion handlers (messages coming when tasks completed) and navigation controllers - embedding this next to the view controller. Not sure about much of this.
Entry 167 - Still part of Flash chat - logging in, table views....a lot to get sorted but eventually it worked!
Entry 168 - UI animations, the user interface/experience with sending messages. I did a random colour array to change the message colour for each user, but didn't quite make sense! At least it was all working.
So, I felt like the conceptual stuff was going way above my head. I had to get to grips with closures and other aspects before plowing straight on into another project! I also had been slacking in terms of regular entries so felt the need to focus more on syntax than projects.
5.4 - Consolidation - (4/5/2019 to 5/5/2019)
Entry 169 - Consolidation entry for closures. For some reason I went back to Bob Lee! No offence Bob, but his stuff is just so vague and hard to follow. I tried some other bits but still couldn't make much more sense.
Entry 170 - Final bit of attempted consolidation. Not much joy again!
5.5 - Nick Walter Course Swift 5 - (3/6/2019 to 10/6/2019)
Entry 171 - A big gap between entries and not feeling prepared to take on Angela's higher order stuff, I thought it good to go for a course that specialised in Swift 5! For this first part, it was all recap. I did two hours worth and went through all the basics and moved on to more complex stuff with conditionals.
Entry 172 - This was a 'bonus' entry, just to do a summary of what I had achieved over a year. I had different dates as headings and checkpoints.
Entry 173 - Back to Nick Walter's course. Tuples, sets, functions, optionals, classes, enums... All good. The challenge was again very manageable so mostly recap here.
Entry 174 - Well this had a much tougher challenge! Really outfoxed me - basically had to do a word counter for a text, which turned out being harder as doing a .count on strings does the characters!
Entry 175 - Consolidation entry - went over the challenge from 174 again, which was much needed as I made better sense of it and did not rush. Still found it hard and needed help but ended up picking up some useful stuff here.
Entry 176 - Various bits and pieces about what is new in Swift 5. Useful to get a summary.
Entry 177 - A mixture of recap and about making a package/using other people's code.
Entry 178 - So part of the project, this was basic stuff about having a button run a function to change the background colour to red.
Entry 179 - If statement used in conjunction with randomisation to vary background colour (at random!). Actually, it was just a set order - I came up with the randomised element, put that as a comment on his course, which he was impressed by!
So a productive week with pretty much daily entries - sometimes more than one per day! That is the way to go - the learning moves on so much more as there isn't that need to make sense of it all again each time. I thought to crack on with another course on Udemy, rather than Angela's. I found another that promised a Swift 5 compatibility.
5.6 Stephen DeStefano Course Swift 5 - (11/6/2019 to 25/7/2019)
Entry 180 - Like with Nick's course, more recap of basics, which is healthy to do to be fair. Quizzes after every lecture or two, which was a good way to check understanding.
Entry 181 - Quick session focused on tuples.
Entry 182 - Functions - quickly becoming technical with inout and other keywords.
Entry 183 - Properties. First session in a little while and first being back in UK for summer.
Entry 184 - Lots about value vs reference and initialisation. Again, very technical stuff - not as accessible as Nick's and nowhere near Angela!
Entry 185 - Optionals and control flow. Fairly brief session but covered a lot.
Entry 186 - If/else and switch statements. Guard statements. Then loads on strings which I skimmed through.
Entry 187 - Collections, enums and error handling. All pretty involved stuff.
Entry 188 - What is new in Swift 4.1 and 4.2. Bit of a con, considering that the course is supposedly updated to Swift 5! Good though to find out about more recent features.
Entry 189 - So breaking point! I honestly thought the practical would be fun and useful. It wasn't! From strangely different options on Xcode to ridiculous amounts of code to copy and poor explanations, I am totally put off Stephen!
So that covers the 'intermediate and project' learning phase, which has been a long and, mostly, fruitless stage really. I may be being harsh on myself, but I feel little has been achieved in nearly 7 months of learning. So this is why the next move makes sense....summary to do first!
Summary - 49 entries
Breakdown
Angela Yu- 23 entries (141 to 158; 164 to 168)
*Own Project - Times Tables* - 5 entries (159 to 163)
*Consolidation*- 2 entries (169 to 170)
Nick Walter - 9 entries (171 to 179)
Stephen DeStefano - 10 entries (180 to 189)
So there we have it. Looking at it, Stage 5 was where APIs really kicked in with Angela's course, I had another successful own project - with little to go on, and I consolidated lots of intermediate features. Stage 6 is all about it having it on one format. One method, one site. Treehouse! Yes, back to where it began! Last time I was here, it was August - end of summer holidays so nearly a year ago. It would be naive to think it will suddenly be great, as I was so exasperated with it before. But I have a new mission now, to complete the Intermediate Swift Track! Yes, that is what Stage 6 is all about!
STAGE 6
6.1 Treehouse Course - Intermediate Track (29/7/2019 to 30/8/2019)
Entry 190 - All about API guidelines - certain rules to use to ensure consistency and transparency. Certain rules for protocol naming conventions e.g. -ible, -able etc. For functions, to use as a verb and clear argument labels that are logical. Grammatically sound, which I love to hear!
Entry 191 - More on API guidelines. Certain rules like use of prepositions - to, at etc. Used after base (function) name if multiple argument labels. OK, I've just got the mutated/non-mutated bit. Mutated - more present tense whereas non-mutated past e.g. sort vs sorted.
Entry 192 - First part of generics! So starts off with using the <T> for a function that multiple types could use. E.g. swapping values for Ints/Strings/Doubles etc. Use of 'Any' type. Other syntactical things like use of & (ampersand). From further reading, a key point is that other types e.g. optionals, arrays, dictionaries are all generic types too - e.g. an array of ints all have to be ints.
Entry 193 - More on generics. Long-winded code to show how map features can be created from scratch. Use of equatable protocol - so that you can compare values for a new, custom type.
Entry 194 - Next generics. More of creating functions from scratch with generic type e.g. largest, which must follow comparable protocol. Passing a function as a parameter...this will link to the future closures stuff! Now info on generic types - e..g Array is a type and an array can be created with different syntax using that keyword.
Entry 195 - Linked lists! These were so confusing and I still don't see the point. Stuff about single/double linked lists...nodes being each item...all very confusing. SO you can create your own linked list...but so much code to add to this. Mental stuff here.
Entry 196 - Associated types (still on generics here!)...This was also confusing. A bit about type alias, which I TOTALLY get now! That is useful. The key thing here is using associated type is useful because you still can inherit the behaviour of a specific type, rather than using 'any', which has no specifics for type behaviour.
Entry 197 - Lots more about protocols and some extending the generic type...but all seems pretty vague looking at it again.
Entry 198 - Consolidation entry on generics.
Entry 199 - First part of closures! More about functions for this first part - how you can have a value declared as a function then use it etc. Then putting in functions as parameters...More use of type alias, which makes more sense. Return type as a function...lots of stuff.
Entry 200 - Next closures! Showing the increasing shorthand of writing a closure to the dollar signs!
Entry 201 - Use of 'map'! OK, so that's a closure that can be used on arrays. Use of trailing closures - when the closure statement is at the end of the line/last thing in the line of code.
Entry 202 - Other built-in features like flat map, filter, reduce...various aspects here.
Entry 203 - Extensions on ints....use of throw and throws which was confusing!! Memory consideration - use of the @escaping... unowned vs weak keywords. That was it on closures.
Entry 204 - First of delegation! Design pattern with the really cool example of race horses! It was a shame that I couldn't develop this as much as I would've liked.
Entry 205 - next delegation. Info on why these are good for the long term strangely lacking...not actually clear why we're bothering with delegation at all! A strange example in lots of ways! I did however have fun with changing the code to make it F1-related.
Entry 206 - CL location manager and text field delegation - the concept of this was clearer. If you wanted to advertise a job out, you would put in the specifications. A delegate is technically a protocol that fulfils those requirements. Last one on delegation by the way!
Entry 207 - First part of the interactive story - this was all dandy to begin with! Use of navigation controller made sense - having it embedded in. I like the idea of the view controllers all coming off the NC. The NC becomes the Root controller. The segue show - has automatic features like a back button. All fine.
Entry 208 - Second part of the story app project. A cool intro with having a pipe dream plan of how I can progress with my Swift journey! Then a LOT of code for the classes and various bits for having the story. It was a lot but I did like the structure to it all. Better than Angela's having it as separate values!
Entry 209 - Third part of interactive story...and the last it turned out! I found the programmatic part so confusing and difficult to make sense of. It seemed deliberately verbose and I realised I didn't have the time nor patience to see it through. End of Treehouse, and this sub-stage!
6.2 - Lynda.com free trial (31/8/2019 to 21/9/2019)
Entry 210 - Unofficial first entry! This started as a line drawn under Treehouse, with no aim to return! I can't return there - it's too out of date and it won't help long term. Nice to visit it for a month though!
Entry 211 - So this was a new exciting platform to explore that only ended up with one really decent course worth completing, which was a shame. Anyway, real basics covered here - variables, constants etc.
Entry 212 - Continuing on with collections, tuples etc. Some good detail with nested dictionaries.
Entry 213 - Loops, optional binding and switch statements.
Entry 214 - Overloading functions (functions with the same name but with unique signatures), closures and type alias
Entry 215 - Type alias - needed to go over this as didn't get it right first time.
Entry 216 - Custom types - classes, structs, use of static, private, subclassing - quite a lot of complex stuff here
Entry 217 - Enumerations, including raw values, protocols, extensions and error handling
Entry 218 - Final challenge that had various bits to it. Did a final wrap up of where to go next. Went for RW.com, which ends this brief section!
Entry 219 - One final part - a useful going over of the whole yet, picking out the key aspects. This is worth revisiting again in fact as there are various elements to look at here.
6.3 - Raywenderlich.com: Swift UI intro (30/9/2019 to 25/12/2019)
It took a bit of time to get full functionality of latest Xcode but I did and it was onto rw.com! Having assessed all of the options, it was between this and the Reinder guy. Initially, I went for a monthly payment but once the annual subscription came down significantly in cost, I went for that.
The first few of these were all the Swift basics recap, using most up to date language features.
Entry 220 - Setting up and overview for what I will be learning.
Entry 221 - All basics of Swift.
Entry 222 - Collections and loops - including nested ones.
Entry 223 - More collections: dictionaries and sets.
Entry 224 - Functions and use of ternary operator in these. Also type alias for shorthand use.
Entry 225 - Structures and classes
Then it was project time - building the bullseye app, one which I did before with UIKit.
Entry 226 - Objects, data and methods - all core to object-oriented programming. Changes to other bits - buttons not needing 'connecting' etc. 'State' - a bit like an on/off switch on a car dashboard. So an intro to the new features of SwiftUI.
Entry 227 - Swift UI Views - very easy to put in labels and sliders etc. The use of stacks and spacers too.
Entry 228 - Binding the state var with an object - in this case a slider. Basics mentioned. Methods - main difference I've noticed with previous Xcode is the function returning something. A bit about type inference and var scope.
Entry 229 - More on basics and function to update score.
Entry 230 - Images - getting the three different x1, x2 and x3 versions and putting into assets. View modifiers - code to change appearance of text/images etc. Styling buttons and sliders - various options.
That was the end of a successful start to SwiftUI. I continued with the next logical project - a to-do app from Jessy Catterwaul.
Entry 231 - Started fine with what a model is, then went into very technical stuff...I stuck with it but am still not sure what dependency injection is. Lots of tricky bits just in the first few lessons.
Entry 232 - Modal views... all very hard again. Also, whatever I did, the project was riddled with errors. So abandon ship on this one!
So the above was way too hard! A good time now to try making a project - updating one I'd done before (HowManyLetters?) to SwiftUI!
Entry 233 - A great effort with getting all of the texts, stacks etc. Discovery of actually setting the spacing (but that may not translate well to other devices)
Entry 234 - The 'model' part made - nice and easy. And actually I did it as a struct, then created an instance in the main Content View. That was something I never managed to do before - keeping the array of words separate to the main body of code! Gave up as I tried all I could but to no avail to get editing of text box. But good practice!
It made sense now to focus on learning more about SwiftUI - so many differences after all! Laurie's course below was technical but useful.
Entry 235 - Biggest difference - no view controller! View is updated automatically...live update...a bit about the stacks. Lots of cool things basically in SwiftUI.
Entry 236 - Features with images - resizing, aspect, clipping, styles, then some about buttons.
Entry 237 - Sliders and steppers; date pickers and toggles...lots of cool, easy things to create here. A lot easier than all of the VC stuff from before.
Entry 238 - Stacks - about the use of ZStack in particular as this hadn't been gone into as much before.
Entry 239 - ForEach - an alternative to for...in... And some on lists and forms - other keywords used to create objects/layouts on SwiftUI.
Entries 240 and 241 - *bonus entries to consolidate everything from previous 5 lessons. Good practice, using F1 drivers as the content to play around with.
Entry 242 - Use of scroll views which included use of Geometry Reader and proxy. Technical but useful!
Entry 243 - Navigation view. Use of new Swift files to put in certain bits of code - tidying up the main file. Tab bar as well but I don't remember much about that.
Entries 244 - 246 - *bonus entries! A lot of great putting into practice - my F1 driver scroll through app. I used the previous two entries and the images/ideas from the other bonus project to make something pretty cool.
So a lot learned from Laurie's course - plenty of info and practice with the different properties and features of SwiftUI. At this point, it was the right time to go into some technical stuff.
6.4 - Raywenderlich.com: Technical Code and Layout (8/1/2020 to 13/3/2020)
The first course during this time (Catie Catterwaul) was all about functions and types. More complex stuff, including closures.
Entry 247 - Intro to functions - mostly recap including overloading and default values.
Entry 248 - Advanced parameters - variadic, in/out including the ampersand (&), that functions are a compound type - they have their own SIGNATURE. Use of type alias instead of using that complicated signature each time; closures being similar but key differences.
Entry 249 - Closure syntax - tricky! But the usual stuff of going from more verbose to the use of $0 and $1. ForEach (new in Swift 5) and use of maps as closures for arrays.
Entry 250 - More on maps - compact and flat maps.
Entry 251 - Filter, reduce and sort - all specific uses of map.
Entry 252 - Enums and the use of allCases if made of type of string and case iterable. Also raw values mentioned.
Entry 253 - Use of switch statements. Switch within function. Use of value binding - use of let and where for storing a temporary value in a switch statement.
Entry 254 - Properties and methods. Stored props, computed props and lazy props.
Entry 255 - Use of mutating func (when the parameter value will change). Other stuff with caseIterable again too.
Entry 256 - Class inheritance and a bit about polymorphism (up/down casting)
Entry 257 - Initialisation - designated, convenience...required...a bit on protocols too.
Entry 258 - Extensions - a neat tidy way of adding to a type. Protocols - requirements laid out that have to be satisfied. Value vs reference type - Objects are technically classes and values are structs. Best for each class to have a single concern.
Entry 259 - Consolidation on the above!
So lots of useful stuff in this course. Got to grips with the more technical aspects of functions and types - and should refer to this stuff whenever needed. Then it was Catie with Jessy for auto layout...
Entry 260 - Stack alignment - use of the V and H stacks to put together different bits of text and pictures.
Entry 261 - Alignment guide - having the line go through the object, or through the top or low points; custom alignment - coding this for something more specific.
Entry 262 - ZStacks - think of it as the background. Padding - made more sense (barrier around the object). Geometry reader - a view; proxy provides access to it as it's an instance of the view.
Entry 263 - *So next three lessons are back to UIKit. Autoresizing, stack views - grouping views together.
Entry 264 - Intrinsic content size - the size that will fit into the view. Content hugging and compression resistance - vertical and horizontal settings for each, so four options to set. When priority of CH and CR is the same - ambiguity! Nesting stack views.
Entry 265 - Constraints - adding in new ones in one go; minimum font scale; using highest level stack to set the constraints - rather than each item (that's where I've gone wrong before!)
Entry 266 - Consolidation of all of the above.
So that was layout - both in SwiftUI and UIKit. So plenty of good stuff! From here, I had realised that there was so much Beginner content unexplored, things I needed to look at before considering Intermediate. And enough on this stage of learning.
Summary - 77 entries
Breakdown
Treehouse - 20 entries (190 to 209)
Lynda - 11 entries (210 to 220)
Raywenderlich.com - 45 entries (221 to 266 bar two) including consolidations!
*Own Project - HowManyLetters* - 2 entries (233 to 234)
STAGE 7
Total sense to see this as a new stage! I've learned a lot about the technical aspects of Swifts, have worked on various projects - to differing degrees of success - and got a grasp of the new SwiftUI.
The key in Stage 7 is to be confident with ALL of the beginner-level aspects of Swift, ready to move on to what is considered 'Intermediate'. It's taking a while to break through but I know that I'm not ready to be considered at that level yet. I'm going to complete anything else, relevant and recent on rw.com that is beginner, then proceed on to the next stage. Stage 6 took AGES and was meandering - no real focus.
So in Stage 7 I want to pick up specific new skills from the articles (stage 7.1), then in 7.2 complete ANY other courses that I haven't and seem relevant. 7.3 will then be a big old consolidation - going through everything on Swift that I can remember, giving myself challenges and mini projects. I want to be ready for Stage 8 at the start of May!
7.1 RayWenderlich.com: articles (14/3/2020 to present)
Entry 267 - Storyboard intro article - all setting up using Storyboards and use of VC, NC, segues...all interesting to practice.
Entry 268 - The second part of the above. Connecting it all together.
Entry 269 - More on segues and having a whole app connected with code. Lots of technical code starting to be put in.
Entry 270 - Putting it all together including purpose of different parts like the text field; lots of settings and code needed for this.
Entry 271 - Consolidation of previous two entries - what the code actually means!
Entry 272 - Swift UI animation part 1 - modifiers, transitions, state changes.
Entry 273 - Combining transitions together; asynchronous animations - second and final part of this article
Entry 274 - Navigation tutorial. Using UUID to identify specific objects; navigating to a detail view all with Swift UI
Entry 275 - *Final entry to wrap things up after hiatus*
So, the final 'proper' entry was 274. This was back on 20th March, so the entire blog lasted for nearly two years! I could continue and add to this one, but after several months of being unable code, it feels more appropriate to start a new blog - explained in entry 275. So signing off here but the new blog will start now!
Comments
Post a Comment