learn-co-curriculum / mobile-development-curriculum

This repository is for holding notes about the Mobile-Development-with-iOS curriculum track. It's primary purpose is to collate notes about problems with content (readings and instructions), though technical problems with labs may be appropriate if they are internal problems with the functioning of the lab itself or with student experience (e.g. please report needed CocoaPod updates such as KIF deprecations).

Dangling repo:

https://github.com/learn-co-curriculum/reading-ios-selectors
https://github.com/learn-co-curriculum/reading-ios-unitTesting
https://github.com/learn-co-curriculum/ios-collections-vol-2

View This repository is for holding notes about the Mobile-Development-with-iOS curriculum track. It's primary purpose is to collate notes about problems with content (readings and instructions), though technical problems with labs may be appropriate if they are internal problems with the functioning of the lab itself or with student experience (e.g. please report needed CocoaPod updates such as KIF deprecations). on Learn.co and start learning to code for free.

mobile-development-curriculum's Issues

II.i.1 Reading-iOS-Intro-To-Xcode recreate & add screenshots (medium)

The current screenshots are currently sufficient for a high-level overview of Xcode, but the reading would be served well to have them recreated with better graphic design and labelling, perhaps utilizing some color-coded shading to help distinguish the main areas.

A thorough detailing of the functionality within each window would require additional zoomed-in screenshots of the available tools.

III.ii.06 - inheritance vs composition

Composition may be too advanced of a concept to explain beyond a footnote in the Categories reading that it's one way to extend composition.

II.i.10 Objc-Deli

Introduces Xcode workspaces for the first time, and tests. Neither of which have been explained yet.

Needs goals.

Needs context.

Should improve clarity of instructions.

Have we covered how to compose a method yet? There is a section on using methods, but not composing them.

Lab: should we provide the first method name in the lab for the sake of clarity?

Instructions point to reading tests. BAD!

II.iii.04 - reading-ios-filtering-basic

Introduce the problem more clearly.

Fix bad practice in example "CharacterArray".

Don't use string interpolation in the first example. Later, show how it can be used programmatically.

Move accessing keys and properties (self.name) to the actual explanation of the syntax, not the introductory example.

The examples are very convoluted. (Flargaret?)

introduce diacritical marks, why [d] is important.

Maybe explain some more about NSPredicate syntax and its valid comparators? The apple documentation on it kinda sucks.

Don't mention Core Data in the conclusion.

II.iii.000 - whileyCoyote rewrite for loops practice

II.i.09 Reading-iOS-NSArray

Needs some love.

Formatting/style consistency.

Creating arrays sections needs explanations: why is the array-literal preferable? why do we need to be able to recognize the archaic forms? Why can't an array contain 'nil'?

Include [NSArray count] explanation.

Explain that arrays can contain other arrays (array-types like dictionaries and stacks). The term for this is "nested", but "nested arrays" functionally form a matrix.

There is a link to the NSSortDescriptor lesson. Should this be removed or revised as advanced reading for future use?

Methods listed should be explained better, and a link to the NSArray Apple Doc should be included.

III.i.12 - locationTrivia-objects

Reference existing issues on the repo : tests, naming practice, syntax errors

learn-co-curriculum/locationTrivia-objects#4

Update instructions for parallel style and better clarity

Update lab to use CGFloat properties instead of NSNumber

Update CocoaPods, remove OCMockito

III.i.06 reading-ios-creating-custom-class

New reading about how to create a new class file with import dependencies and public-only properties and methods.

III.ii.04 - reading-objc-casting

This subject can get into the weeds really quickly. It's mostly important for pulling objects out of collections and in subclassing UITableViewCells.

Worth discussing type id as "any class" or "unspecified class"

Is worth explaining the "magic" that at runtime all objects are type id, that classes are an abstraction to help the compiler catch when references will crash into each other? Could be an advanced note? Don't wanna blow minds too early.

II.iii.015 basic NSDictionary lab

write a lab that's a simpler introduction to practicing with NSDictionary

II.i.04 Reading-iOS-Things-NSString-Can-Do

Add context: framework methods built by Apple. Mention documentation (how to look this stuff up)?

