WWDC2000 Session 191

Transcript

Kind: captions
Language: en
hi my name is Dane I spent my privilege
over the past couple of years to have
the opportunity to build and lead the
developer applications engineering team
for Mac OS 10 I stood on this stage a
year ago and described how Apple was
committed to the creation of great
development tools for Mac with 10 I'm
very proud to be back this year to show
how we're delivering on that commitment
so what we're going to cover in this
introductory session this morning is an
overview of Apple's development tools
strategy a look at all of the apples
development tools for Mac OS 10 a quick
run through with that and then start
focusing in on the new project builder
you've probably heard references to that
in a few sessions by now I'll be showing
you what we have in Developer Preview
for what's coming soon and what's on the
drawing board some things that we're
working on it a little further out and
we'll also be touching on some of the
new features of interface builder in VP
4 then I'll get to some of the specifics
of delivery and deployments of the new
project builder and because this is an
introductory session we have a lot to
cover and I have pointers to numerous
other sessions where you can find more
details about what I'll be talking about
here so to give the senior management
perspective on Apple's overall
development tools strategy I'd like to
bring on stage my manager look Steve
they're off the senior director of Java
and core tools Steve
hi there this is an outline of the
strategy basically we we feel strongly
that Apple has to own its own destiny
and develop great tools for a platform
aside from developing great IDE we need
to support the platform initiatives for
instance when we got a new hardware the
compilers need to support that hardware
in a first-class way when we develop new
frameworks like cocoa the ID has to
support them in a first-class way so we
have a strong background that just as
Microsoft uses their tools to to push
their platform initiatives at next we
have the same background and at Apple we
want to carry through that legacy to
make sure when we do do new things the
IDE is presenting them in the
first-class way another part of our
strategy is to make sure everyone at
Apple is living on on these tools I've
seen a lot of apple development in
efforts over the past decade mainly from
the outside and at least the last one
which was centered around Dylan one of
its major flaws was no one in Apple was
actually using Dylan Dylan with some
really great work that unfortunately on
died on the vine because no one in Apple
actually cared enough to use this stuff
and in fact if if years ago more folks
at Apple were using this stuff on Dylan
could have been what Java is today but
unfortunately that didn't happen so what
we're hoping is the next time there's an
opportunity like that we will make sure
we're on top of it because Apple
engineers will in fact use the stuff
we're developing and we have support
from the very highest part of the
company Steve who feels strongly that we
need to do this on 10 years ago actually
I'll show my age here more than 10 years
ago back in 88 I was one of the early
adopters at next of the new compiler
project and it was in its infancy at the
time but as you know today
a it's the underpinnings of the Linux
movement and in fact open software is
now socially acceptable worse
it wasn't 12 years ago and we feel
strongly that we need to drive this we
need to be a major player in the
open-source community
next was a fairly small company apples a
much larger company with more resources
we're putting our resources behind the
open source initiative with Darwin and
I'm putting them my resources in the
tools area behind the open-source
movement as well we've benefited in many
ways already much of the Alta Veck
support we have an organ you compile er
was actually originally done at Motorola
because Motorola invest in the new tools
IBM invest in the new tools their
countless number of companies that
invest in the new tools and we want to
benefit from that research and
development another thing to mention
about the canoe tools is I think they
compile that the compiler in particular
compiles more lines of code I think than
any other compiler into the on the
planet it compiles all of Mac OS 10 it
compiles all of Linux its compiled all
of Maya it's it's compiled a lot of
stuff and as a result it's extremely
robust it's not a toy so there are other
there are other open-source projects you
could read that we we leverage in the
Java space we're also shipping the jikes
compiler which is an open source java
compiler by IBM and even though we want
to have a great fit finish to our tools
as you'll see project builders totally
built with with cocoa and aqua we we
want to work with third parties by no
means do we want to close anyone out of
the tools market we want to work
actively and we are working actively
with with metro works / Motorola in
prize Pacific Sierra AB soft and lots of
others we again want to collaborate with
with these vendors sometimes that may
mean the tools are available or
integrate with project builder sometimes
that may mean we may take our tools and
integrate with them so it's a it's
sometimes unclear what collaboration
means
but nevertheless it is a design point we
do not have any motivation and owning or
being the exclusive tool on the planet
at least on them on the Mac platform so
I guess I guess the take-home point
there is competition is good and we want
to compete and we think what we've done
that we're going to show you today is
competitive a couple notes before I turn
it back to Dave one is even though Mac
os10 is in DP for this is the first
release of project builder so it's our I
won't say DP one because we've released
it internally four months and have been
using it but it's our DP Jewish release
so bear that in mind when you use the
tools are still we still the ways to go
before we finish this thing there going
to be some bug's are going to be some
missing features so I wanted to set that
expectation appropriately and well I
guess the last thing is what's thrilled
me is we've built a great team over the
past year to deliver this product and
even though it's not everything we want
it to be at this moment in time I'm
absolutely confident 100% that this
product will be everything we want it to
be and you want it to be because we have
a great team in place and you'll meet
many members of the team over the course
of the talk so with that in mind I'll
hand it back to Dave thank you
thanks David
alright so diving right in let's start
looking at the new project folder in tp4
so first off what is it project builder
is the new integrated development
environment for Mac OS 10 been a long
time since Apple's had an integrated
development environment perhaps remember
now so project builder is the
centerpiece of what we're trying to do
with development tools at Apple we want
to tie many things that we're doing in
to the side to e
there's a number of other components we
work with the interface builder user
interface layouts tool we work with the
web objects tools so web objects builder
neo modeler we work with a number of
different compilers so GCC as Steve
talked about Reds for your Mac Resource
Manager resources Java compilers like
jikes and Java C we worked with a
variety of debuggers like the GDB GDB
debugger for all our c based languages
and Java debugger is tying in to the
virtual machine there and we're working
with the Apple Script team on some of
these things too so what all do we need
project builder to do for us again as
Steve mentioned we want to be able to
live on this tool internally at Apple
that gives us lots of great feedback
from customers who are it's wonderful
they're in my face every day and so and
we also want it to be a great tool for
you so among the requirements we need to
be able to build the core OS itself with
it and how that translates to you if
you're developing device drivers or
kernel extensions iokit modules you'll
be doing using the new project folder to
do so once we've got that KDK all put
together there and we build our
frameworks with them so the carbon
framework the cocoa frameworks java
variety of frameworks there and of a
special importance to you there's a
variety of different types of
applications as well as plug-in modules
frameworks shared libraries that you can
build with the
your project builder for carbon for
cocoa for Java and for web objects so we
did actually have a previous product
that we called project filter some of
you may have used it this was derived
from next but when we looked at all the
different requirements that we needed it
to solve we need project builder in
general to deal with we realized that
the existing project builder was not
really going to be able to handle it so
we have completely rewritten it from
scratch for dp4 but we do need to be
able to import projects from it we also
would like to be able to import project
some code warrior and in fact in the
next session immediately after this
we'll be showing that and then finally
in order to be a full carbon development
environment the definition of a carbon
application is it should be packaged in
an application package that's double
clickable on both Mac OS 9 and Mac OS 10
currently project builders building ma
Co binaries that are double clickable on
Mac OS 10 we are starting to work on
generation of path binaries so we can
get double clickable carbon applications
for nine as well so being a full carbon
development environment so in order to
meet all these requirements again we
decided we need to start over so we did
that January of 1999
so not a tremendously long time ago
about a year and a half I started
building the team at that point and had
approval from senior management to add
more folks some of you may have
remembered the last year WWDC when we
showed a demo of a prototype called PDX
so if you hear of anybody else on stage
referring to PBX that's because I
referred to it internally as PBX the
project was called that up until about a
month ago but the official name of the
product is now project builder and every
time they say PBX charge them a dollar
and I'll split it with you
so but that was a little scary because
by that point I'd only had
two guys writing code for three months
and so I beefed up the team considerably
more after that and we got to an Apple
internal rollout in February of this
year now my team had been developing
project builder with project builder for
a long time before that and this was
about the time of dp3 we did not go out
on DP 3 because we hadn't had enough
internal feedback yet to tell us all the
ways in which we were brain dead so
we've let the internal developers tell
us that it's been used widely across Mac
OS 10 and now it's your turn to tell us
how we're brain good so we have our
first external release on the Developer
Preview for CD and from here it's onward
and upward for us and the OS onto GM so
what do we need to do with the new
project builder as Steve mentioned we
need to fully support the Mac OS 10
platform initiatives and we need to be
much more flexible with our project
layouts and editing than our previous
project folder was when we tried to
bring the code in from the finder for
example into the old project builder it
was a very difficult experience because
they've been developing with code
warrior and the old project builder was
very restrictive on how it expected your
project to be laid out now we've broken
all those restrictions we want efficient
project navigation amongst your source
code a powerful build system if I can't
build your project and it doesn't matter
how good the rest of the system is it's
not of any good to you we need much
better graphical debugging in a variety
of aspects there and overall user
interface polish and then one final
thing and project builder does have a
very powerful build system that you can
leverage but for many pieces of code now
they're coming off the next with their
own make build systems or other build
systems that perhaps if we're sending
code back to the organization that we're
getting it from we don't want to replace
those build systems so we do feel that
is very important to be able to hit the
build button and build one of these what
we call legacy projects hit the debug
button and debug ads and work within the
nice IDE context good good project
navigation but not necessarily
completely replace the existing build
systems so Mac OS 10 platform initiative
support it is very
important that you read the system
overview manual understand it Mac os10
is not the same as Mac OS 9 there are
many fundamentally different concepts I
have to take a little bit of pride in
this manual because I told the pub's
team that look you know I don't care if
you just document how my app works and
how the api's work people need to have a
fundamental understanding of the system
in order to be able to deal with this so
again I mentioned it ma Co the format
the project builder generates this is
what the GCC compiler is emitting for us
it's been used since the dawn of time it
next and that's what is the fundamental
primary binary format with Mac OS 10 we
do support path modules loaded by the
code fragment manager as a transitional
mechanism four-carbon binaries but we'd
really like you to move to mock o to
take full advantage of the OS features
and performance wise and tools wise all
our tools are going to be aimed
primarily at not go the concepts of
frameworks is very important with Mac OS
10 framework is our shared library
packaging mechanism and it includes all
the for example headers public headers
documentation resources project builder
directly supports making use of
frameworks now we also let you create
bundles so very importantly understand
the concept of bundles of Mac OS 10 an
application package is a bundle plug-ins
or bundles frameworks themselves or
bundles bundles have information
property lists that we know how to edit
and this is how you do your localization
through editing of bundles as well so
with project layout and editing there's
a variety of types of ways to create
project templates we have a whole bunch
of standard project templates and you
can define your own again we can import
existing projects from the old project
builder and from code warrior we now
have user definable groupings of files
so this is independent of physical
layout on disk which was not the case
with the old project builder and it's
also independent of how the build system
works and so we now also support a
target model
you can have multiple build targets for
per project and select which one you
want when and projects can reference
other projects so you can have
dependencies on that that feature I
guess I'm done that is a little bit yet
to come but we're working on that one on
the build system last year when I talked
about the build system I described the
build tool jam and that we leveraged
jams just another make freely available
piece of software that we get off the
net but what we've done in the meantime
is abstracted things away so you don't
need to have nearly as good an
understanding of the jam tool itself so
that's what we use to call down to all
our compilers so GCC res Java C etc but
we in the IDE we may can take advantage
of what we call build phases so there's
a variety of standard build phases for
copying your framework headers copying
your resource files compiling your
source code linking etc and the
jam-filled tool we are leveraging at
this point to get automated dependency
analysis of course that's obvious right
but well actually our old product didn't
do that right and and but there is no
need to go in and edit make files so
we're handling all this within the
context of the IDE and you can customize
your build by adding additional scripts
custom build phases as necessary so as
Steve mentioned we are taking advantage
of the GCC compiler for those of you who
knew the term eg CS or eggs this is that
version of the compiler GCC tu-95 it's
the latest this and is a significant
change in the compiler from what we had
before this provides full C++ support
now including an up-to-date standard
template library support and we are one
thing to note about this is that it is
stricter with an C C++ compliance so
some of the users have told us that wow
I found bugs in my code that I didn't
know existed with the previous compiler
and with this compiler we have support
for the velocity engine and Steve
mentioned the company
cific Sierra research that company is
working to do an automatic vectorization
support for Mac OS 9 and for Mac OS 10
because unless you're familiar with it
vectorization is a little bit difficult
so we're working with that company to
try to take full advantage of that and
again it's very important to note that
GCC does build all of Mac OS 10 all the
core OS code sea based code four-carbon
frameworks and core foundation C++
applications like finder or Sherlock and
yes we do use PowerPoint to send things
internally and so we build that at our
own version of that Mac app is now
building in power in project builder and
with GCC and we also support objective-c
still as a primary development language
from a closed ten so the cocoa framework
is written with Objective C the mail
application project builder itself is a
cocoa and objective-c application and
just to note you can still write your
cocoa applications with Java as well so
cocoa Java apps one final thing is that
we actually do feel that it's very
important to be able to build from the
command line there's a lot of things you
can leverage in that way Apple at Apple
our built-in integration mechanism
builds all of Mac OS 10 from the command
line as opposed to firing up the IDE in
any way but what we're doing here rather
than calling jam directly we've put a
new command in place called PBX build
which of course is PBX is a denigrated
term this stands for project builder
external build commands
so with this command what we actually do
is a very small application that
actually links with the same framework
as the project builder application
itself and actually opens up your
project model and invokes jam once per
target of the project you're trying to
build so you can automate builds with a
shell script a nightly build process for
example or login over telnet and run
build i aughtta mated my performance
testing and quality testing of the build
system through this mechanism so now
what I'd like to do is bring one of the
engineers up on stage Manuel de Silva to
help me go through a demo of project
builder first patient queue so what
we're going to do here is take a look at
an example project from the system so
the glut examples is a project that you
would find out in system developer
examples what examples this is the
OpenGL user you can see OpenGL utility
toolkit examples project it's got some
graphically cool stuff in it we've
stripped down this project a bit so that
only got a few targets in it but let's
take a look at what happens when you
first launch the project and we've tried
to as we're doing with the finder and
with mail we're optimizing for use with
the single window here and we showing we
have a variety of new projects that you
can create you can create carbon
applications or cocoa applications CF
plugin bundles frameworks but we're not
going to do that we're going to work
with this OpenGL example on what Manuel
has open here is the groups and files
outline on the left on the left we have
tabs that show structure of your project
across the top we have tabs that are for
tool operations to find build debug so
with the structure here now we have
three of the examples here geo phase
roller-coaster and uses sphere map we
can open one of those groups take a look
at the files in that we see a little lot
circles in the left-hand column that
shows that these files are built for the
particular target that's our active
target we can see that up above geo face
is the currently selected active target
and down below we also see that we're
linking with the glut framework and you
can navigate down into the headers of
that so we do very directly times with
framework mechanisms of macros ten this
is what you do with the carbon
frameworks or cocoa or whatever and so
let's take a look at how we can do
grouping for example so we can select
let's say that we wanted to have the
source files in a group and just I call
them the sources group so we can select
them and create a new group call that
look looks like we know we can move code
in there I'll show you moving okay so
that's all on under sources now so again
note no physical type in layout on disk
now let's take a look at how you would
look at some of these files in the
editor you know we'll click around on a
couple of files main dot M display dot C
so these all show them at the same
window there's a pop-up here if you want
to go back and forth between files that
you've recently been to and you can also
use a browser like back and forth
navigation buttons but let's say that
you did want to have a file of source
code off in a separate window just go
over to the files line and double-click
to bring it up in a separate window
that's got all the features you can
split the window and split the panes in
the window and actually bring up even
other files in it etc so a lot of
flexibility there you can have as many
separate windows as you want now let's
take a look the file inspector so up
under the project menu show the
inspector this is where you would set
things like what's the reference style
to how to get to the source code here so
group relative project relative
absolutes
this is also where you would do for
example localization so if you had an
interface builder nib file and you want
it to localize that you would do that
from here ok so let's take a look at
building so we'll go ahead and just
build the entire geo face projects here
and a Geo phase target since this is our
active target so now this is one of
those areas where we know we need to
make some additional user interface
improvements here what's popped down is
the expert mode build panel and what I
was trying to do at Apple was get this
product out useable as quickly as I
could so that I could stop maintaining
the old project filter that many people
were using so there are areas of the
products where you'll find sort of
expert modes built in because we haven't
quite had the opportunity to build in
all the nice user interface that would
show you know which files need to be
rebuilt in which files building now but
this has built and so now let's say that
we had a syntax error in a file how
would we deal with that so let's go
ahead and introduce a syntax file in the
head dot H file and save that and then
rebuild again in this case we see up in
the build summary that the number of
error messages pop up we can select on
one of those that takes us to the line
of code fix the syntax that are there by
doing undo so we can undo past the last
save it's a multi-level undo multi-level
redo and now from here we can rebuild
and it just goes out and builds exactly
those files that were dependent on the
head dot H header file and we're
successfully built and we can go ahead
and launch at this point
ok so we've launched the target
executable we can make it do a little
dance here and also one thing to note
manual is pressing the a key that's
saying uh making smart there you noticed
as a lip went up a little bit and you're
seeing build log or log messages from
the application in the standard
input/output window behind there so if
you have log messages you wanted to
print out for example okay so let's quit
out of that now let's take a look at
target editing so if we select the
targets tab over here on the left you
can see that we've got a number of
different targets will select the Geo
phase target and that brings up a
different type of editor into the main
window so this editor now shows us the
files and build phases this is basically
how your build is going to work for this
project what het earnest will deal with
what bundle resources will copy what
source tiles will build how will link
and build settings this is where you
would set the you can go to the build
settings tab this is where you set the
product name that's going to be built
and if you were doing an install where
it would install - and down below you
see the expert mode build settings so
this again is another case of where we
need to provide better user interface
but with this expert mode at least we
can get a way of supplying all the
options we need to today into the build
system so application settings this is
where you set the information property
lists for your bundles is a very
important thing to know about and
actually the if we can go back to the
simple screen there this interface is
actually has been cleaned up but my team
move moves very quickly this is post DP
for feature here you don't have it quite
yet so what you do have is the expert
mode build settings which is a property
list editor with cocoa we can just
leverage an object that we already had
to do property list editing and then the
final tab for executables if for example
if you were building a bundle that
needed to be debugged within the context
of a given application you could say
this is the application that you would
launch to run that bundle and the
arguments that you would pass to it so
we can select a different target up here
let's say we go to the install target
and with the install target we see some
different tabs this actually is a legacy
target here it's an example of how to
have a target that builds something
different than what we have in our build
system so this is just running a shell
script here to copy the example source
code where we need to done on the system
and then one final targets let's take a
look at the all examples this is an
example of an aggregate targets that
itself has no build mechanism but it
does ask other targets to be rebuilt so
we have full dependencies between
targets and if we build all examples
then at this point then it shouldn't
need to rebuild geo phase because that's
already been built goes off and builds
the
two targets as well so roller clothes
rollercoaster and uses sphere now we see
down the lower left don't succeeded but
you see up the top and the toolbar that
the run and debug buttons are not
enabled that's because with an aggregate
target there is no single executable to
run here at this point but by selecting
one of the sub targets so for example
making roller coaster the active target
now we can watch it and watch the roller
coaster come up and spin so these OpenGL
examples are kind of fun to play with
alright very good so now let's talk
about debugging with our debugging
system we have an extensible
architecture that can accept various
plugins we do communicate with gdb for
debugging of all C based languages gdb
is a very well-known UNIX usually
command line debugger we also are
working heavily on Java debugging it's
not fully functional yet but if you've
been in some of the Java sessions you've
seen some that we're working with the
Apple script team for debugging of Apple
script we've gone to a much more
graphical debugging model than we had
before so we show thread stack traces
variables within a particular stack
frame with breakpoints now one thing to
know about project builders that we are
designing it to deal with the multiple
person projects so each person gets
their own preferences saved off per
project settings saved off with the
project itself it's actually inside the
project document wrapper so you could
actually check those into a source code
control system for example and
breakpoints is an example of some of the
settings that we store in there so you
can have them persistent not just
between runs of the debugger but between
runs of the IDE as well and I can have
my breakpoints Manuel can have his and
you can have yours all within the same
project one person told me that whenever
they write code they put a breakpoint on
it and I thought that was a great idea
you know later on two weeks later you go
to execute the code and hit the
breakpoint and step through it the first
time you've run it and now we can
support that
now we can invoke functions to get the
values of opaque data types which is
very important for carbon developments
today and also for our core foundation
with functions like CF show from the
debugger we control the dynamic motor
what's called dy LD on our system so we
can control where frameworks are being
loaded in from if you're doing framework
debugging so also cross project
debugging part of the reason we've got
the one window there is we expect that
you'll be working with frameworks and
perhaps having frameworks and different
projects so multiple windows open on its
own project window and from an
application you can step right down into
the code of a framework and to cross
project debugging so we are taking
advantage of gdb and I've gone through
many of the features here we do have
additional things that gdb provides like
the ability to set conditions and
commands on breakpoints we don't yet
have user interface for that but we will
have the opportunity to do so in the
future to put that in but we do have
access to the gdb command line for any
superpower features that those of you
real gdb addicts want to get to there's
a number of powerful macro capabilities
that the carbon team and the core OS
team they're taking advantage of in a
variety of ways and we have done some
things so the stats are startup and more
robustness in our DP for version of gdb
so now let's take a look at an example
of debugging if I could go back to demo
demo one on both screens please so what
we're going to do with debugging here is
give an example of debugging the Geo
phase targets again so what we want to
do is set a breakpoint on a particular
function that we have and remember the
name of so make menus so let's bring
down a fine panel panel and show make
menus and you'll find for that so we'll
find good text we'll find right now
there we go
and we select on that and that takes us
to the line of source code there we can
put a breakpoint on that now if we want
to see what breakpoints we'd have in our
project again this is project
data projects structure we have another
tab to show that so we have just put a
breakpoint in main em which is dot M is
the suffix for Objective C but it's
showing that we already have a
breakpoint on make faith dot C so this
is actually an example of a persistent
breakpoint that was already out there so
by double-clicking on that we can show
the specific lines that the breakpoints
are on again this is an example of an
area where the user interface has been
cleaned up slightly since dp4 actually
so let's go ahead and launch the
application under the debugger we hit
the debug button and the debug tab pops
down and it starts loading the
application into gdb and we're off and
running so now we've hit our first
breakpoint let's take a look at some of
the user interface here so we have a pop
up menu that shows the different threads
within our application now we'll leave
it on to make face thread for now we can
walk up and down the stack trees so we
see the variables changing for each of
the stack frames within the variables of
the make face function we can expand on
for example the face argument and see
that that's actually a fairly complex
structure in there we're getting all
this information back from gdb now we
can close that back up and do a little
bit of single stepping through here we
see actually that there's two loop
variables here the I and III variables
and yeah I didn't write this code but
every time we change the value it's
showing the preview the change variable
in red so kind of what you would expect
and so if we continue from there then we
actually march along hit the other
breakpoint that we just put in
let's single step a little bit there and
then continue again and we see the
application fire up under the debugger
here so debugging fairly nicely tied in
and again we're going to do the same
thing with Java debugging
and I think that's it on that all right
so we can go back to slides thank you so
continuing our discussion of what's in
Developer Preview for let's switch the
interface builder for a moment so what
is the interface builder for those of
you who aren't familiar with it
this is Apple's user interface layout
tool the big deal at this point is that
you can create aqua compliant user
interfaces for both carbon and cocoa
applications with this get all the
metrics correct etc standard menus you
want and for those who've done cocoa
development in the past you're familiar
with the interface builder in this it's
a big part of the cocoa development
cycle lets you put in actions and
outlets that tie back into the source
code but you can also at this point use
it for your carbon development so when
you run you interface builder it
generates what's called a nib file which
is the description of your user
interface again we can do that for cocoa
applications carbon and also for Java
clients for web objects the interface
builder team has done a great job of
adding and support for additional
platforms so if they're down the road
become more that become important we'll
be able to add that into interface
builder so how would you take advantage
of this in a carbon context well within
the carbon run sign on Mac OS 10 and in
carbon Live 1.1 soon you have what's
called the interface builder carbon
runtime that takes the nib file under
direction from your code and loads it in
and then you can not it builds your user
interface from that so this is sort of
an alternative to using the dibbles
d-logs
and window definitions and other things
it may be familiar with in the past so
why might you want to do that one
advantage is that again it does let you
create a aqua compliant user interface
this does support all the carbon user
interface elements and for those of you
who have been learning about the new
carbon event model where it makes it
easier
I command back into your code this is a
great way actually the best way of
taking advantage of the new kerbin event
model this is lets you create Unicode
compliance user interfaces and it is
tied in with the new project builder and
will continue to tie it in more tightly
as we go so I'm not going to demo
interface builder in this session this
morning but 9:00 a.m. tomorrow I believe
in this room you can come learn much
more about interface builder for both
cocoa and four-carbon development okay
again further elaborating on how we're
delivering our on our commitment let's
show you some of the things that aren't
in this release but will be coming soon
I've talked quite a bit about both Java
and Apple script we're trying to broaden
the scope of project builder to handle
development of everything that you'd
need to do with Mac OS 10 so I've got an
engineer on my team at this point who's
working heavily with the Java teams to
make sure that we can build all Java
projects and that we can debug them some
that's been shown in the Java sessions
we're working with the Mac runtime for
Java team to bring some of the features
of their SDK from Mac OS 9 into the IDE
for Mac OS 10 with the Apple script team
we're working with Chris Espinosa team
there to provide an environment for
developing Apple script and then within
the IDE itself we're working heavily on
better source code navigation a number
of graphical user interface improvements
so some of these you've already seen
like this information property list
editing sorry couldn't help it I already
gave a sneak preview of that build tool
option settings it's very important to
us that we'd be able to have a much
better graphical user interface for
setting of do I want optimized code or
what level of optimization etc we'd like
to continue refining our user interface
for debugging and source code management
is a feature that ever since I first
took the management job here the web
objects team for example has been
demanding source code management
features so let's talk about the
efficient project navigation
we know that we need to provide a number
of shortcuts and the user interface to
be able to quickly get to the
definitions of functions references to
the specific functions would be nice and
when you're looking at source code it'd
be nice to be able to quickly get to the
include files or vice-versa
we need this for all languages so in the
previous project builder we didn't
actually handle this for C++ now we are
going to do that actually by going
through the compiler to gather the
information so for C C++ objective-c and
for Java will provide class browsing
features and access for the frameworks
that you're using so definitions of
things in the header files of frameworks
or for example for cocoa doing class
browsing of the cocoa frameworks with
the source code management UI anti to
make a decision here how do we approach
this do we make a nice plug-in
architecture that could handle things in
a general way that would be nice but the
first thing my top priority across the
board with this product was to make sure
that I had the features working and that
the right feature is there and that the
robust so I wanted a way to do things
and then we can think about how to
expand from there so this what we've
decided to concentrate on for now is CVS
that's what we use for everything
internally an apple now that's what the
darwin sources are accessible through so
we're providing CVS access directly
through project filters so we can get
status we can commit your files we can
do file updates to the changes that
others have made and we can show you
comparisons of your files so let's take
a look at the demo of this okay so back
into our favorite geo face example
project let's now select the muscle dot
C file again and you know part of the
reason the 7th shift is because the user
interface isn't quite right and some
things like that you see now in our
navigation file above the project editor
that we've got two new pop-up menus
so the pop-up menu on the the middle one
is the very symbols within this
particular file and on the right we have
the header files that are imported by
muscles see so let's go ahead and select
the last one of those head dot H so you
can see we went to that and let's go to
the function pop up or the simple pop-up
and for example let's choose muscle and
that takes us to the structured
definition for the muscle type def and
so now the this menu it's a little hard
to read but it says imported by or
imports this and so there's a number of
source code files to import this header
let's take a look at one of those so for
example me m and another thing that we
have built in you can see also we have
full syntax coloring here and you can
set the options on how you'd like that
to be set
so one other thing is see if we go to
the find panel we can also do a find
definition and we'll be working to
optimize user interface on this to make
it more accessible from the code so
let's say type in ko saing which we
happen to know is there and that shows
fine definition we can click to go to
that we see a book marker there so that
if it's framework we could go off to the
documentation for that ok so now let's
take a look at some of the SCM features
if we take a look at the groups and a
filed view again we see that there's a
new column over here the SCM column and
what this shows this is the SCM status
of the files in your project we see a
number of M's here which indicates that
some of the files have already been
modified so let's take a look at one of
those like head dot H for example and
actually man well I don't remember what
we changed in head HDO well let's find
out so so let's go over and take a look
at the SCM menu now we could update to
the latest revision we could compare we
could commit but before we commit let's
do a compare and see what's
changed so we send a message off to the
file merge graphical dipping tool and in
that up we come and we can see
graphically what things have been
changed in this file it's very cool okay
and so if we quit out of that then we
can now go ahead and commit these
changes we like them so we can type in a
commit log message here so we fixed a
bunch of warning messages that if you do
take the glut examples and bring them
over you will get a number of compiler
warnings so we fix those for purposes of
the demo now we've committed them but I
wonder what are all the difference
met the different revisions of this file
so let's take a look at the file log if
we go back to the file inspector we now
see that there's another tab that's been
added down here which is the SCM tab and
that shows us all the different
revisions of this file you can select
any two particular revisions there and
do another compare of those and they
actually don't have to be right next to
each other but again we can bring up
file merge to show you the differences
between any two revisions so that's
what's coming soon things I'm confident
we'll have into the next release that we
get out to you what are some things that
are a little bit further out on the
drawing board so we know that we want to
make project builder more extensible
I'll talk about that a little bit more
in the moment full integration with web
objects tools we have not completed this
yet but we're working heavily with the
web objects team to make sure that web
objects builder and Ile modeler works
very well with the new project builder
if you've got any of the web objects
sessions they're actually still
describing the old project builder and
I'll talk a little bit more about that
in a moment
generation of carbon binaries and faster
C++ compilation is a big issue for us
for extending project builder and we'd
like to have the ability to easily plug
in new build tools so if you have this
special purpose compilers for example or
whatever then you should be able to just
drop those in and maybe write a little
bit of jam syntax if you're going to
extend the build system you at that
point may need to know some level of jam
but hopefully it'll be nice and stylized
and will have a mechanism for providing
user interface for setting the options
for your build tools but we're in
progress in some that but don't have
anything to show today plug-in editors
we haven't shown it we have shown how
you can have different editors in the
editing portion we have a tiff editor we
have a release TIFF viewer we have an
HTML editor that we can plug in but we'd
like to make that a bit more extensible
as well we'll be adding scripting in
sometime down the road and with that we
could provide npw like addition of new
menu commands that could help you tailor
the IDE to what you'd like so let's talk
about carbon miners here for a moment
again this is for generation of carbon
applications the Quran on Mac OS 9 and
it's very important that we be able to
have a full carbon development
environment for you our strategy here
again is to leverage the GCC compiler
and use it as a cross compiler to
generate X cough output files we go
through then the PPC Azzam assembler and
PPC link and we are far enough along
with this that we will show you a quick
demo of that ok so on the left here my
left your right we have a Mac OS 9
machine on the other system we have our
Mac OS 10 machine so we're going to open
up a different projects here but first
let's make a network connection what
I've got here is a shared folder this is
my Mac OS 9 system so let's go ahead and
I can Apple share connection to this now
on the finder does not yet in dp4 you
can see in the go menu a connect to
server' menu item well they didn't quite
have time that's not enabled but there
is what's called a test
AFP clients and system demos and so
we're launching that now with
in the IP address of our mac os9 system
connect as guests choose the volume and
so now we're mounted and we can quit the
test AFP clients so now we see it in our
Finder window mac os9 shared folder and
we see this is my mac os9 system ok so
let's go ahead and launch project
builder on a different project this is
what we call the handy sample I don't
know if our DTS engineer is out here but
this was a sample is provided to me by
DTS it's an example of scrolling in a
carbon application if you want
proportional scroll bars and taking the
hand and scrolling so we're going to go
ahead and build this project so again
you see the same kind of build output
the same output mines see see there is a
way in the Preferences of project
builder to get the full build command of
exactly what it's running what we've
done here if we go into the build
settings we've kind of modified this
project a little bit in ways that you
won't have to you can see some of the
flexibility so what the - B argument we
can tell GCC that we actually want to
use a somewhat different version of GCC
that generates a different output and we
want to use a different linker here as
well and so we've also changed the X in
the executables tab we've changed now
we're going to use the once CFM binary
as what we launch for this application
but we are passing in an argument which
is the full path to this particular
application so let's go ahead it's been
successfully built let's hide project
builder and we should see the binary
here in our macula densa so let's go
ahead and copy that across to the mac
os9 system ok so i sit here on my mac
os9 system let's go back into project
builder and we can hit the launch button
from here and actually see the half
binary launched under project filter and
by double clicking here on mac os9 I see
the same binary launch done nine
so again this is showing demo of carbon
scrolling here so when we do this for
real
what you'll get by default for macula
ten miners is a knocko binary that will
let you take advantage of the full macro
sense system but for demo purposes today
we're showing pepper on both sides
alright so that's it for our demos
thanks very much Manuel and if we can go
back to now let's talk about delivery
and deployment now I've mentioned that
we have had a previous version of
project builder those of you who have
been doing web development or cocoa
developments are familiar with that now
we're playing a little shell game here
in zp4 and when you look in system
developer example in system developer
applications project filter is the new
one and we have the project folder lo
which stands for project builder web
objects and that is the old one that
today would still be used for web
objects development but that would be
changing soon and so if you are coming
new into this I would not recommend that
you run the old project folder lo at all
so for those of you who are using the
old project folder we will not be
shipping that again unless somebody
gives me a very good reason why I need
to I have no intense put any effort into
maintaining that product although we
will make sure that the web objects
customers and developers are fully taken
care of but again we're working with
that team to make sure that the right
things happen to integrate with the new
project builder and you all want to
shift over if you are using the old one
and in the next session we'll show how
easy that is to do so for delivery and
the decision at this point is that this
is one of Apple's core development tools
it will be shipped on the quarterly tool
CDs to Apple Developer connection
program members so you get this for free
as part of your monthly mailings and we
haven't done this yet so I'm sure there
will be some logistics to work through
on the
but that is the plan and we'll also have
web updates available again we haven't
put one of those out yet so I'm sure
we'll have a few logistics to work
through there for support resources
we've put a public email list in place
project builder - users at public lists
accom this is one of the fairly standard
places where these go we do have a email
list in place at this point that we've
been getting feedback on we have
delivered this to a few and a very small
number of third parties at this point
who came down for one of our kitchens we
sent them back with it in the kitchen
they shifted their development over to
the new project builder and they're
elated with it so far thanks you guys
there they go
and then the DTS support mailing list
so in summary and you can see that we
are delivering on our commitment to
great development tools I'm very proud
of the team it would accomplish what I
consider to be a heck of a lot in the
last year and a half and in fact if I
could ask team members to just stand up
and take some acknowledgments here
you