WWDC2004 Session 309

Transcript

Kind: captions
Language: en
please welcome Xcode lead engineer on
ders Bertil rude hi I'm and Ursula dice
code lead engineer as you heard on
previous session we saw a couple of ways
of increasing the productivity of Xcode
clicker works yet we saw how to increase
productivity one when navigating your
project in particular with the detail is
finding the right files the files by
name and by content that kind of thing
we saw editing how to get productive
with that sauce some source code
management how to use documentation
workflows I kind of thing so this
session would i'd like to do is to dive
down a little bit on the build system
and we can take a look at some of the
ways specifically have increasing
productivity when building your projects
in xcode so let's take the hood off so
we're going to cover is we're going to
start with talking about the xcode
project model just brief summary we've
talked about a lot of concepts in all
these sessions like targets and files
and build phases by kind of stuff but
sometimes it can be a little bit tricky
to keep it all straight so i just want
to give real basic and talk about some
of the concepts real quickly and then
we're going to talk about optimizing to
build performance some of the things you
can do to speed up the things that your
projects already doing so the kinds of
builds that you already doing on your
projects then we're going to talk a
little bit about how to automate some of
the common tasks then maybe things you
are doing using finder or the command
line that we can actually set up to be
done automatically maybe even at night
using an automatic script to run so you
don't even have to worry about it so
we'll talk about this we'll start with
the project model so Xcode works on
projects right so a project what is a
project well project is basically a
container it contains references and
files so these are files and folders on
your disk and it doesn't actually
contain the files themselves right the
files just live in two
is you can access them using the
terminal or finder we just have
references to the file the project also
has targets and these are the blueprints
for the conceptual products that you
want to build so your application your
library your plug-in that kind of thing
there are associations between these
file reference can belong to a target
and as just as there can be multiple
targets a file can be part of one or
more targets in particular we see here
this single file reference is actually
part of more than one target so this
could be the case if you had some shared
common code let's say you're doing a
client server maybe there's a header
file that they both use to get access to
things like default port numbers stuff
like that you also notice that we can
have file references that are not
actually part of any target at all and
well what are these useful for well you
know maybe you want to have a to-do list
or you have read me or something like
that some people actually use xcode to
manage the recipe collection and
admittedly most of you actually have
projects that build products so for use
this would probably be a to-do list or
something like that so another thing
that we have in a project is
dependencies between targets and this is
fairly logical right if you have a
library in an application you want to
make sure the library is up to date
before you try to build the app fairly
simple we also have build styles and
we'll get to those little bit more later
but they're actually a separate entities
in a project that's get applied to a
target dynamically when you build we'll
talk about that in more detail there's
another case which related to a question
that we had just recently from the
previous session you can actually have
one project refers to another so in this
case we still have the first project as
file references targets as usual files
belong to the targets nothing special
there the second one is files targets
files belong to target and there's the
dependencies between the targets within
a project but there's something more we
can do we can actually add a project
reference to the first project in which
case we have a link to the other project
so now the first project that one of the
lot
actually knows about the project on the
right and therefore we can set up
dependencies between the targets between
the different projects so this can be
very useful we still of course have the
build styles and they can actually apply
to builds of the targets in the
secondary project will go into that a
little bit more so we talked about
targets well what are these targets that
we talked about application and library
and those kinds of things those are
really product types the types of things
you want to build the party types more
refer to build systems so we we have
this dependency layer that goes between
the targets those are the red dashed
arrows you saw on the previous diagram
so you can have your application your
library etc but each target can have its
own build system and so we'll see how
this can be useful the first kind are
native Dart right this is what Xcode
really shines with this is where the
dependency graph is maintained
continuously up to date internally so we
can show nice up-to-date information
about it native targets currently
support applications frameworks
libraries plugins and there is project
level support for multiple OS SDK so you
can be on Panther and you can build for
tiger for example they provide the best
integration of the user interface but
sometimes that's not feasible so
sometimes you have other kinds of
targets you want to use so one of the
kind are what we call external targets
and the icon here is a shell command or
a command-line tool icon because it
actually lets you invoke any command
line tool at all and you can typically
invoke things like new make or aunt or
those are those kinds of things
typically they're used if you have maybe
an open source project or a project that
sets this cross platform but you can
actually invoke any script or command as
we'll see a little bit later on a demo
Xcode also supports project builder Jam
style targets so that for those of you
who have projects and projects builder
there was a separate command line tool
called Jam stands for just another make
and that's what there was an external
tool the pipeline for the information
between
IDE and the build tool wasn't that great
so that's we have native targets but the
jam targets still support everything
that they did in project folder we did
this specifically so that you'll be able
to transition your projects from project
builder tax code very easily it's a good
idea to convert to native targets
there's a menu item for that the only
thing not supported as native targets in
xcode 1.5 our java targets or working on
that and the architecture of xcode is
actually fairly flexible so in the
future we plan to allow you to plug in
customized support for other kinds of
build systems if you want to we don't
have that yet we're hard at work on that
when we're not doing presentations for
WBC so that's a little bit about target
types so these things are these things
determine what gets built but how do we
determine how to build it but these are
the build settings right so they control
the inner workings of the build they're
like the properties that you make
variables analogous to that so their
individual properties one settings value
can actually refer to another one this
is someone powerful you can define a
setting that has the path of a common
directory and then base everything off
of that for example the install pass can
actually refer to dollar home turns out
that home is one of the build settings
that gets inherited from the environment
so that can be kind of nice build
settings are passes environment
variables I mentioned external targets
we passed that in the environments if
you have an external shell script or a
new make target or whatever they will
actually have access to that of course
for native targets it doesn't really
matter there is no external command to
be called build settings can be set at
various levels will see that shortly
they're usually set on a particular
target because that's the most natural
place to set a preference or a build
default is on the product that gets
built and there's an ordering it's the
build settings so that your customized
values override the defaults and build
styles override to target values etc the
higher levels override the lower levels
so what are the levels well here's the
president
at the bottom we have the inherited
environment variables these are the just
the basic things like like the homes
variable that come from a terminal if
you're purely an ID user you probably
don't care so much about this after that
comes a built-in default settings
there's a lot of these right these are
all the set all the default settings for
all the compilers or linkers or whatever
you have installed so whether or not
optimizations on or off by default that
kind of thing above that are the target
setting the build style settings come
above that we'll talk a little bit bit
more detail about that and above that or
the command line setting for what's this
well for the IDE itself this is always
empty this is always a moot point but it
turns out you can actually build a
project from the command line and that's
where this gets useful you can override
any setting at all from the command line
when you invoke what's called Xcode
build to build your project from the
command line the environment variables
we talked about these get inherited the
built-in default so the linker settings
that kind of thing that the default
values target settings are real
interesting so we're going to drill it
down and talk more about those you set
the target settings in the build tab of
the target inspector as a target info
window so we see the little red red
circle there how you get to that and
that opens up this panel and here we see
the settings it's just list you saw this
in the previous session shows the
inherited default values as well as
anything you've customized anything
YouTube customized is showing bold and
the inherited ones are are not involved
also I mentioned the build settings
there's anything set in the build
setting Trump's the values of lower
levels so we show in strikethrough we
show the ones that are set and build
settings in in in built out so this
indicates that the dead code stripping
setting is actually overridden in the
deploy in the current build style
something else here is we have a pop-up
menu that lets you focus on category of
build settings I think this was shown in
the introduction Xcode but it's worth
pointing out again that you can actually
click on that that table heading there
and
and narrow down your your focus and of
course we have the search field which
lets you find any setting that you want
quickly and this match is not only
certain not only the name of the setting
but also we searched in the help string
for that setting so if you type in if
you're not sure if you can't find a
setting you're looking for try typing a
phrase related to that into the field
here okay so much for target settings
that's pretty simple so build style
settings we'll talk about that these
guys have said in a similar manner they
left some variations on targets so the
bug versus release app the pro version
of the app versus a demo version let's
say they as I mentioned the build sells
override anything at the lower level
some examples of how to use build styles
you can for example build with without
debugging symbols this is fairly obvious
you can build with zero link enabled or
disabled their link is feature that we
use a development time but we really
don't want to use while we ship with
product different optimization levels
pretty easy alternative rhythms suppose
you're trying out some new hashtable
algorithm you want to build one
variation of your apps with the old
algorithm one variation with the new one
and just in performance test let's say
you can enable/disable features if you
do a demo version of the app you want to
disable save and with a good stripping
the codes going to get removed as well
that's a feature that's new to 11.5 you
may want to set different build output
paths so that you have your debug builds
object files going to one place and your
deployment bills going to the other
place so why don't you tell multiple
targets right i mean we haven't already
have separate targets well you could but
let's consider an example right so what
if i have an application and let's say
that i have a demo version of that
application right so all we do there is
we set a special bound to find that
turns off saving okay let's say there's
a support library that they all rely on
but actually so I've been doing
development for a months and so let's
see okay well what I've actually been
developing is my is my debug version of
the thing right so now it comes time to
deploy well I want to optimize better
want to maybe turn off some debug
logging that kind of stuff so I really
have another version of each of these
targets and then suppose I want to have
yet a third style where I say well let
me try that new hash algorithm I still
want to have optimization on so I can
really do the performance testing so now
i have really yet a third set of each of
the target so all told I have nine
targets and really what I have though if
you look at them is the combination of
three targets times three variations on
each week or less fees and to build
styles we get rid of these so what we
really have is is and the plus n as
opposed to end times then so build
styles of multiple targets right you can
use multiple targets and just ignore
build selves that's fine but they're
there and especially helpful for large
projects so let's talk about how to set
those the settings there we go to
actually the project if you notice what
selected here is the project icon up at
the top build styles are attached to the
project not to each target so we inspect
the project and that's where we see a
list of the build style so this is in
the Styles tab if you notice at the top
the four tabs I've selected the Styles
tab and there I see in the pop-up I see
all the styles that are available and
the window looks very very familiar
right it's the same thing that we see in
the target inspector just now we're
editing a different level of the
president's
one in important thing or one important
way to use the build Styles is to only
define the things that are unique about
that style so if you have some setting
that really is common to all the styles
as the same value for all the styles
odds are that it's not really part of
the variation so that that's one thing
to keep in mind one interesting thing is
that you can actually refer to the
overridden value you don't actually have
to obliterate whatever is defined below
you can just append to it so if you have
a bunch of preprocessor macros you can
say dollar parenthesis value and for
capture the overridden value and then
just add to it that was a little bit
about build set build style settings
there's more and that you in the
documentation can reach from the
distinct help button there again we
talked about the command line settings
these are for use by could build I'll
talk about that a little bit later
another thing that native targets have
is build rules and these are just like
the rules that you would define and make
or any any language like that right they
control how source files a process and
every will consists of a condition and
an action and the condition matches on
the kind of file that you want to
process so the first matching rule is
used and what you do what xcode does is
that it matches on either file types so
this is the abstract file types such as
all see like language files which would
include C C++ we could see that kind of
stuff or you can match on specific
patterns the filing pattern matching is
particularly useful if you have
something like you custom extension for
custom file format let's say you have a
unique image file format that he use
you're developing a game you can set up
a rule that will take files with type
suffix and pipe them through some
translation tool that compiled the image
or whatever so they can load faster into
your game that's just an example you can
use them to select the compiler
inversion for example GCT 35 there's a
preview of that in your onto DVD that
you got and you can use build rules to
select between GCT 33 and 35 the default
is 33 but
you can you can easily just change the
pop-up to select 35 another example is
Java C vs jokes and as I mentioned you
can also use them to generate translate
files or even generate custom source
code the outputs of a build rule or
pipes back into the Builder old
machinery so you can generate some
cascading rule applications in sweat you
headed to build rules using again the
target inspector you go to the rules tab
this time pretty pretty obvious if you
hear that you can define you can use a
custom script if you want and there are
some macros that you can access input
path output path for the name of the
file being processed again the the pink
question mark icon there is your friend
when it comes to help about what what's
going on here as we see here the system
rules are defined down below and the
custom rules are above if you remember I
said the first matching rule is used so
custom rules at the target level
overwrite anything at the system okay we
have a fairly extensive set of built-in
types that extra recognizes and you can
notice at the bottom those wells pretty
low but the ridge the last item says
source files matching that's where you
can type and let's say start out to so
that's the condition the action shows
all the compilers and translators that
Xcode knows about and you can also type
in a custom script in any scripting
language you like that's a little bit
about build rules as i show you can
define actually what the output pass is
going to be the ties into Xcode
dependency analysis so your script is
only run if the inputs are newer than
the outputs okay so let me show a little
demo just and show her some of these
things are grab the demo machine please
Thanks ok so I have here a diversion of
sketch and what I wanted to show was a
couple of things in so many of these
demos you know just kind of opened
something and build it and shows that it
builds I figured I'd do something a
little bit different and actually show
you just where the items are some of the
more commonly asked questions so one of
the big ones is if you select the target
the project icon up here and then say
and so that's how you get access to the
style but not underneath the targets the
target has its own setting so we can
expect that to write and actually I
inspected the target smart group which
has nothing but I can select each target
and show that but again the project is
what has styled if you notice here there
are a couple of items that are in bold
these are overridden I've actually here
I've overridden the the output location
for both the intermediates and for the
products and so what's going to happen
here is that when I build with the
development build style it's going to
put everything into a subdirectory
called debug if you build with the
deployment it's going to put them just
into the default location so that's
really useful this is also where you can
define new styles up here in the the
project inspector and name your own
build style that kind of thing you can
obviously edit build styles and delete
them in that kind of stuff so one other
thing that I wanted to show is that when
we have stringless settings you can
actually you can actually edit the value
using a sheet now and if I can find one
let's say a preprocessordefinitions can
narrow it down there preprocessor
defines i can say edit setting and i
actually get the sheet to edit
individual list items in here so i can
do do that if i choose one other thing I
wanted to show is the build rules again
here's the rules editor now this is
notice again that this is at the target
level so each target can define its own
rules here are the inherited ones and I
can also of course add my own rule and I
can choose whatever
I like here okay one thing that you may
find useful is you notice I can only
select the target up here we actually
have another pop-up menu they can add
you toolbar if you end up using build
Styles a lot like I do for example you
can actually just add another pop-up for
the build style and so the way to read
this is ok I'm going to build a sketch
target I'm going to build it with either
for either deployment or development and
that can be fairly fairly handy thing to
do so just a little overview of this
could we go back to the slide please
okay so we talked about the project
model a little bit that was or a quick
introduction or a quick refresher looks
like really about optimizing bill
performance before you were here
increasing productivity with Xcode so
speeding up the bills well what occurs
during a build expert has a fast
powerful build system and it keeps a lot
of information internally so some
features are automatic we talked about
the dependency analysis that's always
kind of being updated in the background
so that when you hit the build hammer we
already know what's up to date or not we
talked about parallel builds if you have
a dual cpu machine xcode automatically
takes advantage of both cpus zero-length
these are all things you've heard about
predicting compilation you may not have
heard so much about we'll talk a little
bit more about that the basic idea is
that we can start compiling while you're
still editing your file so that by the
time you save your file and you actually
hit the hammer we're done compiling it
and that works really nicely when you
especially when you have single file
turn around so those are some automatic
things there are some things you can do
to optimize your project one of the
biggest things is to add a precompiled
header Xcode comes well Mac os10 comes
with a lot of SDK is a lot of headers
and there's just a lot of declarations
that the compiler has to see every time
it compiles a source file so we can we
can speed up some of that work by doing
it only one another big thing is
distributed builds I'm sure you've heard
of this too maybe you don't know quite
how to enable it
I can figure is that kind of stuff we'll
talk a little bit about that sixty
continue is another thing that you saw
in the introduction sessions how many
people are actually used then Wow okay
try it out it works most of the time
there are some caveats that other
sessions have gone into to change the
size of a structure that kind of thing
basically patches your code while it's
running so you don't even have to quit
and restart the app and it can be really
good at really a time saver but let's
talk a little bit more about the compile
at a compiled debug cycle so let's say
we're editing a file that's it takes
some time right and then we have let's
say we edit for files we end up this is
the slow case we end up compiling each
of the four files and then we link and
then we start the program so one of the
things we can do as I mentioned here's
the timeline that this all takes one of
things we can do is set up a pc h a
pre-compiled header this cuts each
compilation down to a fraction what it
was so we shorten the overall time okay
that's pretty straightforward another
thing we can do is to use your link to
enable that during during development it
is enabled by default for development
builds so that cuts out the link during
development so now we've shortened it a
little bit more still we have the CPU
marching through each processor like
that I'm just compiling it and then
finally we start the program so let's do
it in parallel we have a dual cpu we can
have each GPU actually going through
compiling and we're done in a shorter
amount of time but we can do even better
and suppose instead of just using two
cpus we used one of ours or two of ours
to take the data preprocessing somehow
send it out across the wire to other
machine but those compile the files and
send the results back and then we just
harvest the results so that shortens the
time and that is great for large bills
especially when you have lots of files
suppose we just take the single file
case
just go back to that so we're still back
to the one file even if we have dual
CPUs if we only touch one file there's
no point in having two CPUs we can't
really Carol lies we can just do that
one so one key observation is that
editing is not very processor intensive
so we commit we can actually make a
shorter box to indicate that and then
what we see is it can actually slide the
compile step in underneath the editing
meaning especially in a dual cpu if you
have to read you can be editing with one
and compiling with the other one so what
Xcode actually does to send down the
first part of the file and then wait
until you hit save and it sends the rest
of it so that shortens the compile time
and then the last thing is as I
mentioned six and continues we can get
rid of restarting your app entirely in
most cases so you can just keep on
patching the code in your wrap until you
find its unique change of structure or
do anything more significant like that
so it's a fairly short compile time
compared to we started out with soap
recompile headers so that yeah that's
that's nice graphic but how do we
actually do this well what you do is we
use the observation that most of the
most of the code is in the headers the
compiler sees the same code over and
over again analyst for using precompiled
headers one example I just found a small
one a little C++ file under developer
examples and this is the this is the you
carbon event TPP it's actually 54 lines
long and this is actually the whole text
of that file so it's a very tiny table
scroll spoilery but wouldn't be
interesting things here and expensive
ones is we see that it says import
carbon / carbon H so what does that end
up doing well it actually ends up
working the code that you typed because
this ends up being 9944 lines that the
compiler has to see so this is actually
not even to scale the grade line there
would have disappeared it's actually
point zero six percent of the code that
came from your project and ninety-nine
point ninety-four percent came from the
system headers so the obvious thing to
do is to create a precompiled header for
for a carbon that H so
you too d 33 and 35 support precompiled
headers and they're pretty easy to set
up an Xcode what you do is you create a
prefix header that gets implicitly
included in front of every source file
in your target it's a tapper target
level and then you just check the
checkbox that's a pretty compile this
thing exco to automatically figures out
which different versions of it it needs
to do for example if you pass different
preprocessor macros and different
headers it actually builds builds it
correctly for you keep in mind though
that prefix that are gets included for
every source file to target so it has to
be compatible with every source file if
you have people's plus an objective c
plus plus then you need to use pound of
steps appropriately there's a really
nice help page on that index code
documentation you search for PCH the
other thing to keep in mind is even if
you have a correct prefix header it can
get precompiled too many times if you
put changing headers in it so they did
the trick here is to put all the stable
code typically the system code which
hardly ever changes except when you
update the software you put that in the
precompiled header and then you leave
all your user code to be compiled every
time and the other thing I mentioned is
Xcode does pre-compiled the prefix
header on demand which means if you
change the input conditions so the pre
comp is no longer valid Xcode will
rebuild it for you so that's a little
bit about precompiled headers just
shortly about distributed build there's
some some questions we we get about that
Xcode automatically uses all CPUs right
the why why limit yourself to your own
machine there's lots of CPUs we only
ship dual CPUs but you could have a 14
CPM machine if you use all the other
machines and their offices next to you
the way to do this way to enable this is
to go to the Xcode preferences and there
are two things you can set or you can
set whether your machine should use
other machines to precompiler to to
distribute to and you can set up at the
bottom there whether your own machine
should be a distributed build server
something is to keep in mind it's only
available in the 33 and 35 that's a big
of an issue
for most of you who are on 33 obviously
the faster your network in the faster
your machines are the more benefit
you're going to have and it really does
require 100 bass-t network to be
effective because with the machines even
the powerbooks being so fast anything
slower than that it's also faster just
to compile locally than to send it out
and get it back the ideal number of
machines we found is between four and
ten that that's a very fuzzy number it
just really depends any project but it's
probably not the case that adding 200
extras is going to make it 200 times
faster than not having distributed
builds so there is definitely a fall off
at some point keep in mind the security
resource code this is concern for some
of you in that and not at all for others
there are two modes one is rendezvous
this means go out and find any server
who's willing to compile my code and let
it compile my code but that means that
you're sending your source code to that
machine so you make sure that that's
something that you want to do the other
option is to specify a list of servers
you could do that in the panel that I
showed you in the previous slide you can
actually just specify a list and if you
enable rendezvous it will actually show
you the list of the servers that are
within range and you can check off which
ones you want and limit the list that
way to let's say a set of secure
machines and a lab somewhere so we
talked about precompiled headers and
distribute a build 0 link this is fairly
automatic there isn't much to talk about
here except to observe the length time
is significant part of the turnaround
time and typically you're editing only a
couple of source files so the
interesting is saying here and where you
need to be aware is that it runs the
code directly from the object files it
does only work for applications and
command-line tools right now for
technical reasons the big thing to be
aware of is keep in mind it runs from
development from the object code so
therefore you don't want to do this when
you deploy your app the deployment build
style is set up to not use zero length
by default that you actually get a real
app that gets linked don't trip
interlink builds because it's going to
try to access the data
files back on your build machine if you
get this I know if you can see this but
basically it says zero line could not
load o file then it gives a path of the
data file that indicates that you took
the the binary stub that was built for
zero link and took it to another machine
and the binary sub is about 10k big and
it's all the old files are still back in
your old machine so that's that's a
symptom of that and the fix of course
turn off your link for the plant those
particular just want to mention a little
bit this is off by default so here's
something that you can do to increase
your productivity normally even the PCH
doesn't get used nothing happens until
you have build so here's the idea again
that we can get a head start by using
those idle cycles while you're editing
and start compiling we send the first
couple of town includes which typically
include include heavyweights like carbon
H or coconut H and get the compiler
really chewing on that stuff first and
then while you're still typing your code
the compiler is just sitting idle and
then when you say we send the rest of
the data and then when you have build
oftentimes the compilation is already
done and the data file is just sitting
there ready to be used so it effectively
essentially eliminates the compile step
for single editing even if you're
editing multiple files before hitting
run again if you edit them in sequence
it actually can eliminate the compulsive
entirely the ways to turn this on
there's a checkbox and the press panel
so that's all you have to do for that
it's automatic after that you're going
to show a little bit of that
okay what I wanted to show first here is
we inspect the target again see that I
have let me see here if I can find the
prefix setter there we go so I've said
here s Keith SKT prefix this is a
project roller path actually to a file
in my project so let's take a look at
that which type prefix can use the Handy
detail view to get to it all this one
does is include coco de h if you had
people plus in here this would still
work because of the guard macro that's
what i was talking about before the
precompile had reached exciter
checkboxes it is obviously the one that
caused it to be to be precompiled you
could have a prefix that or even if you
didn't want to pre compile it that's
typically not not very interesting zero
link is really does show up in the
target inspector because after all it
inspect all of the settings so if I
choose 0 here at cic 20 link actually is
overridden at the target level and the
reason for that is the difference
between the deployment of development
build so I go to the project and it's
back here if I go to the styles let me
narrow down again r0 link I'll excuse it
in the development style 0 link is
checked and in the deployments violates
unchecked so that that's really how you
want to do things another thing I wanted
to show here is the distributive builds
again we see normally under building
there's some some options for the local
machine distributed builds is the prep
pandas dedicated to to distribute the
build I don't have set up for
distributed bills because of the the
demo machines here but pretty obvious
what the settings do but I wanted to
show that this is the panel actually
where you get access to that because
sometimes forget questions well I you
know how do i set this up or do whatever
you can look under building there are
some interesting options one thing that
Xcode supports which is actually kind of
nice is to build through shared location
this is particularly nice if you have
multiple projects even
they're unrelated you can get all the
products to go into a particular
location it's also good if you're
working with source code off the network
and you want to make sure that your
binary is really on the local disk it's
a really good idea for performance the
predictive compilation is off by default
but and disabled by battery power by
battery power but it's really good thing
to be to be turning on we'll be turning
that on is the default and another
useful one is if you want explicit
control over how many processes to to
run on your machine we're limited to
three because we've really seen that it
can hurt the performance or the
responsiveness of your machine is you if
we launch too many compiles of once on
the same portable power book so it's a
little bit about that one other thing i
want to show actually is i showed how
you can set settings at a target level
you can actually set settings at a
particular source file level two you can
either navigate down into groups here
you can expand the sources phase which
are all the source code files for that
target or you can just see them here
keeps fact if you select sources you see
them all listed they all have check
marks because I built the project yet
this means that it needs to build one of
the things you can do is you can
actually select here and you can add
additional compiler flags and if you if
you add compiler flags to a particular
source file Xcode will take care of
generating another version of the
precompiled header for that if it needs
to so you don't have to worry about that
okay so just a little bit about those
kinds of things creative slides back
please thanks
so we talked about optimizing build
performance a little bit i just want to
show you where to go to set some of
these settings because of the questions
to get on the mailing list indicate
sometimes people don't don't know that
i'll talk about it really interesting
topic those automating some of the
common tasks we talked about how to make
the things you already do as do those
things in xcode faster but automating
common tasks gets into territory where
you may be doing something totally by
hand that you could actually automate so
what if some of the ways we can do this
well you can automate the build that's
one of the most obvious things and there
are a couple ways to do this one is to
use the command line tool the I'm
command line tool called Xcode build
I'll describe in detail you can use
applescript Xcode is scriptable so for
those of you know one love Apple script
we can use that and actually there is a
automator stage in an action that you
can use to build a project another way
you can automate your workflow in xcode
the build workflow is the set up custom
build rules I mentioned that I'll talk
about some more examples some custom
build phases have really interesting
uses that that I haven't thought of all
of them and I'm sure you can think of
many many good ways to use them they
were the external targets these are
really kind of opening a porthole into
the machinery so that you can actually
hook and anything that you like into the
build phase and into the build sequence
custom executables is another topic I
want to talk about this is sometimes
underused but can be extremely powerful
especially if you're working on
libraries and plugins we start with
building on the from the command line
the tool is called Xcode build and it's
in your default path so if you're
running from terminal you type Xcode
build it provides access to the exact
same build system as the IDE uses so
there's no sort of compatibility mode or
any of that stuff it's actually the same
shared library that's opening your
project and building it you can evoke
from the command line from the shell
scripts for example or directly from the
command line good for nightly builds
that kind of stuff the basic
implementation the basic
location to Xcode build and that would
just bring your projects at the date
whatever project you have to change the
working directory into but it has
several options one of those is you can
say what action you want I mean that's
pretty obvious you can remove your
binary so you can bring bring your
project up to date you can actually
specify which target you want to build
and this is obviously useful if you have
many targets I showed the target pop up
where you can choose which target to
build this is this option the dash
target option is actually the same thing
is that problem sets for too controlling
same with the build style you choose a
build style development or deployment
typically if you're building from the
command line even building for
deployments and you'll want to put the
results and installer package something
like that this is the same or controls
the same setting as the pop up for the
build style into Xcode ID and under the
hood it actually controls literally the
same setting so there's a high degree of
fidelity there you can also over at
build settings if you remember the gray
box at the very top of the president's
with command line options that's what
these are so if you pass any of the
command line options II just once that
you've defined or that are built in you
can just override that on the command
line this is kind of a new make style
use of the Xcode ide but it's it's nice
to have a command line tool like those
for the automated stuff so if you don't
want to use the command line you can
also use Apple script excursion
scriptable if you go to the script
editor and you say open dictionary Xcode
shows up in there and you can see all
the classes and commands p.m. not all
facilities are available from Apple
scripts at this time but we're working
on completing that rounding it out
project operations are you can set build
settings you can add files that kind of
stuff here for example it's just a
little line of Apple scripts that just
builds a particular target specific
current set of build settings so this is
another way that you could automate your
build process for actually going from
source code to file disk image that you
ship to customers so either or
custom build rules are a way of
automating inside of the projects as I
mentioned inside of each target I'm
repeating some of the same information
here but I want to sort of try to give a
couple of opportunities to and to help
you remember it they could the essence
is that a rule controls how the target
produces and processes the source file
so in action it's any script you can run
from terminal you can even use Apple
scripts you can use pearl Ruby that kind
of stuff obviously a normal shell Python
as I mentioned earlier the build rules
can declare the path that gets produced
the find output files so this gets
related to the input files by Xcode and
so your rule only gets run if the input
is newer than the output or if the
output doesn't exist and the produce
files are set right back into the
dependent into the rules system so if
you produce see files then they get set
back in and the rule for C files gets
applied and it could see compiler is
involved so that's fairly handy for
example custom scripts to generate see
files from whatever data files you have
in fact the tool that you used to
generate those see files could actually
be built by another target in your
project we've seen that in some of the
internal projects at Apple actually
other example uses pre-processing
generating code code you can invoke
compilers that are not directly
supported in Xcode we have a list of
some of the compilers that are supported
GCC is the the only c compiler with
built-in support there are other c
compilers and Fortran compilers and you
can use a rule for those custom build
phases are a little bit different from
rules the rules are conditioned action
kind of saying build phases are just
steps from the sequence to build your
product and so you can add them to any
point in your native target and the
primary uses are things like copying
arbitrary files for exam and running
upper tree scripts you may have UNIX man
pages you may have custom files that
going custom places in your applique
you can specify inputs and outputs and
again these phases get run only if
needed and the paths have fed directly
into the Xcode dependency graph so some
examples copying files and folders
that's a popular one a lot of people
have somewhat complicated applications
and they want to embed frameworks from
that kind of stuff you can set special
permissions on files we have a have a
little kernel expansion that kind of
thing that it needs some special flags
you can also install files in arbitrary
filesystem locations so that's what I
mentioned the UNIX fan page this is
maybe for more of the sort of typical
darwin development it has specific
places in the file system were files
need to go typical Mac applications
should be able to be run from anywhere
external targets I mentioned this early
on this is a way to call any kind of
external build system you have so you
can specify the actions in vogue for
build for clean all these things are
passed in the environment so you can
actually set your own options at the
target level and they get passed down
through the environment and if you have
a perl script let's say or shell scripts
you can pick up those settings and
modify the behavior of its based on that
so there's lots of opportunities for
weaving your own custom scripts into the
xcode build process here to really get
to it to a source to disk image kind of
workflow you can customize the command
line as i mentioned you can pass any are
any options you want if you have your
own script that you're invoking to drive
a part of the build system that's maybe
not so interesting because you've you
just change the script but suppose you
using aunt or or make you could do that
there are actually a project templates
to invoke the ant build systems are
installed as part of the the Xcode
install for java development so you take
a look at some of those four examples of
this sexual ok so other examples I think
I talked about these some of them
already make and yeah talked about this
package maker is actually another
interesting useful this we intend to
think of external targets to to invoke
external build systems but any tool can
be involved so if you want to use it to
create a package disk image there are
command line tools for that excellent
does not yet have to have gulping target
types for building disk images and other
kinds of deployment targets that's
definitely something on our list but
meanwhile you can actually wired up
yourself but not not that much work web
server deployment tools is another
interesting one you could ftp as a
result of your your build over to some
server etc custom executables are an
interim I think under use but a very
useful tool anytime you create an
executable target such as an application
or command line tool Xcode automatically
creates an executable for you and what's
an executable well just an execution
context so that names something to be
run the directory from which it should
be run any kind of arguments to be
passed to it if it has any on the
command line you can set these up for
anything you like so if you're
developing a photoshop plugin you can
actually set up an executable to launch
photoshop and have it load your plug-in
launch parameters can be configured and
as I mentioned you can create as many of
these as you want custom ones plug-in
development is one libraries to if
you're working on a framework or library
maybe you're you're most of you probably
shipping an app or working on something
like that but if you are working on just
the framework what you probably have is
you probably have a dozen test apps or
more and so you could set up an
executable for each of your test
applications each one configured to run
with your build version of the library
and that's a great way to test your
library as you make a change to your
framework code you just hit build and
run it will run some other app but load
in your framework and you can test your
changes that way and it's useful for
quickly switching between them just as
there is a development like a build
style and a target pop up there is an
active executable pop up which controls
what gets run when you hit the Run
button
so that's another thing you can add your
toolbar so I want to show a couple of
these things in action the time actually
going to show not just show where things
are but actually build a couple of
things so can we have the down-low
machine please thanks so what I'm going
to do here is to first let me just go
ahead and build let's say we have the
development build style here is the the
active one I can actually add i'm just
going to control click on here and you
have the active executable show you that
sketch not surprisingly executables
shown under here and you can edit any
kind of settings there what i want to do
now though was too let's say create an
external target let me go ahead and I'm
going to do is to go under the project
menu select sketch here you go and say
new target and what I'm going to do is
create a shell script target and let's
say I want to create a disk image so
that's what I'm going to going to choose
and I want to add it to the sketch
project that's pretty simple okay so now
we have dance fo here by default this
target it doesn't build any kind of
product at all it has is a single phase
they create that runs a shell script so
I'm going to inspect the shell script
build phase shell script goes here right
so i could type in the whole shell
scripts here if I wanted to but what I'm
actually going to do I have a ready-made
one that I'll just add to the project
i'm just going to drag that n drop it
here under under the groups and files i
want to copy this into the project
actually it lives on my desktop right
now so i'll just copy it in i'm not
going to add it to any target because i
don't actually want to install the
script as part of any build if i added
it to the sketch target it would get
added as a resource in the resources
bucket but i don't want to do that so
i'll just go ahead and click Add so now
i have my shell script here I can let's
see you take a look at that and in this
case it's a fairly it's not too
complicated uses applescript actually
the most of the complications use apple
script to configure a disk image what it
does is just created
disk image used apple script to set
position of files and icons and color
and stuff like that compresses the disk
image and then it sells the finer to
show it to us so let's go ahead and take
a look at that now I've added the file
to my project but what I also want to do
is of course to to edit the shell script
old page itself so I'm just going to
tuck in a shell command here to to this
case just invoke the shell script that's
in my project the shell script here gets
started up from the project folders so
that's that's fairly fairly succinct way
of doing that she noticed at the bottom
there is the input files may output
files this is how i mentioned that xcode
weeds and the shell script into its
dependency graph so that it knows when
to run it so what I'm going to do here
is I'm gonna actually going to add I'm
going to use some of the build settings
that are defined by default I'm going to
say that in my built product directory
there's going to be a application called
sketched out app could drag this into
these build settings header know about
build products sir well we have a menu
item for bringing up the HTML page for
this we have a bunch of built-in build
build settings normally if you're just
building an app in xcode if you're not
doing anything particularly like
automating the workflow here you don't
really need to know about these but
they're very useful if you do want to do
anything more a little more complicated
like this another thing I'm going to do
is I'm going to make the shell script
here depend on the shell script file
that I am actually including and what
this is going to do is it's going to
mean that my shell script gets run if
the product is out of date and also get
and get run if I modified the script
that built the disk image so that's kind
of nice and what does it produce we need
to know what to compare against so what
the script produces is it put and target
builder that's another one of the
standard defined settings it's going to
create a sketch disk image so now we
have this all set up and let's see what
happens when we build one of the things
that I do is to make sure I picked the
deployment
target so don't try to ship the the zero
link binaries and I'm just going to
select the create disk image target
there's one more thing I forgot to do is
anybody know yeah so right now we have
two independent targets you can actually
have two separate totally separate
dependency trees or two or more if you
want an Xcode but to relate these two
targets to each other what I want to do
is I want to bring up the inspector
again and I want to add a dependency
from the create disk image targets to
the sketch targets so this means that
schedule get updated before I even try
to build a disk image me and get rid of
a couple of the the inspectors here and
now let's just go ahead and build this
so it's going to go ahead and build
sketches it normally does and actually
I'm going to do is it's linking it's not
very linking so that's a good sign so
it's running the custom script so it's
actually creating the disk image and
mounting in setting the background color
and all that good stuff so now we
actually end up with a compressed disk
image that can change my built version
sketch and I can ship this to my to my
customers and moreover thank you
moreover if I go in to Xcode again and I
have build see it just says build
succeeded we can look at that in more
detail for you bring up the show
detailed results I'm just going to hide
the editor here because I don't really
need ever know nothing happened here
well that's because Xcode knows that I
haven't updated sketch I have not
updated the script and so I don't need
to do anything if I go in here and I
update the script one of the things I
can do that date the script is to say
okay here's some of the input settings
so my script takes well let me go ahead
and copy one of these and I'm going to
not define it in the script itself I'm
going to save this what I'm actually
going to do is I'm going to set this
Andy create this kimmage target so I go
here and i have my own setting and i'm
just going to make this be let's say
zero so now when i build and it knows
that i need to build because i modified
one of the inputs so now when i build it
runs the custom shell scripts and it's
going out to the finder again and now we
get a different color so and there again
if I build once more nothing happens
this is a nice way to make sure that we
only actually do work when we need to so
that's where the shell script inputs and
outputs come in all right so that's kind
of interesting but we can actually do
something even a little bit more
interesting with shell script build
phases me actually add in the shell
script build phase to the same target
you can either create a new target and
have it depend on other things you
typically do that if you have your own
build system like Andrew make if you
just want to have a little steps to
happen at the end of updating a target
you would just add another shell script
build phase I'm going to go ahead and do
that I can do that in several ways I can
go to the project menu here saying your
build phase i'm just going to control
click here on target actually and i can
say add new build phase yeah at a shell
script build phase just another one I
get another inspector looks exactly the
same because it's just another shell
script the sequence of these matters so
they accept rise to run your shell
scripts in sequence it will however
respect input and output dependencies as
a higher order
presidents and respecting the the order
in other words if you say is that the
the first shell script depends on the
output of the second shell script it
will actually run the second one first
so will respect the dependencies what
I'm going to do in this case is I'm
actually going to use Apple script now
I'm going to use a tool called with a
script and what I want to do is I have
another little script here that I'm
going to drag into my my project i'm
going to copy it in not going to add it
because i don't want to copy it into my
product this is just a helper script
while I'm building my product and so
here's a little apple script and what I
want to do is actually you know in and
see if I can't get get a little
notification here when I when that build
completes so what I want to do is I want
to I want to get an SMS when when the
put my build finishes so I'm just going
to go ahead and have a little script to
use his Apple script to do that let me
go ahead and just type in the name of it
notify completion that xept I don't
actually need any inputs and outputs in
this case I just wanted to run at the
very end it just always run if I need to
build something if anything needs to be
updated I just want this always run so
we're just going to go ahead and build
again and we're already up to date with
the disk image so we shouldn't really
need to do much what we did though was
we ran we ran an applescript to send me
lil SMS and ok so the build finished and
actually it says your build succeeded
but you can't do that so that's that's
an innovative use I guess for for build
phases so go forth and experiments with
that
alright so i can we have the slides back
to
okay so just to summarize okay slides
right of water just to summarize one of
the things we mention Xcode has a lot of
built-in features a lot of you don't
have to know about sometimes you just
have to enable like predicting
compilation your length all this kind of
stuff just just works out of the box
semi-transparent right there a link
pretty good compilation icon stuff
others do require some setup because
there are inputs that X cannot know such
as with your prefix setter what's the
nature of your project what kind of what
kind of headers is it that you use that
are not changing their something's Xcode
can do to analyze this we're thinking
about how to make this even more
automatic in the future but for now set
up a prefix setter make sure it's
precompiled this will save a lot of
times during build and we'll get some
some good build performance distributed
builds is another way if I'm sitting in
a coffee shop with my powerbook this
isn't going to help you much but if I'm
in the office and I have a build form
that's just a couple of meters away this
can really speed up especially a batch
build if you have a large application
you nightly build this could be a real
time-saver custom build phases and build
rules a little bit different right
they're not helping you speed up the
things that you're already doing such as
building your app but they help you
automate some of the things that that
you might be adding to do by hand and
even if you have existing script to do
something like build a disk image we've
seen how you can actually weave that
into Xcode and two to get Xcode to
invoke it at the right time so explore
the possibilities and use the mailing
list the Xcode helps and and learn about
these features and use the great
documentation that talks about these
features so for some of the more
information there's actually sample code
and some example project here at connect
apple com I think you've seen this
address and in many other sessions some
sessions there's there's the samples
that we show the demos you can actually
download those play with that yourself
obviously the expo build system in the
reference library
especially for the bill to build
settings they're all documented there
there there in the HTML pages there's a
normal Xcode help of course on the
release notes I'd like to his Matthew
Formica here now okay we have virtual
Matthew I'm going to ask virtual matches
we come up on stage again it's wei-li
and and at this point I'd like to also
ask the arrest of the Xcode team to come
up for Q&A