WWDC2003 Session 419

Transcript

Kind: captions Language: en good morning everybody welcome to session 419 cocoa user interface programming in depth for a session of the last day so hopefully you guys are wide awake if you're here at nine o'clock in the morning either you saw andreas when cuz presentation on two days ago the intro version of this or you still think this is coco performance techniques it's not we're going to go in-depth on some of the cool new ways of doing your interface and to talk about is Mark Petrelli thank you Jason so good morning Wednesday we introduced a lot of new technology that makes user interface programming much easier now today we're going to talk about the details in section 412 we let you know about all the new bindings and controllers technology we're introducing the goal is to automate user interface handling so you have to write much less code to provide some of the features you've been asking for of course we integrated support for it into interface builder and the whole goal of course is to make your development faster and easier and the effect on your application much less glue code so i love this screenshot on a big list of ib outlets just goes completely away so what i'm going to talk about today and general i'm going to talk about what it takes for your model objects to integrate into this system and the interfaces by which we allow that to happen our key value coding key value observing key value binding talked about a little bit about how the controller class to fit into this and there'll be some notes about performance at the end so the architecture that we try to adhere to while implementing all this is a classic model view controller for Coco model-view-controller means the view classes that we've always had a full set of user interface controls and everything model class is like NS document and nsdictionary makes a great generic model class and of course the model classes you provide now we're introducing three new controller classes and its array controller and its user defaults controller and then its objects controller we're using the key value coding system that's been in foundation since Mac OS 10 point and before actually we're introducing key value observing and Panther and key value binding which ties it all the other is how object relationships are established at nib loading times and things like that and in the interest of full disclosure at this point I should admit that on the WWDC disc NS array controllers their key value observing is mostly there but NS array controller doesn't use key value observing so a lot of what I'm going to talk about this a little bit idealized but it's definitely all going to be there in Panther and there's the lots of things on the wwcc or explain it and when I give examples today I'm just going to use the old classic sketch I updated sketch so that the graphics view supports binding and does observing things like that and it hooks up to one of the new array controllers and the draw document got updated a little bit to support key value coding key belly observing and I'll show you that so terminology there's some words that I'm going to be using that everybody uses but not everybody uses the same way so today when I see a property I mean an attribute a two and relationship or too many relationship by attribute I mean something simple a single immutable value like the fill color stroke width of a sketch graphic a 2-1 related object is a single object related to another it it's not an attribute it has properties of its own so if you know it'll have attributes an example is the sketch imageclass if you if you walk to we'll code the image is 21 related to the graphic I think that holds it and too many related objects are as the name implies collections of related objects for the graphics of a sketch document a sketch document has a collection of graphics so the first leg of the tripod on which all this is built is key value coding it's it's been around for a long long time we're making some changes to the implementations of the existing API we're adding new API and why do you care because if you're implementing custom model classes and you want them to work with this binding and work with controllers they have to be key value coding compliant and I'll show you what key value coding compliant means so key value coding is our system for giving access to object properties using a very generic API that identifies them by key and by keying we just need string for the most part a sketch graphic has around sorry sketch document has graphics identified by the word graphics and the individual graphics have properties like fill color and you just name the keys you know something programmer readable and these are the same keys that you saw it typed into the interface builder bindings inspector in Wednesday's demos so in the context of what we're talking about key value coding lets views get and set values and controllers and it lets controllers getting set values and model objects so the first semester of key value coding there's a bunch when we're going to go through like four of them today though they they're there what they would they serve about ninety percent of the time value for key return to value of the key property what's interesting about what it does is it actually uses the objective-c runtime to poke around in the class of the model objects which this message is sent and it invokes an accessor method whose name is typically just the same as the key so your model class is you get to write in a very natural way but this APL API allows clients to access them in a very generic way one of the features it does for you it converts scalar values like bullion's and integers and floats to NS numbers so that they can be passed up through the API and around to different parts easily so for example sketch graphic has a boolean attribute draws stroke and the accessor method is implemented in a totally natural way and it still works when value for key draws stroke is sent to that object and then this number is returned and an ass number is a little bit easier to pass around for the generic stuff than a boolean or an integer or flow would be something new we're adding to value for key for Panther is actually inspired by scripting and we're adding specific support to value for key for too many relationships you know collections of objects that aren't most easily stored in NS array a complicated example of this is in text storage its scripting support has a to many relationship called words and to have it pick it all apart and return an array of words every time somebody asks just for one of them isn't really that great of a thing or so we're we're adding a few more key value coding compliance methods so you'll have your choice you can either implement graphic in the example to sketch drawn ashman or you can implement two methods count of graphics and object and graphics at index to provide access to that relationship and so and whatever you choose the key value coding client the caller a value for key can't tell the difference it gets back and NS array key value coding puts the NS array together and the client that uses key value coding can send any NS array method to it including the methods that are implemented in categories and then try something new we added just by request was support for key value coding get accessor names that more closely match the conventions that you see in our API value for key not only looks for methods of the same name that looks for methods that begin with is so you know you can write still more natural code a brand new method for Panther is set value for key and as its name implies it sets the value of the keyed property it's a renaming of a method that's already in there called take value for key and typically we don't just go rename things and like in the kit this is actually in addition to the take value for key method that's already there but we consider the renaming we realize while we're working on this that key value codeine is going to get much more popular more widely used than it has been so we decided to clean up things like this so the default implementation does the equivalent of what value for key would would do it looks for a method whose name fits the pattern and invokes it so when you send an object set value for key fill color it will invoke a method named set fill color and just like value for key does it does NS number two scalar value conversion something that's been missing now we're adding to panther this can be very useful in the context of this UI programming is a new method named validate value for key error and its implementation is supposed to either return a value good enough for passing into set value for key or supposed to return an error and the reason this is separate from set value is because of separate validation rules from decisions about when to validate how to validate is always a model decision but when to value that validate is a UI decision so for truly reusable model objects keeping the separate is a good thing you might want to defer validation till the user hits the next puttan next button on a pain or something like that and the way you implement this is follows a typical KDC pattern you just have to name the method correctly and said I couldn't think of an example of this for sketch so I picked the zip code which I think people will probably be typing in a lot so and the method name just follows that pattern something really new for Panther is this method mutable array value for key and what it does is it returns an NS mutable array or something indistinguishable from one that contains too many related objects and the reason we need this is because you're not supposed to mutate the NS array that's returned my value for key when the key refers to Germany relationship so we wanted to support this concept of you know a client that's naive of the class to which is found being able to mutate sets of objects so we added this and the invoker of this method gets to send any NS mutable array message to the result again including things are implemented on categories so the user of this method really has total flexibility it's not limited to a specific API when manipulating the data but at the model class that provides the data doesn't have much responsibility it just has to implement two methods that corresponds to the two most primitive NS mutable array primitives insertion and removal so the client of key value coding gets to do all sorts of different things but thing that implements key value coding support for that key doesn't have much responsibility a concept that will be coming up a lot as I talk and shows up a lot in this UI technology is the concept of key path and for each one of the methods I just showed you there's a variant that takes a key path instead of just a key and these are actually probably invoked a little more often than the plane key methods and what's the key past a key path is just a dot separated list of keys and those methods that take keepass pick them apart at the right time and invoke accessor methods correctly so if you send to some object set value for key path image flip it'll get the image and it will effectively send set value for key to that image which boils down basically to the line you see on the bottom of just you know getting the image and calling set flipped so key value binding is in terms of key pass and key value observing is in terms of G path and our controllers use key pass for example and NS array controller republish a--'s the properties of whatever it's bound to it republish a--'s those properties you know of the selected objects and it does it using this key platform so you have to know about them but you don't have to do anything to implement them so if you're writing custom model objects like sketch graphics for example here's basically all you have to do to make those classes key value coding compliant you'd have to implement enough methods for value for key and set value for K and things like that to work so for each attribute or to one relationship you know single values you can just implement methods named the same as the key that you picked to identify that property and if it's a mutable property you have to implement a set method also if there's validation to be done you implement the validation method if there is no validation method that's fine validate value for key air just assumes there's no validation necessary for each to many relationship like the graphics in a sketch document you have your choice you can either implement a simple method with the same name as the relationship or you can implement a pair of methods whichever is most convenient in your situation and you know you can change it after the fact about having to go change other code for each to many relationship that can be mutated things going to be inserted removed a replacement it you just have to implement this pair of methods insert object and Keaton X and move on just from chea decks so the demo is you saw on Wednesday were great and they took advantage of the fact that nsdictionary is key value coding compliant so for simple model objects don't bother right in the class just use nsdictionary so you know it it responds to the set value for key and value for key method works fine it's and it's a very least and easy way to start prototyping and I think a lot of times are going to find out that your application is done before you run into the limitations of good old nsdictionary so possibly the the first limitation it will run into though is the fact that it doesn't do any validation of the values set value for key just goes in the head goes ahead and sets the value whether it's valid or not so the next thing that we're introducing panthers key value observing its all new api i'll talk about how to observe i'll explain why your model objects have to be key value observing compliant so that other objects can bind to them and i'll explain what you have to do to make your model classes kita observing component so what does key value observing do the summary is that it allows objects to be notified of changes to specific properties of other objects the notifications are very detailed and the context of this UI programming it lets views be notified of changes to values and controllers and it lets controllers be notified of changes to values and model objects an observer registers its interest in getting notifications using this method add observer for keypad options context this isn't part of an informal protocol and this object really does have an implementation of this but does everything you need we don't really expect this to be over in that often these messages are actually sent to the individual objects to be observed there's no observer Center that you know about or anything like that for this to be meaningful the receiver must be key by observing compliant as far as reference counting goes I think there's probably going to be a bunch of different situations as far as reference counting goes what's appropriate for the observer to observe the observed object or not so key value observing just stays out of the discussion it's API it doesn't cause any routines or releases well there'll be some standard things that people will do over and over again the star is retaining and releasing but the key value observing leaves everything very flexible and as you would expect if there's an ad observer method there's also or remove observer method so the first parameter is the observers the recipient of notifications about changes to the property identified by the keep at this observer must implement the NS key value observing informal protocol which is one method this one deserve value for key path of object change context and I'll talk about it a bit later and as again as an example of who's observing what they controls and sketches inspector panel that will show you in a bit will observe the selection property of an hour NS array controller to which is bound so the key path is just the keep a that identifies the property to be observed sticking to that example selection dot fill color and it can identify and attribute the two in a relationship or committee relationship you can not only observe simple values you can observe collections values and be told them things are inserted or removed or replaced he Valley observing supports two options right now we we definitely expect this list to grow in the future but right now they're just too new and old and these don't control when observing notifications are sent just what's in them when they are sent so new controls whether or not the observer notification has the value after the change and the old controls whether or not the observer notification contains the value from before the change that's causing the observer so I think in the the feedback after the session on Wednesday somebody asked about automatic undo support which is something we always think about and I think this old option will probably be a big piece of that comes around and the kind of there's a context parameter following a pattern that's common in a lot of cocoa API is something that you can pass in that will just be passed back to you at the right time and we think people probably use this for you know identifying the reason for the observation when one observer is observing a bunch of different things so the the notification method observed value for Q path of object change context is what sent to the observer for every change to the observed property and it's very generic key value observing doesn't care what you do when you observe this it's it's meant to be very low level and very generic so and the key path and the object are pretty much just the things bouncing back to you same thing with context change is a menace dictionary full of the information about what changed there are four possible entries into it the kind of change indexes for the change of the irony and new values and old values there are two basic kinds of observable change notification the first one is for simple setting when you know he value coding set value for key method is invoked and somebody's observing for that property this is the kind of changeable use setting if somebody's observing a to many relationship and it is something it's inserted or removed or replace you know one of these next three observer notifications will be sent and for example when might that happen when somebody uses that mutable array value for key method method and you know mutates the array that it gets back something like this will be sent to any observers and in the case of insertion removal replacement it provides the indexes of the objects that are inserted or removed to replace using the new index set class we're introducing them Panther it doesn't make sense for simple setting changes so it's not there then and the last two entries of the key value observing change notification our old values and new values and you know these aren't there if the observer didn't specify it wanted them when it registered as an observer so for simple changes settings these are just the old and new values of the property for insertions removals and replacements these are actually a raise of the objects that are inserted or move to replaced so how do you what does your model class have to do for these key value observer notifications be sent out when properties in your model class are changed well there's the pretty easy way in the really easy way this is a pretty easy way you just stepped us around the change with indications of will change value for key and did change on four key and in the case of too many that was four attributes into and relationships or too many relationships when collections of objects are being changed the methods you have to invoke are a little more detailed will change and yet specify removal replacement or insertion the relevant indexes and then again the key that identifies the to many relationship so that's not so bad but we don't even want to you know force you to have to write that much stuff into your model classes so we're introducing a feature called automatic key value observer notification and it's actually on by default so you don't even have to do anything to turn it on and what automatic qilai observer notification means is whenever any of those key value coding methods like set value for key is invoked that will cause an automatic key value observer notification to be sent out and not only that but indications of key value coding compliant methods result in observing notifications so not only the set value for key messages cause observer notifications for that key but soda implementations of the accessor methods for that property and not only do mutations of the result of mutable array value for key cause notifications but when any anybody sends an insert object in key it index or move object from key at index message to an observed container that will cause key value observer notifications so you don't have to sprinkle will change value for key and did change value for Keating all over your code if your model objects access their own values and each other's values consistent consistently through key value coding compliant method will do the rest you know simple set methods just keep using those you know you might already be using those and it'll just automatically work so and of course they're a couple situations where you can't go through those key value coding compliant methods and even when you're using automatic key key value observer notification the manual mode keeps working so key value binding it's the third lake leg of the tripod that all this sits on and it's brand new API and it's what ties it all together it's what allows the value of an object's property to be tied to the value of another object property and the safety our introducing provides plenty of flexibility so that objects can support binding options that we can't even anticipate and key value binding when it's being used that implies that typically key value coding and key value observing writing used to so this API is key value binding API is used at nib loading time typically you can be used with other times of course and views and controllers get hooked up to controllers and model objects key value observer or key value observers are registered with the things that they're observing UI controls at that point take responsibility for updating whatever they're bound to whenever the user manipulates the value that they're presenting and of course all the asset classes to which are adding bindings support do this so this is what the method looks like it's just buying to object with keep an options this is again sent at nib loading time you can use it at other times too for more complicated situations but for a while this will probably we don't expect too many uses of it you know other than nib loading time but it's there for you so and of course there's an unbonded tick so the parameters are the name of the binding and a lot of these look like key value coding keys but they don't necessarily have to be and for example NS control exposes a value binding and NS text field exposes and editable by meaning things like text color to the other parameters are you know what is being bound to the object that contains the proper to be bound to and the key path is a property and there's a dictionary that takes options so I think andreas covered most of these options pretty well on Wednesday which is to refresh your memory things like value transformers something that can manipulate the value for you know as part of more glue while things are moving around placeholders the marker values that come out of controllers for complicated selection situation become place holders that are presented in the UI and any options that are specific to the binding so controller classes there they're the first big clients of key value coding key value observing and key value binding there is an abstract superclass NS controller and three subclasses NS array controller object controller and user defaults controller so and its array controller is what you would typically bind a table view to now and NS array controllers have a to many relationship named arranged objects there's a set of objects to be presented to the user after any sorting or filtering or whatever it's done on the other side of the arrange controller you can bind it it's a ray relationship to the to many relationship of a model object in our example for example the graphics of a sketch document what the array controller we're using binds to so in key value observer notifications from the model object cause key value observer notifications to be sent to the table refers to the array controller then to the table you and the the array controller just doesn't pass them straight through it updates them to take things like sorting into account because that's what the table view is thinking about as arranged objects and it also keeps the selection up to date when inserted or removed objects I'm sorry when objects are are removed or inserted and make sure that the selection that's showing in the table view still make sense and in addition to binding an NS array controller to a relationship of model object you can just use the set content method that it publishes and let it manage the lifecycle of an array of objects you don't have to you don't have to bind it to anything you can just let it do all the work for simple situations so the first big feature that NS array controller has is selection management you can bind the selection indexes of a table view to an array controller selection indexes and when you do that and you've also bound the selection selection properties of an array controller to you know UI elements whenever the selection changes key value observer notifications are sent to the UI elements so for example a color well that's bound to an array controllers selection is notified whenever the in this example whenever the fill color of this directive selected graphics changes and that might happen either because the fill color of an individual graphic change or the set of selected graphics changed in all the different situations that would cause that to be updated in the UI msra controller isn't just for for binding it provides real API of its own you know big set of methods you get to call and just the selection of them NS array controller has built-in support for user friendly selection behavior a few flags like avoids empty selection for when that's appropriate in the table view preserve selection so things are are being inserted and removed around the selection the selection statesville and selects inserted objects from and that's the right you I behavior and for situations where the array controller is being manipulated by some other code of your own you can get it all the things like the selection index is using methods like that selection indexes and add and remove the other big feature that NS array controller supports right now is sorting so you can bind the sort descriptors of a table view to the sort descriptors of an array controller so as the users clicking in the the table column headers to change the sort order the table view tells the controller that the list of sort descriptors has changed and when it does that and this array controller actually does the sorting and sends out key value observer notifications for the array and ranged objects relationship so that was an NS array controller and its object controller is also there and its name implies it controlled a single object instead of an array so why is it useful to bind a UI control to an object controller it's because you combine an object controller is something that might be you know coming and going it will observe a to one relationship and another object and I it's those clever things like handling the situations where that two men are that I'm sorry that two one related object disappears or the type of it means that the bound to property is no longer applicable so in general and object controller serves the purpose of generating these marker objects that you heard about our Wednesday that get converted to placeholder objects that show up in you I even in simple situations so in just as with NS array controller for this object controller it has a set content method so you can just let it own what's being presented and the third new controller is NS user defaults controller and we saw demonstrations that on Wednesday and what you do is you buying the values of you I controllers to the value of the user defaults control you know some sub property of it that's the key for which you know you get to pick the name so not only can you do that but you can observe and its user default controller so other parts of your program that want to know immediately when the preferences change can just register themselves with key value observers of those properties and NS user default controller also supports handy support for setting the initial values of preferences you know the factory defaults and shared user defaults controller is easy to get to an IV you saw it being picked from the the pulldown menu in the bindings inspector on Wednesday so let me show you some of this code I'm talking about so let's say that sketch was so useful that it was worth packaging up and making sure that it was properly reusable the first thing we would do in doing that is adding binding support to its graphic view and here's a simple implementation of the key value binding method that I told you about this sketch graphic view supports two binding names one is graphics the list of graphics to be presented in the view and selection indexes just you know that which graphics are selected so in the implementation is pretty simple all it does is it just stores a pointer to the container of the graphics that's being passed in the keep a that was specified and then it starts observing that container of graphics so it wants both graphics that are being inserted and graphics that are being removed so it can update the display and I'm sorry I move removed while that's happening and the context that specifies just so it can identify why it's getting these observer notifications is just one of a handful you know simple and it really just needs them for identification purposes and for selection indexes it does a similar thing it records the information about what the graphic view is bound to and then adds itself as an observer and then it updates the display so sketches draw a document for it to allow things to bind to it it has to be key value coding and key value observing compliant for this graphics relationship that it publishes this is all it takes to do to be both key value coding and key value observing compliant for that relationship just something that returns an array of the graphics and the method that handles insertion and in this case it still has to do its own undo support and in addition to doing the actual insertion that also tells the graphic what document it's been added to that's actually part of sketches scripting support for individual graphics individual graphics also have to be key value observing compliance so that the sketch graphic view can observe them can be told when they're changed so it knows to update the screen the first one I'll show you here is set fill color and I didn't have to change this at all this is already key value coding compliant and because we're using automatic key value observer notification it's already kto compliant so no changes necessary for this one for set stroke line lift it does a little more the line width of the sketch graphic effects how large the graphic is on the screen so it just manually says when the line width changes the drawing bounds change and actually there's another feature that's going to be in panthers called set Keys trigger change notifications for dependent key a mouthful but this is what you can use to indicate things like the drawing bound of the sketch graphic depends on the line with so this will change value for key and did change value for key it won't even be necessary in this situation though should leave it in just so you can see what it looks like so I just run this and it's sketch you know sketch that's all so it has inspector panel and I'll select them all so as you change things that just works so and I'll show you the code for the inspector panel in a second and changing things is automatically updated on the screen so the code for the inspector panel I think you can see this coming I'll show you some of the bindings in the nib this is pretty neat I be gives you a nice summary of what's going on with the bindings so the checkbox here for controlling whether or not the graphic is filled it's just bound to the selection draws fill of an array controller the fill colors bound the selection dot fill color of an array controller and actually it's really not appropriate to leave that enabled when that check box is not checked so you can bind the enabled binding of the color well to selection draws film so and so on so because of all the binding support in the inspector panel and because you know and it's a raid controllers taking care of everything for you here is the source code for inspector controller which is no longer part of the project I got to take all of it out so this is not actually built into the project anymore so how many lines of code got to go away because of that finding support and inspect repent we won't count a copyright notice so about 250 lines so if they go completely away so the last thing I'll talk about today is performance some of what we're doing to make sure that the new technology is fast enough to use and some performance notes about being key value coding compliant and Q value observing component so as I mentioned observation info is actually associated with each individual observed object and it might sound expensive you might imagine oh no that means that there's going to twice as many objects in my system each object and then the observation info for each object and no that won't be the case we're actually taking great care to make sure that when multiple model objects are being observed in the same way same set of observers same key seems like that the memory that's allocated to record that observation is shared between the individual observed objects key-value coatings performance has always been very important and we're making sure we don't ruin it with key value observing so set value for key has a certain cost to it and are making sure that cost isn't going to go up inappropriately when somebody is observing that cube for that model object so and the general rule we're following is that we're providing good default implementations for everything but we're open to optimization but we're leaving things open to optimization for specific cases which I'll show you one piece of advice for you value for key don't override it there's a bunch of performance tricks we can play as far as caching objective-c runtime info goes but all those tricks are effectively defeated if value for key is overridden so in general just stick to the pattern of implementing you know key value coding compliant accessor methods so I mentioned that we added a support for implementing key value coding compliant methods of the form counts of key and object and key at index those are required if you're using that pattern of giving access to relationship if measurement says it's worth it you can also implement a method whose name follows this pattern get key range so those first two methods correspond roughly to the primitive of NS array and this next method corresponds pretty much to another NS array method that you can override for mutable to many relationships you have to implement these insert object and remove object methods you can also implement a replace message if it makes a difference in your too many relationships case so that's just two optional key value coding compliant methods we plan on adding a bunch more in the future as we get more experience with this seeing how people are using it and you know see the the performance issues that need to be dealt with so and for example we you know we might add more optional key value coding compliant methods that lets you insert and remove ranges or work with the new and its index set class that's being introduced in Panthers so and whatever we do though we don't intend to you know change the list of methods that's required to be key value coding compliant as far as using key value coding goes the advice is don't over use it so if you're converting code making it more generic letting it support bindings and you're converting implementations of simple methods to uses of value for key and mutable array value for key that might be worth measuring when you're all done with that these methods are pretty fast considering what they do but they will always be more expensive than a simple objective c message dispatch so you should check that when you're using value for key in getting an array back or using mutable array value for key and getting mutable array back what we're suggesting for now is try to use it just like you would a normal NS array or NS mutable ring our intent is that the performance characteristics will be pretty much the same as a real an iterator and it's mutable array so if then when that's not the case we want to hear about it and if you see optimization needs to be done try and keep that in the model code and you know where it will be more reusable as far as efficient key value observing compliance goes there's a pair of methods that you get to override if you need to and I think typically you won't but they're called set observation info and observation info so when large numbers of objects are being observed you know the observation info is actually stored separately from the object associated with a hash table and that should be good for most of the you know most of the time but there may be situations where it's not and when it's not we just want you to give us four bytes of instance variable space and let us put the observation info there and in general with key value observing take advantage of the fact that these observation notifications are our super fine granularity it just doesn't say that the object changed it says that this property of the object changed so you know don't don't cause Q value observer notifications to be sent out when nothing is actually changing and on the other side of it don't observe not necessarily so that the asset views to which binding support are being added take care not to observe gratuitously the best example of this is table view when a table views role objects are bound to too many relationship in a container for example in an NS array controllers arranged objects which will be typical if the table view if there's like you know hundred thousand rows and the in the table it doesn't observe a hundred thousand objects it just observes the 50 that are visible at any one time and we're taking care to make sure that adding and removing one object as an observer of another is is fast enough to make that feasible so there isn't any noticeable overhead while you're scrolling a table view caused by the facts of this table view is d registering itself as an observer the objects as the scroll off and registering itself as an observer in six tall on so one more pair of methods I haven't told you about yet it's the bulk variance of AD observer and remove observer so the same set of parameters as the ad observer in the new observer I've already shown you but it's sent to an nsarray and it takes an index set identifying the objects to which key value observer should be added or removed so and in general you know there's a little bit of work that has to be done when one object adds itself as an observer of another with these methods that little bit of work is only done once basically the observed objects you just told you know here's your observation and if I'll hold on to it for me so that's pretty much it on Wednesday we introduced great new technology to make user interface programming much easier and today we talked about what it takes for your custom model objects to hook into that so and it basically boils down to being key value coding compliant and ki doli observing compliant and we work pretty hard to make sure that that's going to be fast and easy for you it so I hope you all give what is on the wwc see it a try it should work pretty well for you and and we hook you a right great custom apps with this thang thanks mark let's see okay so here's the roadmap obviously this is make much sense since it's Friday but fortunately there are dvds that you'll be all getting so make sure you look at those dvds when you get them check out the intro Coco the cocoa update sessions and so on we do have a couple of things still coming up today we have the tips and tricks for 24 sort of your reward for staying through the entire week some really cool stuff in there and of course so what's new for Coco tech some really great stuff that we've added to the text engine okie dokie there we go so John Glenn geez the person you want to talk to if you've got some information feedback what have you on all the coca cells that you've seen at the show you have general API suggestions they should go to Coco dash feedback at group that apple com those go directly to the cocoa engineering team and if you have code level questions they should come to my team develop technical support where I have to help you if you need more information we've got no documentation [Applause] but feel free to check the headers we will we will have documentation for Panzer you