WWDC2001 Session 703

Transcript

Kind: captions Language: en ladies and gentlemen please welcome Godfrey de Georgie good morning I'm glad to see so many people were able to get out of bed on this third day of WWDC how's the show for you doing good fantastic okay so this morning this is the project builder in-depth session where we're going to take you into some of the more curious details of project builder and show you how to get things done and to that effect I'll introduce right away Mike Farris the manager of the project builder ID development team hello so we have a lot of stuff to cover today and so I'm gonna go ahead and dive right in basically we're gonna try to focus today on some of the more advanced features in project builder and we're gonna concentrate on on features of the build system you know project builder you know does pretty automatic support for most of your needs in terms of the building of your project but every project every real project is probably going to have a few things that fall a little bit outside the scope of what PBE handles really automatically and so we want to do today is talk about you know what features are there in project builder to let you do the kind of things that we haven't possibly anticipated or that aren't directly supported and automatic in project builder so small projects you know may be very simple you create a project template it builds everything works fine but large projects often get more complicated and an IDE has to be able to build your projects the project templates gets you started you're going to add a bunch of stuff to that we have to support you you adding all that and we also have to be prepared to let you get stuff done that we don't even know about right now so you know there may be some new requirement that comes up you know at six months and if you can't get project builder - you know satisfy that requirement you're kind of stuck and when it comes to this future extensibility the most important part is the build system because if project builder can't build your project it doesn't matter what other features it has all right so again we're going to concentrate on the build system today this is basically what we're going to go through today we'll start with importing projects and source code into project builder this will give us a project that we can then use throughout the rest of the session to show you some of the more advanced features once we get the project up and running we're going to talk a little bit about targets and then start talking about some of the specific features that go along with targets and project builder build styles which let you modify the way that a particular target gets built so if you want to have a target to build your application but sometimes you'd like to build it for debugging and sometimes you'd like to build it for profiling and sometimes you'd like to build it to put it on a CD and ship to your customers you you would use build styles to customize the way that the target gets built build phases are sort of the basic basic building blocks of a target so a target is basically a sequence of build phases and build phases you know do different things to the files that they contain and we'll talk a little bit about what that means and then at the end we're gonna talk a little bit about legacy targets and a legacy target is a special kind of target and project builder which basically circumvents project builders building system altogether and so one common use for a legacy target would be if you have a project that's say an open-source project and it has a make file you can set up a legacy target that will invoke make to build the project instead of use project builders built-in system alright so let's get started on importing our source code basically you have a few different ways to get started with project builder if you're starting a brand new project okay great you just pick a project template that's closest to whatever you know you want to end up building and you start with that and you just start adding your code and writing it and eventually you will be done but a lot of you all have existing source code and so then the question becomes how do I get all this code I already have into project builder and building and we provide a couple different ways to do that we can directly import projects from two different ideas from code warrior and from the old version of project builder called project builder wo these days the third way to get source into your project is that you can just directly import you know hold trees folders full of source code in the project builder in a fairly automated way and we'll show a little bit of that too so today what we're gonna do is we're gonna start by importing a code warrior project and to import a project from code warrior you start in code warrior because you're gonna have to basically export your project as an XML file and then project builder can read in the XML file before you export the project as XML it's important to set in your project settings for code warrior the little checkbox that says save project entries is relative paths PB can import this stuff a lot better if it has the relative paths to the files once you import the project project builder will automatically get from this XML the whole group structure of the code where your project it will bring over any targets that are in the code warrior project and convert them into project builder targets once it's all in there you're almost certainly gonna have to do a little bit of hand tuning of the resulting project before it is complete and buildable and project builder so the other thing that we're going to talk about a little bit today is importing just folders full of source code you can just drag a folder into project builder from finder and project builder will offer to sort of recursively import all the stuff inside the folder when you're going to do that it's usually the best thing to create the target that you want to use to build that source code first because as project builder is importing all this stuff it can automatically add it to a target so if the target already exists you can say okay add it to my new target and as it's processing all the files it'll figure out which build phase each file belongs in and put it in there automatically once it's all in there you probably have some more configuration to do on the target before it actually builds so alright let's get started with the demo and to help me with the demo we'll bring on ders fertile Ruud onto the stage Andres is a member of the project builder team so let's get started by importing our codeword project so the first thing we're going to do is fire up code warrior and open up this project this is a sample project that you can get off of Apple's website it's provided by the developer tech services people and it's a simple little application it actually ships with both a code warrior version and a project builder version we've thrown away the project builder version so that we can show you how to do the the importing so first of all let's go ahead and make sure that the checkbox is checked for the relative paths and once we know that that's all done we can go ahead and from the file menu just choose export project and this is going to save an XML file and we'll go ahead and put it in the actual folder that the project is in so now we've generated this XML file okay now we're done with code warriors so let's go ahead and get out of code we're and go to project builder and we can choose import project and you get a choice of what kind of project to import so we're gonna import a code where your project and then we just have to point it at this XML file so okay and now we're done we can just go ahead and let the import happen you'll notice that it imports and we get all the groups so we can go ahead and check out and make sure all the files got in there okay now actually I'm a little bit lost on the demo script here so yeah so now with when code warrior builds this thing it's going to build a path binary and so it links against the carbon Lib libraries and we're gonna build a mock OH binaries so we're gonna go ahead and get rid of the libraries that came over from code warrior and we'll add in the frameworks we need in a moment but first let's go ahead and look at the target that got imported and you'll notice that in code where this target was called something kind of funky so maybe we should rename it to be something a little bit more reasonable okay and also if you go to the build settings tab the the application that code warrior was generating has this weird PPC in parenthesis after it we don't really need that so let's get rid of that and okay now let's actually go back to the files tab here and make sure that we are linking against the frameworks that we need so first okay we have this Mac libraries group let's go ahead and rename that to be frameworks and then from the project menu you can choose add frameworks and we'll go ahead and find the the two that we need then this example uses carbon and QuickTime so we'll get the carbon framework and the QuickTime framework and add them in there make sure that they get added to the target and you'll notice that they appear there in the framework and libraries build phase of the target so for this example this is actually all we have to do now we're ready to actually you know build the things so let's go ahead and build it make sure that it actually works okay it's built go ahead and run it just to make sure so this example all it does is it takes a screenshot of the screen it lets you you know scale it and it actually lets you save it which will you know show a little bit more of later in fact when you save it it saves as a picked file interesting so that was not part of the demo script right so as shipped from Apple this thing saves screenshots has picked files and we thought well maybe it would be nice to be able to save as a tiff file so in order to do that first we're gonna need some Tiff's handling code so what i did as i went out to SGI's website and i downloaded the free tiff library that Sam Leffler wrote which is sort of the standard implementation of the tiff library and what we're gonna do now is actually import that tiff library into this project so that we can build a library that handles Tiff's and then we'll make the app link against it so again to get started when you're gonna import a bunch of raw source code it's best to create the target that you want first so let's go ahead and create a new target we're gonna build a static library here so we'll create a library target let's call it limp if dot a and when the target gets created why don't you go ahead and close the build tab up there too so that we can see more it has no files in it but that's okay because we're gonna add the files right now actually before we add the files let's go ahead and look at the build settings tab of the target and make sure that everything is okay there so the thing is going to be named Lib Tiff's dot a and actually let's go ahead and set it to install in slash applications not the library you know what you're right never mind so let's go back to the snapshot target actually and do that so this illustrates that even if we make a mistake when you first start you can always go back and change all right there we go we're gonna install the lot of the application in slash applications and okay so now let's go back to the to the tip target so that we can see all the files as they get imported and we'll switch to the file tab and then go to finder okay can group these guys let's group those together that's a good idea so we'll go ahead and put all of the source code for the snapshot stop into its own group so that it doesn't get confused with the TIFF source code now we have a library or we have the folder with all the source code here and finder and we can just drag that in you get a few options here let's go ahead and have it copy that source code into our project and we'll tell it to recursively import all the contents of that folder and we'll add it to the lid piff target that we just created so all that stuff comes in and you can see that it's all been added to the build phases here we have actually made some minor modifications to the source code we got from SGI the only thing that we've done is we removed some files which are used only for other platforms just to avoid having to get rid of them once we've imported it here so now we have a target that builds the tiff library and let's go ahead and build it just to make sure so we make the active target be the new TIFF target and go ahead and build now this is actually going to take a moment because this library has a lot of files in it and we'll see that it does have some warnings if we were going to be conscientious about things we might go in and fix those warnings but we'll let let that be for now so still building if you did want to fix the warnings of course you can just click on the lines and go to the code and figure out what's wrong so the build stuff the build is done so okay let's go ahead and close up that build tab the last thing I'd like to show in this segment of the demo is we'd like for the super snapshot application to link against this TIFF library so to do that we can go back to the target for a super snapshot and if we go back to the final stage again the products group is sort of special that has a reference in it to each thing that is built by your project so every target you add will typically cause something to be added into that products group and you can see that we have two things in there the application and the library that that we're building with the TIFF target so one of the reasons why this is available is so that you can actually establish a linkage between the different target products so to link against the lib TIFF target we can just set the active target to be in snapshot target and then click in that left-hand column and it will that library will be added to the snapshot target in the frameworks and libraries phase and when we build the snapshot target the next time it will link against the library now one more thing that we actually should do just to be complete is in the targets tab we can establish a target dependency so that every time we build the snapshot target we'll make sure the first build the tiff library so in case we didn't build the TIFF library first we can still link against it because it will get built automatically so now we have a complete project here and we'll use this as the starting point for the rest of the demos in the session but now let's have onder's talk a little bit about build styles okay let's go back to the slides taken like so if we could have the slides back on the screen please move the mouse pointer a bit here okay okay so now we have a project that had the sources imported into it and so we can build it and what I'm going to talk about now is the feature we call build styles and this is a feature that we added to help you maintain your project in the long run so what is a build style okay so the basics of a build style is that it builds a allows you to build a single target or a set of targets in many different ways so if you have one logical product that you want to build let's say one application but you might want to build it for profiling for debugging you might want to try it out using a hash table or a linked list algorithm whatever you wouldn't want to set up lots of different targets and have all the same source files in all those targets because then as you maintain them if you had a source file you have to remember to add it to each of those targets if you change the build setting that should not change between the targets you've got to make the change to all of them so so the build style is just like a filter that gets applied on top of the target settings at Build time so here are some examples of that you can enable disable features experiment with different algorithms different optimization levels etc okay so how does this actually affect the bill well the basics is that a build style it changes the settings of the target dynamically so it doesn't actually modify the target it just allows you to pick a different set of settings to apply on top of them at Build time and a targets build settings like optimization level and what flags to pass to the preprocessor that's just really a dictionary of settings and so even if you check a checkbox or choose a menu item from a pop-up in the target editor what you're really doing is just changing the contents of that dictionary so a build style just selectively places where it pens to some of those entries so we see an example here debugging symbols equals no that would replace the setting that was defining the target if a build style has uh sequels that means that it actually just depends to the value of the setting in the target and one very useful thing is that one build setting can refer to another one using a syntax that's fairly should be fairly familiar to those who have experience with make so you can say a equals dollar B for example right to refer to the value of the build setting called B now obviously the build style can refer to the target settings but also the target settings can refer back up to the builds to the build styles so it's actually fairly flexible and it's possible to configure your your settings to do a variety of interesting things the one thing that's not permitted is circular references right you can't define a build setting in terms of itself because what would that mean so since we have these different layers of settings you know the targets the build styles we need a precedents for that so here's here's summary of the precedents the very highest level are the settings passed to the PBX build command line build tool now if you're running the IDE there are no PBX build settings so that part just goes away but this says also intuitive to those using make anything you pass on the command line to relocation will overwrite anything else anything that's not defined there the build system looks in the build style that's in effect and if it's not there it goes on to the target settings etc so by using this precedence you can set up some really interesting at configurations that like to just switch the build style and give very very interesting behavior changes and okay great so now we configure the build styles but how do we actually use them well currently the IDE has a pop-up that you can put in your tool bar using the customize toolbar command and that's a pop-up that's very similar to the target selection pop-up the one that chooses the active target this one sets the active build style and the IDE currently always has one build style active so you can pick any one you want say development or deployment and just when you click on the hammer that's the build style that gets used you southern in the demo actually sorry you saw that for the target but it works the same way for the build stone you see that next time now the PBX build command-line tool is a little bit more flexible than that if you don't specify any build style then none of the build styles have any effect and the settings defined in the target are the ones that they can used but as we've seen the second example here you can build for install for example you can specify by name the deployment build style now you could call that anything you want so you could add as many build styles as you want and the last example here just shows that the active build style that was set in the target and in the project is a per user setting and so you have access to that from the command line if you use PBX build so you can just say the last one says use whatever build style was active in the IDE when added at this project can be handy and by default new projects get to build styles just to start you off there's deployment and the development build styles and so development is is by default set up to enable debugging symbols and and to let you basically have a debuggable build the deployment one is when you want to build it for putting on a CD for example so that would turn off debugging symbols have a higher optimization etc but you can add any number of build styles to your project so you can just define anything you want to we're gonna see in the demo definition of processor preprocessor macros alright so I like to my christian mullick up onto the stage and we're gonna do a little demo hopefully I'll remember the script okay great so first of all what we're gonna do is we're going to configure the targets that we have the two targets super snapshot in Lib tiff to turn off debugging symbols because we want the default case to be build for CDs in this case so Christians gonna open up both of the targets here and we just unchecked the generate debug symbols checkbox for each of those so now if we're build without any build style at all then we're going to just going to build for putting on a CD so now in order to be able to set the active build style we actually want to customize the toolbar here so we want to go ahead and yeah just go ahead and control click on that say customize toolbar we just dragged up the build style active build style pop-up just drop it in there and click done we don't put it in there by default because we want to keep the UI and the concepts a little bit simple when you first start out so it says no build style since we don't have any defined yet so let's divide some bill styles so let's go ahead and go down to ya build styles and create a new build style just call this development okay and if we click on that the development build style we can edit it now right now we don't have any graphical UI for any of the settings we're planning on adding that but what this gives you control over the exact dictionary of settings that are available let's go ahead an add one that's called debugging underbar symbols and so you just click in there and hit return and that adds a new one and you tab between the fields so debugging symbols let's set that to yes because we're doing development and let's add another one and this one is going to be other C flags which is just a bucket where we can put any other C flag we want to pass to the compiler actually see flags yes I just double-click on that right and we just up the value to be - capital D debug so this is just going to define the debug process or macro so now if we click on the equal sign there you'll see it turn into a plus equals maybe you don't see that there we go it's a little bit small but you see that when you sit in front of the screen and what that means is we're just going to open the value to the end of the value that was defined by the target okay great so now we have the development build style setup let's go and create deployment build style and to start off we're just going to select all these settings here you select them both and they were just going to copy them so you can actually copy and paste these settings between the different build styles let's garden crane you build style called deployment actually I take that back let's call that save as tip because we imported the lib TIF library and so one of the things we want to demonstrate here is defining a preprocessor macro that causes the source code to use the TIF library I've actually modified this super snapshot project to do that so let's cut and paste in the settings from the other build style and all we want to do now is just add to the value of other C flags - capital D and save as TIF okay so now we have defined our two to build styles we can see that they showed up in the pop-up menu up in the toolbar so we can set which one is active so let's go ahead and set the sets into the development one to be active go ahead and go to the files menu or files tab and click on super snapshot at sea so this is the file in which we've added some pound if deaths for save as Tiff's and Fergie bug so debug causes it to print out some extra stuff save as tiff causes it to use the tiff library when you choose save let's go ahead and just save this file to make sure it's dirty and hit build so now we're building using the development build styles so the debug preprocessor macros in effect and so if you run this and if we choose save then we should see some debug output hmm so just go ahead and say that and we see that it was writing a pig file okay great so let's quit that and then we're gonna go ahead and choose the other act of the other build style from the pop-up menu so now we want to build this using the algorithm that uses the Lib TIF library so we just cried and build again why okay so it looks more and it looks like this machine does not configured exactly the way the other one was configured so [Music] okay we can either spend a lot of time and install libraries here or we can say it trust us so you see the palette the if not to find save as TIFF there what's happening is that we're apparently using a quick-draw call that that is not in the public headers that's my fault so the point is though that because we got this error this time you've seen that the different build styles are in effect and in fact right which was the point of the demo so successful demo okay at this point this point I'd like to invite Kristian to talk some more about the build phases yeah you're a Christian which is another feature of the build system okay so what I'd like to talk to you but it was about how project builder organizes builds of individual targets in the build phases to make it easy to see and modify what's actually going to happen during a build so they seem a little bit complicated at first they're pretty simple actually though some fairly difficult and dangerous things can be done with them basic idea is that a target is built in a series of phases that do happen one after the other new phases can be added or deleted to tune exactly what's going to happen during a project build new files when they're added to a project to a target get added to the correct phases automatically so phases don't yeah you don't need to be conscious of them normally you should just see your files where you expect them and if you need to tune a build process you can go and touch them in their phases so files can be added to or removed from individual phases moved between phases or within a phase to different locations so the files will be processed in the order they appear in that phase as well as the phases themselves happening in order um so standard build phases that you see in target templates or in distributed examples or a headers build phase which is used for copying headers that are part of a distributed project into place currently some extra work is done during a headers build phase to make sure that those headers are available to other targets that you might be building or other targets in other projects that you might be building simultaneously next is the bundle resources phase in this phase all of your bundle resource files get copied into their appropriate localized locations as well as files that project builder is responsible for generating such as the info.plist property settings file and the package info file that goes in the bundle all get generated and copied into place during this phase during the sources phase is where the bulk of the work happens this is where new sources are derived from given source derivation and all your sources they're already present and the drive sources actually get compiled and put in order then during the Java archive phase a hierarchy is constructed which has all of your compiled class files as well as extra resources that need to be in the any Java archives that get constructed following that is a frameworks and libraries phase this is where the libraries that actually get linked to by a product actually are all listed and this phase actually builds the final executable and then finally the resource manager phase will actually go and add resource manager resources to a product potentially on a resource fork so it's got to be after the link so that's a good basis to start with but it's often not enough there are a bunch of custom phases that can allow you to tune the process in a bunch of different ways the most basic being the copy files phase this allows you to copy special product contents like readme and other such into a product it also is the primary model that we use for product inclusion so the way that a product that includes another product such as an application that has plugins works is that you add a copy files phase that refers to that product reference in the product section and brings it into the actual built product finally there's the script phase this is the most general mechanism where by default shell is run but really any utility can be run during a build so this can be used by default shell is invoked but sea shell pearl Apple script can all be used to do various things during a build so those are build phases might be interesting to actually see these and if I can get a viewing help me work a little more with this project so the first thing that I'd like to do is show you the actual phases that are in this downloaded example you could open up the snapshot target and go to the files and build phases tab so there they all are one thing about this is we're not building this with a bunch of other targets and the headers and all that interesting for the application itself so let's try just deleting that phase to clarify what's happening during the build that's better so more important is getting extra stuff into the build a simple thing to start forth first is adding this in app a readme to this application and I think it actually came with one that we could add to the project it's the level of bill there it is and yeah we're gonna add this to no target to begin with so what we want is a copy files phase added to this easiest thing to do would be to select the last phase and add a copy files phase from the project menu then drag the readme into the file section and we'd like to have this happen every time so copy when installing isn't necessary and that should go into the wrapper of the application so if someone actually looks into this built application the first thing they'll see hopefully is this readme okay so there's a simple copy file phase let's try something a little bit trickier what might be interesting for this example is to actually distribute this custom TIFF library that we built so maybe someone else can get it's a beast if so let's make another copy files phase and drag the lib tiff product reference into it this isn't really useful to us when we're just doing normal development build so we're going to do this only when installing and we're going to give this an absolute location because it's a library we're going to put it in local user local Lib standard library distribution place for a technical issue this means we're building a route for distribution where we're gonna have user local Lib and slash applications rather than just the drag and drop install application presumably because we're including the library it's for developers anyway so and actually would be nice to have to read me in any case even if a build fails part way along the way so why don't you drag that phase to be the first thing that happens so even if the compliation x' don't go well we're gonna have a readme and whatever we end up with so copy files phases are one thing but more interesting are these script phases that are completely general so let's add one to the end of the actually it's add it to the end we've actually got a few scripts ready to go in some stickies I think the first one we're going to put on is a accumulating log which we'll put in an entry for any given build that we do saying exactly what got build and I believe what style was used for the build this is gonna use shell for this and it's gonna run with every build now let's try something a little bit trickier even still add another shell script phase and this one what we're gonna do is on the case of install builds and we're doing final builds for distribution what we'd like to do is see them in the finder so that we can go and immediately check them out and see what the user would see just to make sure that they're right so this is going to use shell to invoke an apple script that'll raise the install builds location in the finder for us so that we can go and take a look at this and because this is really only interesting and we're doing full builds we're gonna make this happen only when installing so there's a bunch of custom stuff let's do a normal build in the PD UI of the application target to up let's change rails yeah you're gonna have to change the build phases our style that works pretty quick now if we can show that in the finder okay so what are we looking for let's see there there well there's the build on oh so we created to build on we did get a build log interesting that's a start the perhaps more interesting would be to actually take a look at a final deployment build which will invoke all of these build phases so if you could bring up the terminal window ooh and crank up the farm big enough dagger thinking oh here we go all right enough and I believe that's in the project rectory so if you do a px build install with BST root set to slash install so this will do a deployment build in that / install location and you can see those build phases are happening quickly in the background and the finder did raise with a copy of our route inside the Applications folder you should see the actual built application and if you use ctrl click to look inside that wrapper we should be able to see that readme there it is let's build faces with that I'm gonna turn this over to Dave who's going to show us a bit about how to do legacy targets all right so back to the slides [Applause] okay well you might wonder why the Java debugger engineers talking about legacy targets and you know what I don't really know so but it turns out it's kind of fun because I get to show you how to package your final application the way we want you to package the application and that's in a disk image so okay legacy target well the basics of a legacy target are that they are used to invoke custom command line tools so as Mike said earlier in the talk I mean the most common thing you would do probably is use it to call out to make or something maybe for an open-source project but there's lots of other things you can do with it there's lots of other build tools out there ant being one of them well you can also use them to create to generate source files that are used in other targets or to do some pre or post processing on targets and of course you can run anything from a legacy make file target so to do just about anything an example of some of those other things you might want to do well package disk images that's what we're gonna do in this demo you can also do build statistics you know log log statistics at the end of builds or send out notifications after a build like sending an email or something like that and let's see and with that actually we're gonna bring Mike back up here and just show this okay so if you have the demo machine right well the first thing we're gonna do is bring up the shell script that we built up for this that does the creation of the disk image so go ahead and find that out in the finder and bring it into the target we don't need to add it to any target or bring it into the project but don't add it to a target if you take a quick look at that why don't you close up the so I don't want to go into detail in here there's a few commands that are sort of interesting and you can find documentation on on the system for with man I believe man pages but HDI util and HD ID and there's also make FS underscore HFS that actually creates the HFS volume inside of the disk image there's an article on how to do a lot of this stuff on step wise which I recommend okay so let's go ahead and create a new target a legacy make file target and we'll give it a nice name so that we know what it is and let's go ahead and put this at the top this is actually going to be the main target for the project because it does the final processing that's involved in building this this little demo here and go ahead and make the other targets depend on it so so now when we actually build that target it'll make sure all the other targets are built first so okay well now let's do the real work actually the real work within the shell script but so let's change the build tool here to actually be been SH so that it does run a shell script and we'll go over to our stickies and drag in the command line well and this command line all it does is it's creating an 8 megabyte disk image I was a little lazy writing the shell script so I didn't actually come pyew how much space it would take and it's going to name the disk image snapshot and copy in the application itself so I think that's it shall we build it let's build it you'll see down here that it's actually echoing some stuff about what it's doing to create this disk image yeah copying files it actually compresses the the disk image too so you don't really have to worry about creating a disk image that's too large because the final disk image will be quite small so we'll go actually to the project directory right because that's where we decided to put the disk image and there should be in snapshot and double click on it and it's mounting and disk copy no surprises there and look there we have a disk image and an application inside it that you can just launch and run ok and with that back to Mike ok so let's have the slides back for a moment here all right all right so we've covered a few things today and I just want to sum up basically you know project builder provides a number of ways to import code into you into project builder so that you can begin using it if you already have an existing project and code war area or in the old project builder you can bring those in directly and as we saw it's pretty easy just to import a whole wad of source code that you got from wherever you know the build system we've tried to make it flexible we've tried to give you all ways to customize the build process to do things that we didn't necessarily anticipate and to give you basically ways to solve problems that we haven't solved yet now this is not to say that we're not planning on solving a lot of these problems eventually it'd be nice if you didn't have to write some gnarly shell script and set up all this legacy target just to build a disk image and I think we can expect to see project builder do a lot of these things more automatically the point is that until we get around to doing this you're not totally stuck so that was the main point of the session today and at this point I will ask God for you to come back on stage and we'll go through a couple of these info slides and have a little QA pretty amazing stuff I think we're gonna get a lot of a lot of use out of project builder with you guys can we have the house lights up we're gonna start a little Q&A session while I talk over the information slides these are these are our information addresses the top one is our tools page we list all Mac os10 tools available there we have a special page for project builder project builder pages include updates so as new things happen as new details occur as press events and other other things come to come to the public we've put them onto that page we also have a series of mailing lists that we host the URL there is the master massing mailing list page and the three project builder users cocoa developer and Carbon developer our mailing lists that are in heavy use by our community can we have all the Q&A presenters up on stage please this is the roadmap for sessions through the rest of the week starting at 10:30 we're talking about Java development tools over in room a 1 and tomorrow we do compiler technologies on Apple performances tools in this room I hope to see a lot of you there again and then through the week debugging on Mac OS 10 Friday morning very important our C++ frameworks group and our feedback forum on Friday hope to see a lot of you there and if you need to contact me or the engineering team here's two addresses my address I'm the technology manager for development tools always interested to hear your feedback always interested to hear what your needs are what your product needs might be that that need interaction with the team and the Mac OS 10 tools feedback mailing list is a place where you can send product enhancement ideas you know general questions that you want to go to the engineering engineering team itself you