@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/04-Behavioral-PatternsPt.2/Lesson4

The Observer Pattern: This is long and is super text-heavy. Consider adding the following to break up the flow a bit more and keep students engaged:

1. Provide an analogy/example: like subject/observers to how students use slack and subscribe/ignore notifications
2. Have the pseudocode to start, but then also show some real code examples as well, to help engrain the concepts for them
3. Have them play a game of passing messages and accepting/denying them to help learn the concepts.
4. Show an example of the Pitfalls described in action through code
5. Show the use case described in Example Use Cases with an actual code example

We can talk IRL how to improve this section, but the main point is that it's way too much text/reading and not enough doing.

*The Observer Pattern in iOS again similar to the previous feedback, need to be more actual code examples here. Perhaps these 2 sections on Observer pattern can be consolidated into one and just be filled with more examples? Good example would be how mediation is handled IRL (have them think back to SPD)

In Class Activity I and II: Need more walk-through examples before jumping right into the activity, but I think this will be solved if we fix up the previous sections

*After Class: Same as others, how are you tracking completion? There also seems to be a formatting error in the large code section

@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/11-Reactive-ProgrammingPt.1/Lesson11

Overview/TT I: You mention Rx in "Modeling Event Streams with Marble Diagrams" before describing what it is later. Either introduce Rx earlier or remove the reference and update the section to talk about diagrams without needing to know Rx

Also, I feel this section could benefit from a more dynamic diagram: a GIF of some kind to actually show the streams.

I would also consider putting the section on relating this back to the Observer pattern earlier, to draw parallels and showcase differences to help with understanding reactive pattern

How Rx solves them: I think this section should be way less text and more code. Use the code to showcase what's going on in the text, and don't just have walls of text

Code examples also should have more descriptive comments on it

In General - more coding challenges, can be easy, but get them coding more, less TT. Go back to the 90% similar challenges, just more repetition

@amelinagzz - feedback on https://github.com/Make-School-Courses/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/blob/master/Lessons/03-Behavioral-PatternsPt.1/Lesson3.md

Note: The link on your GitHub Pages page is broken, just renders it as if it was plaintext

Learning Objectives: numbering is off (goes from 1 to 3)

Chain-of-Responsibility: This is a lot of talking, with wikipedia explanations. I think it would be helpful to have an analogy here Use the analogy in the linked article in the example section, provide a strong image with it (wiki one is blurry and bland). Maybe one Like this? Also show the code they use as well as your example (site the source)

Example or CoR: typo, should say "of". And see paragraph above on how to revamp

Key Example Use Case: Too much wikipedia outsourcing. Find a better way to convey this through your own examples, or something less stale than wikipedia. Happy to work with you on this IRL, but will need to be an active session, more than just static feedback

In Class Activity I Prior to this, make sure to give them something to work with where they are given help, or at the very least, walk through a coding example with them so they at least see it first. Or give them some example code to model off of

Also in general, it's not clear what the ask is in each section. If you want them to do something, phrase it very clearly, format it in bold, etc. Right now I'm honestly not sure what they need to do

Command + In Class Activity 2: same comments as above: less wikipedia sourcing, more original/helpful examples, more pictures and analogies, and more coding examples before throwing them into it on their own

@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/08-Coordinators/Lesson8

Example: This says it will not run in Playground, but we should give them an example that can run in Playground. This section has a lot of TT, so a way to get them playing around with code more should be tried.

Overview/TT II: Might make this more interactive by trying to have them draw the diagrams themselves, and then going over it as a whole class with you drawing the diagram (or having a student present if they drew it correctly)

After Class: Usual question on tracking completion

@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/09-Functional-ProgrammingPt.1/Lesson9

Key Concepts: This should have code examples, not just text.

Side Effects: Give code examples. This could even be a worksheet where they are given code and asked what the side effects are

Imperative vs. Declarative Code Style: This is better, integrate this with the previous text-heavy sections instead of making them two sequential sections

After Class: You know what I'm gonna say...

Overall I think we can reduce TT here by just combining some of the code example sections with the TT, to make it more interactive. Or turn the code examples into worksheets that they fill out as you go through your TT, and use the worksheet fill-in time to break up the TT

@amelinagzz - feedback on this lesson: https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/01-Creational-PatternsPt.1/Lesson1

Creational Patterns - You mention a lot of patterns here, I would clarify which ones you're going to be talking about in which lessons, and which you aren't going to cover. Also explaining why you're not going to cover them

Possible Idea: To make it more interactive, have them do an activity where they split up and do some peer learning/research to teach themselves what Singleton and Object Template are. They can then share with the class, then you can go over your material, but they'll have a good primer now.

In Class Activity 1: Include a followup activity that has them code up something similar, but doesn't give them any source code. Should match the first example 80-90%

Overview / TT 2: For the 3-step process you outline, it would be good to have example code at each step to showcase it. Or if you can't break it up, show the 3 steps in one code snippet through comments

