Show students Warm Up slide
	Building skeleton classes for observer/observable example should help speed things up

Last lecture:
	- GUI + EventHandlers (rushed)
	- We will review event handlers, but later in this lecture


This lecture will be slide-heavy...sorry everyone! Not my favourite either :(

Observer/Observable interface and class

	- Go over slides for Instagram and user example to illustrate the concept of 
	  observable and observer

	- Observable is an object that "can be watched" (subclass of Observable)
	- Observer is an object that has the ability to "watch" things (interface Observer)


	observerExample package in w5 package

		- Code this small example of an Insta club page making posts and users that 
		  follow that page automatically get notified and update accordingly

		- There are blank versions of: IGUser.java, ClubPage.java, and ObserverExample.java

	- Important notes:
		The object that can be watched needs to
			1) addObserver(object)
			2) call setChanged() when needed [to be determined by devs]
			3) Has to notify all the observers (or a subset) when all the 
			   changes are done

		The object that is watching (observer) needs to have:
			1) update method to define how the water should react to the notification


SCRUM

	- Not an acronym. We just borrowed a sportsball term :)

	- See PPT slides

	- Key concepts: 

		SCRUM is an iterative workflow structure that teams can follow when working on projects

		Main Components: 
			Create a ToDo list 
			chunk ToDo list items into multiple sprints
			Do the sprint (work on and complete the items planned for that sprint)
			Sprint Review (present the results to stakeholders and get their feedback)
			Sprint Retrospective (team reflection on what worked and didn't work)

		
			*See slides for more concise details on each of these main components


Design Patterns

	1) Motivating question: 
		Do you find it difficult starting a new project (solo or group alike) 
		because you don't know where to start?

		"I can't build this because I'm waiting on this to be built first"

		"Class A's xxx method depends on Class B's yyy method, 
		but Class B's zzz method depends on Class A's hhh method."


	2) A design patterns are the notion of structuring/arranging the codebase in
	a flexible and modular way
		- relates to the code structure, NOT the implementation details
		- Language-agnostic (not specific to Java)

		- Separates the various components of the codebase to be independent but interact 
		  through a well-designed set of API (i.e. the objects can interact efficiently)



	3) Simple concrete example: A digital clock vs analogue clock (see slides)
		- They visually look different, but the essence of each are the same


MVC (Model View Controller)

	1) Go over PPT slides

	2) High level overview of concepts

	- MVC is one example of a design pattern


	- The Model are all the classes that defines behaviour and how data is stored/handled
	- The View are any and all components that display information about the model to the user 
	  (often GUI elements, but not always)
	- Controller is comprised of all the objects needed to capture user input/actions
		The controller also has to interpret these actions and update the model accordingly. 
		Controller may also have to switch views/scenes as needed.  

	3) More involved example from past CSC207 example: Balloons!
		- Balloon.java is the model
		- UseBalloon.java was the controller
		- Missing a view...so let's make one

		

		- See slides about desired GUI for Balloons

		- Model: Balloon.java is still the model
		- View: JavaFX Label objects are the view because they are responsible for displaying the model info
		- Controller: EventHandlers for Buttons (and the Buttons themselves I suppose)




		- Open the balloonmvc package in IntelliJ

			- Pay careful attention to the code structure

			- Model: 
				- Balloon.java extends Observable (things keep an eye on the model to see when it updates)
				- the model has to add observers
				- the model also has to broadcast (notifyObservers() ) when it's been updated
			- View: 
				- GUIView.java (Labels) implements Observer (it keeps an eye on the model)
				- that interface requires Labels to now implement update() method
			- Controller: 
				ButtonInflateEventHandler.java (the majority of the controller)
			- Main application
				GUIApp2.java (It is the point of entry, creates everything, and hooks everything up)


Homework/Class Activity:

	- Take the provided ill-structured code and refactor it, modifying it as needed, so it fits the MVC design pattern
			
			