Explain code samples (walk through what's going on)

Case conversions & data type conversions-- should we introduce ASCII / binary here? Touch on why these conversions work?

II.ii.3 - Reading iOS Debugging

Update with objectives and for consistent style.

Correct mythos of Grace Hopper's moth in the machine.

Exception breakpoints can be added by clicking on the code editor's gutter.

Remove note to Joe.

II.i.06 Reading-iOS-Using-Methods

This needs a lot of work.

We should probably avoid calling objects "things." Primitives are "things" too, this is very ambiguous.

We should avoid using code snippets with dogs & cats as the example to not accidentally infringe on Matt Neuberg's examples. FISPerson or FISStudent may be a better choice.

Need to explain message syntax here, this is like defining grammar: where do the brackets go, nesting, etc.

Should also explain good practice in this, perhaps even archaic examples of older styles.

III.i.02 reading-ios-class-vs-instance

new reading discussing class objects vs instance objects

III.ii.09 lab-ios-objc-blackjack

Improve clarity of instructions, edit for parallel style.

Point out that setHand: should recalculate the handscore.

Warn that _ivar should not be used outside initializers and setters/getters.

II.i.08 WWDC-Badges

Needs goals.

Needs context.

Curriculum has not covered for-in loops / fast enumeration yet. This instruction should be changed to for-loop unless fast enumeration is added to the basic curriculum. (This is a good candidate for an advanced option--solve using a for-in loop instead of a for-loop).

The lab is written so that solution code gets written in the main.m @autoreleasepool function, which is bad practice that should not be introduced. This lab should be rewritten so students are directed to writing solution code in an FISAppDelegate file. It is also an OS X application and not an iOS application which is now inconsistent with the new "My First NSLog" lab which precedes it.

III.ii.05 - objc-PetCast

remove unnecessary CocoaPods

let's rename assaultTheMailman to chaseTheMailman, or better, just convert it to a positive action like greetOwnerWithSlobberyKisses or something.

Could add some more material, like a subclass of FISDog to engage in more practice.

ios > objective c basics > deli counter

User: Kevin T

Batch: 000

Current Lesson: Deli Counter

Location: https://learn.co/

Bug Description: I think the lessons are out of order? I was asked to create an NSArray in WWDC Badges lab before the lesson on NSArrays and the Deli Counter requires creating methods before the lesson on Creating Methods. I'm able to find other sources for the information that I need to write the code, but I'm not sure why I would want to do that if the material is available on the platform. Thanks!

III.ii.02 oo-vehicle

Update for objectives and parallel style.

Let's not explain the instructions twice: incorporate "recap" section into the instructions.

They know how to create an array by now.

There might be a little too much hand-holding with all these hints at the end.

Check NSInteger / NSNumber in tests:
learn-co-curriculum/OO-Vehicle#7

II.iii.00 - reading-ios-fast-enumeration

Add a new reading covering for-in loops, possibly the other loop types as well.

III.i. DEPRECATE oo-sentence

I'm probably just going to have to solve this lab to figure out what i don't like about it.

III.i.03 objc-classy-methods code-along

Create a new lab for class vs instance? Maybe a code-along about previously used class or instance methods?

III.i.01 reading-ios-intro-to-objects

This intro to OOP is ... far too rudimentary. And the examples aren't parallel.

Maybe discuss language hierarchy?
Discuss Smalltalk in more detail?
Introduce the idea of abstraction, necessary for human thought, but which doesn't actually translate to the code.

Hey! Let's avoid any similitude to the examples from Learning iOS Development! (Don't use cars).

Also, let's avoid subtly insulting groups of people in the example using humans and zombies!

Hey! Let's avoid ridiculously verbose method names in the examples!

What is the linter?

Relate class objects : instance objects :: printing die : printed paper. Much better metaphor, or blueprint and house. If the class object is an object, what's the value in creating an instance? Set up the problem.

Let's wait to discuss custom initializers until the next unit which already includes it.

The reading doesn't really follow its title-topic. Should this stick to a discussion of OOP?

II.i.03 Reading-iOS-Variables-and-Data-Types

Explain the string literal.

Should format specifiers belongs in the NSString reading? This an intro to variables, may be too specific.