After Class: How are you checking they did the research? If you don't have a system in place, have them answer a google form quiz, or send you a DM or something like that

@amelinagzz - Feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/06-Structural-PatternsPt.2/Lesson6

This lesson, in particular, suffers from too much TT. I've given high-level examples below of how to address it, but I'm also happy to talk with you on how to fix it and we can work on it together if you need a thought partner

Proxy:

• way too much TT upfront. Lots of just text. Break this up with simple code examples of each type of Proxy. Right now you only have one example, get one for each proxy type.
• For the Protection Proxy Example, show what happens when you try to access the restricted class directly.
• Give them simple challenges to work with here that mimic the examples. Needs a lot less TT, and a lot more doing. Can help you come up with this if you'd like

Facade:

• use metaphor of a game console: controller is a simplified way to interact with a complex machine (can also use car, remote for TV, etc.)
• more iOS-relatable examples! That first one is ok, but may help to give them more grounded examples in things they would actually see. They don't need to be complex, but there just needs to be more coding and less TT. Give simple examples, then have them do a simple challenge that 90% mimics the example.

After Class: Same as before, how do you check the research?

@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/13-Reactive-ProgrammingPt.3/Lesson13

Overview/TT I: Give code examples of each Operator type

Overview/TT II + In-Class Activity II: Would there be a way to combine these two? Interleave the TT and activity more?

Question: Do we really need 3 lessons on this topic? Maybe we do, it just seems like a lot for one topic. But I'm also coming from a not fully informed POV, so maybe we do need it? Would like to hear justification around it either way.

@amelinagzz - Feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/05-Structural-PatternsPt.1/Lesson5

New Idea: Have them research the patterns themselves first, discuss as a class, then you explain the concepts and have them practice it. could be a nice way to break up the flow of lessons so far

The Adapter Pattern:

• Give a metaphor here to help the concept sink in. Comparing to the dongles we use for macbooks would be good here.
• Client is mentioned but never used. Either use it in your example, or omit it if it's not important
• Make them do a mini-challenge here. Should mimic the hobbit example 90%, just get them practicing writing the syntax
• Might be nice to have small code-snippets of the "when to use" and "when NOT to use" sections to highlight the examples

The Decorator Pattern:

• Use a metaphor of a magic dongle that automatically adapts to any connection that's needed when you go to plug it in.
• UIDatePicker has a formatting issue
• Put the Coffee example earlier to break up the TT. After the "Problems Addressed" section.
• Add a simple challenge that's 90% like the Coffee example (make it Tea, or Boba, etc.), and have them do it themselves to get practice with it

After Class: Usual concern of how are you checking that they do this work?

@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/12-Reactive-ProgrammingPt.2/Lesson12

Initial Exercise: This is a great example of what more lessons in this course should look like! Explaining concepts through doing activities, with a very short TT after the activity to tie it all together. Great work!

Overview/TT I: This would be another good section where a lot of the TT could just be put in as comments in the code example. Or break up the example and TT into more, but smaller chunks so it's easier to consume

Overview/TT II: Way too much TT again. Break it up by providing smaller code examples, and then have students do a coding challenge that is 90% similar to the example

@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/10-Functional-ProgrammingPt.2/Lesson10

Most of my feedback can be summed into the following question: is all the content here things they need to know? There's a lot of text/words, and I question if all of it is valuable information, or if a lot of it can be relegated to a link for those who want to learn more.

We should do a session together where we break down this lesson (and possibly the previous one) and see if we can distill this lesson down to the core information the students need, and then replace that TT time with more code examples/coding activities/etc.

@amelinagzz - feedback on https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/07-MVVM/Lesson7

Four Components of MVVM: This could benefit from a side-by-side code comparision: show the same, simple app (doesn't need to be complicated) in MVC, then show it in MVVM. This can help break up all the TT

Overview/TT II - this whole section could just benefit from some code examples. Explaining it all in text only goes so far. Show them examples of these things in practice to help solidify the concepts

After Class: Usual concern of how are you tracking they're doing the research?

@amelinagzz - feedback on this lesson: https://make-school-courses.github.io/MOB-2.4-Advanced-Architectural-Patterns-in-iOS/#/Lessons/02-Creational-PatternsPt.2/Lesson2

The Factory Method Pattern: Big text-heavy section. I would include some code snippets here, especially around the Implementation section and the 3 operations. Show a code example for each of those steps

In Class Activity 1: The SUV class is already built, should it not be? I would also have them do a second exercise where they have to actually build the create() function so that they get practice with that

Overview/TT 2: Like that there's an example, but I think it would help the material stick better if you broke up the example to go with its related step in the Step By Step approach section, and then show the whole thing together at the end to bring the point home. Also more comments in the code to help with descriptions of what is going on

After Class: Same as last class, how are you tracking they do their research? See previous suggestions