explain a pointer better? section on " * " is confusing

III.i.11 - object-oriented-people

USE CLASS PREFIXES!

Exposition about properties in the lab readme. This can be review, but it should not be new content.

Let's not use a binary gender system for humans.

friend --> aFriend (reserved word collision)

removeFriend: should be a void type

"Playing with your methods in the AppDelegate
"Feel free to play with your new class outside of the tests in the AppDelegate. Here is a reminder how.

• this seriously misled a student away from the tests

II.i.11 iOS-Variable-Scope

Should split into a reading and a lab.

Advanced reading: Link to some blog post explaining NSError ** and BOOL *

II.i.12 Reading-iOS-CreatingMethods

Anatomy of a method should come earlier. This place in the curriculum could be more a thorough look at methods.

Distinguishing class vs. instance method type long before discussing inheritance in the curriculum.

Have we explained what the compiler is? Should this be part of the Xcode orientation?

Add a note about return type "id"?

Add a section about helper methods?

Has the single responsibility principle been introduced before?

ios prework > testing and debugging > intro to unit testing

User: Amitai Blickstein

Batch: ios-0615

Current Lesson: Intro To Unit Testing

Location: https://learn.co/tracks/ios-pre-work/objective-c-basics/testing-and-debugging/intro-to-unit-testing

Bug Description: Local build passes tests, and is detected, but fails remote build

II.ii.4 - objc-cartoon-collections

Update with objectives and for consistent style.

Generally just needs to be less convoluted. The theming is great but it doesn't really make sense. I remember struggling with understanding the expectations of this lab.

II.i.05 Reading-iOS-NSNumber-v-NSInteger

Lacks a thorough discussion of NSNumber. Add clarity about this relationship.

Mention float, double, CGFloat

Mention NSValue.

Find a blog post to link to for advanced reading about ivars, NSInteger, unsigned, float.

Tim's notes on primitives
https://www.evernote.com/shard/s149/sh/920a0180-bfa6-4097-9f4b-4e439b65577f/2a85e41fd8c5ab22

II.i.13 WWDC-Badges-Methods

*xcworkspace before explaining it

should we use <#name#> as placeholders instead of underscores?

Be a little more clear in the instructions. Don't direct students to reference the tests! Not yet!
"return an NSArray of NSStrings which are the text for each speaker's badge"
"return an NSArray of NSStrings which is the greeting and room assignment for each speaker"

III.ii.01 reading-ios-inheritance

Reference current issues:

learn-co-curriculum/reading-ios-inheritance#6

Should avoid dogs & barking. Just go right into animal/mammal/raccoon kind of stuff.

II.iii.05 - filtering-and-sorting-practice

Objectives, premise, instructions. README!!!!!

Why is there self.window stuff in didFinishLaunchingWithOptions: ?

Replace this story with the first paragraph of Moby Dick and rewrite the test, if only so the result object can be called "mobyDict". Live a little, eh?

Should KeshaMaker replace S instead of the third letter?

addS: --> pluralize ?

Just in general needs to be reworked to make more sense overall, and fix grammar throughout.

II.iii.07 - lab-locationTrivia-dictionaries

self.window again?

fix some bad practice in the spec file

rewrite the premise.

give better direction for writing out the methods, and naming them (don't rely on reading the tests for this).

Hint: look up documentation in the documentation! not on google!

ios prework > testing and debugging > intro to unit testing

User: Amitai Blickstein

Batch: ios-0615

Current Lesson: Intro To Unit Testing

Location: https://learn.co/tracks/ios-pre-work/objective-c-basics/testing-and-debugging/intro-to-unit-testing

Bug Description: Local build success was not detected.

III.i. DEPRECATE word-play

Update CocoaPods, only Specta/Expecta needed

Expecta not imported into Spec file

Advanced section introduces NSError. Is this too early? Nice link to the NSHipster blog post.

Add objectives and update for consistent style.

III.i.04 reading-ios-properties

Update the problem premise to reference the previous reading on scope. Can we access the same instance variable across methods without submitting it as an argument? --> properties!

Begin with the newest @property syntax and then unpack into the ivar definition, setter, and getter.

Explain the _ivar syntax: ONLY use this in initializers and overwriting setters and getters. Otherwise use self.ivar

Do NOT use not notation in a setter (this is already noted): this creates an infinite loop.

Avoid discussion of private properties until view controllers? We haven't introduced that the implementation file can contain a separate @interface section for private properties and methods.

III.i.07 iOShopping-cart

A psuedo code-along perhaps? Tests would be helpful.

Checking knowledge of creating a new custom class. Perhaps object-oriented-people could go here?

III.ii.03 oop-cards-model

check pull request by spacedrabbit
learn-co-curriculum/OOP-Cards-Model#8

incorporate issue: change NSNumber values to primitives
learn-co-curriculum/OOP-Cards-Model#12

Don't make students guess about which properties are expected where. This is also an incomplete list. Let's not be lazy!

Tests should have accurate descriptions

update CocoaPods, remove unnecessary ones

III.ii.08 lab-ios-category-math

Update CocoaPods, remove unnecessary pods

Add objectives and update for consistent style.

II.i.02 iOS-Your-First-NSLog (improve readme)

Needs goals.

Needs context. This could include an explanation of a method (NSLog) currently in "extra info" below instructions--doesn't seem like this should be a footnote.

Walk through is good.

Lab is good.

Explain the iOS simulator that will start up at runtime.

II.i.14-15 Reading-Tests, Writing Tests

The writing walk-through should be moved to somewhere later in the curriculum, but most of the information about how Specta/Expecta are structured should be re-oriented to describe how to read a test, which is what's relevant for these early topics. We could add an early lab about manipulating a test line, perhaps a "debugging a test lab," but I kinda think that might not fit into the prework.

III.i.05 objc-holiday-properties

New lab about declaring a property and accessing it with the self. syntax.

II.i.1 Reading-iOS-Intro-To-Xcode add prose (easy)

The screenshots would do well to have companion text explaining the different areas of functionality within the Xcode IDE. This information should stay general at first and later transition into a high-level overview of the different windows, which can then later be dissecting into greater detail. Revamping the screenshots themselves may or may not be necessary for this level.

II.i.07 Reading-iOS-Looping-And-Conditionals

Proofread for consistent formatting. Define symbols names throughout.

Conditionals explanation is very programmery in its paragraph syntax. Improve for clarity.

Mention for-in loops (fast enumeration). Is there value in explaining do-while loops, or that too much?

Link to the RyPress blog for further reading/reference?

II.iii.06 - reading-ios-nested-data-structures

Is method nesting really necessary to explain?

Reference the connection to JSON response objects.

This reading is really more of an overview than a thorough reading. This should either be incorporated into another reading or fleshed out into a more thorough discussion with better examples that show how the nested literals work in practice.

II.iii.02 dictionary-practice (apples-and-holidays)

Requires NSPredicate filtering before the introduction to NSPredicate.

Add additional objects to each holiday to make more sense with using collections.

Also, just somewhat convoluted instructions. Set up the premise a little better.

II.iii.01 - reading-ios-nsdictionary

Update intro for current order of readings (says we just read about NSArray).

Do a better job of introducing the problem that dictionaries solve.

Make a bigger point of order in dictionaries not being preserved.

Are these real names and phone numbers in the example?

Explain the literal dictionary syntax by its name, both initialization and accessing.
Move "alloc" "init" to discussion of NSMutableDictionary

Explain fast enumeration for-in loops in a separate reading.

Is discussion of valid keys too advanced? I feel like this is too much. Could list it as "optional"/"advanced".

II.iii.03 - reading-ios-sorting-basic

Introduce the problem more thoroughly.

Note that sort descriptors is an array that can take multiple sort descriptors in hierarchy.

Explain "key", explain "selector" option -- should not be default example.
Show initial output of printing the example array.
"key" can be used for properties of objects.

Explain limitation of not sorting nested collections: "one level deep".

Generally just a frenetic reading. Needs work on its flow.

III.ii.07 - reading-ios-categories

Set up the problem. When are categories useful? What can we do with them?

Discuss "composition" in brief terms if the previous reading on inheritance vs composition is dropped.

Maybe pick a different example? One with more common use? Maybe a category to add a reverse method on NSString ?