WWDC1997 Session 208

Transcript

Kind: captions
Language: en
and gentlemen please welcome to begin
senior evangelist Rack City evangelism
Jordan D Matson
[Music]
good afternoon you've heard a lot of
discussion in session yesterday and
earlier today about the yellow bar and
how this will be the platform for you to
be able to write software and deliver
that software the multiple platforms in
one fell swoop in this session we want
to give you an in-depth look at the
yellow box so that you understand how
it's built what it will do for you what
it won't do for you and how to take
advantage of it in planning your
software development for Rhapsody and
for the yellow box to do that we first
have to change the title or accession
when we originally were planning these
sessions the only term we had to refer
to things was Rhapsody or open step now
we have our terminology our nomenclature
of yellow box and such so this is really
the yellow box technical overview and
will I'd like to invite up now Peter
Griffin Eno the director of yellow box
engineering to give us a tour of the
yellow box and explain how you can take
advantage of it here thanks Jason hi
everyone
well it's no WWC my name is Peter
graphene on director of yellow box
engineering and I'm going to take you
through some of the technologies that
make up the yellow box I'm going to
cover today first off is sort of what is
this yellow box thing we're all talking
about what are some of the guiding
principles we've had over time as far as
designing api's code a functional
overview of the yellow box components
and some comparisons as well as some
opportunities for you this is diagrammed
roughly based on diagrams you may have
seen before what we're zooming in on
today is the yellow box and to clear up
some of the confusion perhaps that's out
there about next step products and
terminology let me just cover this slide
here
next step was next Mach based operating
system which we shipped for a number of
years from 1989 to about 1994 and last
released was called next step three
three then there was a kind of
rethinking of the api's that we called
open step actually collaborated with sun
partly on these and this was kind of the
second generation of the next step
application frameworks the products
based on open step are open step for
Mach 4x which you have a copy of 4.2 as
well as as we have all heard about at
the conference open step for Windows
which is a pretty exciting opportunity
moving forward though we're talking
about something that's a little bit
different than open step we're talking
about the yellow box so to throw in some
technologies first we start with some
next technology open step api's
distributed objects enterprise objects
our database access layer web objects
and display post code coming from the
next side in the Apple side we're
throwing in some great stuff QT ml
already a cross-platform technology
color sync GX typography and the Apple
advance look and feel so these two
components together are making up what
we call the yellow box
the yellow box what we have is a
cross-platform application substrate
that really is sort of a platform in its
own right and we like say it's 100
percent in buzzword compliant so
cross-platform object oriented scalable
enterprise ready media rich
client-server world ready and Java
enabled there you go
now the yellow box is sort of a meta
platform is highly portable in fact next
we've kind of been in the business of
porting that's least open step part
around for the last few years we have it
on the Rhapsody LS which is the mock
plus bsd unix and essentially the same
OS that next i've been using we have
implementations on Windows NT Windows 95
obviously any successors to 95 and as
announced Mac OS and just a question
mark there to indicate that reported
this thing before we could port it again
any technology which kind of emerges as
being interesting you can imagine yellow
box showing up there so I figured I
would take this opportunity rather than
just sort of dive into a catalog of all
the api's and technologies to talk a
little bit about some of the guiding
principles that at next we've used over
the years to create api's and make
developers productive and they all sent
around basically giving developers
leverage the first bit of leverage is
leveraging your tools visual develop
development tools powerful and
consistent ap is factoring out common
code from applications integrating
industry standard technologies enabling
component where and making applications
work well together all of these items
are about leverage whether it's your
tools industry standards each other in
the sense of component where or the
platform it's really making you focus on
the code you need to write to make your
application special so I'll cover some
of these items this section will
probably have a lot of pointers off to
other other talks so I encourage you to
intend them in the development tools
area you're all probably familiar with
interface builder which is kind of the
hallmark graphical application builder
that we've had for very long times and
works really well and we're extending it
to support new technologies project
builder the basic visual code editor
enterprises object modeler which allows
you to model relational database
entities to objects to drive our
enterprise objects framework and of
course third-party tools I think many of
these sessions have happened but if you
weren't at them check them out on the
show floor and there will be a session
on Friday talking about our suite of
visual development tools that you should
check out as well
powerful and consistent API is this is
another kind of hallmark that we pride
ourselves on at next and now at Apple of
keeping paradigms simple and synergistic
and that means keeping the simple things
simple while at the same time making the
complex things possible so there's no
walls or cliffs in the API that you run
into and you're kind of stuck and again
you can't proceed with your tools so and
we use our technologies to implement the
API is themselves so obviously we need
that kind of flexibility consistent and
meaningful naming I think this is a key
item that's often overlooked in some API
is that you may be familiar with win32
era success I unknown I think sort of
laughable names in Java for example
they're 30 methods named ad which on the
one hand you might think was you know
well polymorphism and all that but you
know taken to its logical extreme you'd
have one method called do it in your API
reusability of paradigms really
important developers learn something
once in some part of the API it should
be applicable throughout and one example
of that is the auto release strategy we
use which I'll get into later factoring
out common code again we think that when
you're looking in the documentation for
a toolkit it's not really reused to copy
and paste code out of there this enables
faster development cycles you're not
spending your time copy and pasting code
and finding bugs in it more consistent
user experience for for users across
applications because you're relying on
the facilities reducing maintenance
burden on developers so when we fix bugs
everyone relies when we tune performance
everyone gets the benefit of that and we
think that's really important feature we
take it pretty seriously and also the
other thing about factoring out common
code is that the platform can evolve
sort of underneath you to add more
features to your application and this is
something we've used a number of times
in next step for example in version 2.0
of of next step we had a system-wide
back support and any application that
used the standard print panel which
every application did because it was
pretty powerful but now fax with no
extra code along the same lines is a
session later today on designing objects
where you reuse and extensibility
suggest checking that one out technology
integration again providing leverage
this time sort of - to us as platform
implementers we don't really want to
invent technology for technology's sake
but look to industry standards where we
can so for example things like
PostScript color sync rich set of
standard data types
RTF HTML TIFF EPS JPEG Unicode text
we take all these sort of leaf
technologies that are name brands and
integrates them together and in those
cases most of those things go into we
call the app kit you take off-the-shelf
relational database technology provide a
powerful mapping tool into a framework
we call EOF take some interesting object
technology Java koruba ActiveX on
Windows integrate those things together
with our object runtime and media
technology is like QuickTime quick draw
3d MPEG and a whole variety of other
things that Qt ml supports and what you
really have is a yellow box API is that
if you look at the leaf technologies are
pretty interesting set of cross-platform
standards all kind of tied together in
this one API and so you know if you just
start doing some of the cross-product
things like you know the combination of
PostScript and relational databases
maybe there's some interesting public
database publishing apps a combination
of of QuickTime and and post grip may be
some interesting titling applications
Java and relational databases we have a
product called EOF that that does have
have a Java interface so then you have
great relational database access in Java
so again you know mix and match as you
will that's sort of the whole point
enabling component where is important
thing this basically allows you to
leverage each other and open up your
applications for extensibility so a
bundle API at a low level allows kind of
a cross-platform interface to loadable
code modules including localized
resources you can sort of have one
packaging free or sort of plugin if you
will that it's totally cross-platform
and there'd be a DLL in there in the
windows case and a shared library in
there in the Rhapsody case interface
builder palace is kind of an extension
of bundles that allows us to drag and
drop essentially application parts up
in interface builder and we're extending
that to support javabeans so you'll have
build-up javabeans on application
pallets and under Windows ActiveX
components on on pallets and also using
the sort of dynamic nature of this
bundle concept one thing we think is
pretty interesting is for developers to
create custom plug-in architectures for
their own apps because more and more
these days applications are sort of
becoming platforms in their own right
and we think Java is actually a pretty
interesting language to look at
deploying as a as a plug-in architecture
so another another one of our guiding
principles is making apps work well
together we supply a rich set of
industry standard data types as as we
mentioned before that gives applications
a really good sort of lingua franca to
talk among each other with EPS Tiff's
RTF HTML if Unicode and peg and lots
more and to go with those industry
standard data types we've got a rich set
of transfer services so that
applications can move can move those
data types around we've got multiple
pace boards and drag and drop cross
platform which is not dragging from one
platform to the other but drag and drop
implemented in terms of the native
underlying platform in his natural way
possible but we'll only one API for you
to learn services architecture is
another great example of how we make
apps work together in one of the demos
there was a screengrab that came out of
a service the common one is the
Webster's lookup again if you have a
service you want to provide you just
make a simple declaration and you're a
menu item for your app will show up and
everyone else is that
filter services are kind of an extension
of the services architecture which
provides a translation mechanism so if
you have an application that understands
say TIFF images which are the standard
raster image file format someone can
drop in the system a translator that may
say translate gif or something like that
to tiff and if you do the right thing in
your app then you can open up gif files
as well as TIFF files which is pretty
important and script ability we're
working hard to put script ability into
the application framework in the right
way so that it's very easy to add
scripting support to applications so to
talk a little bit about the functional
pieces of the yellowbox I have this
diagram here which shows the application
framework at the top level with the Java
platform embedded in there at the lower
levels we have display PostScript and
the foundation framework and then this
diagram I'm not showing EOF and web
objects but those are there as well
the application kit is basically the
presentation layer code and a lot of the
application services as widgets we have
both pluggable and native look and feel
so when you deploy your yellow
application under windows it has the
look and feel of a standard windows
applications we have a pretty rich
international text system which there's
a talk about right after this I think
which is really a pretty powerful system
this is one area where I really
encourage you to learn about because I
think this is a great opportunity it's a
very modular architecture and not not
monolithic there's a lot of opportunity
for developers to add add features to
this system and I think will be a great
basis of some applications moving
forward again rich set of fundamental
data types and data transfer services
[Music]
we'll see the application framework talk
is tomorrow and the tech system talk is
today right after this foundation kit is
kind of the low-level collection classes
strings arrays dictionaries that sort of
thing as well as their automatic memory
management facility which basically
allows you to not have to worry about
object ownership across API boundaries
so it's pretty in some sense similar to
garbage collection from the standpoint
of an ADA client of your API you don't
have to document whether they own the
object they get back but it under under
the covers is more of a a reference
counting mechanism operating system
installations provided by the foundation
kit so they're abstractions around files
IO read tasks that sort of thing run
loop and notification services are part
of foundation kit loadable component
packaging that NS bundle object I was
talking about is packaged up in the
foundation kit with complete access to
internationalize herbal resources and
distributed objects which is similar
technology to the RMI in the java world
it's kind of the same thing for
Objective C it's a language seamless
remote method system for information
about that there is a talk about the
foundation kit also after this so I
guess you have to decide between this
and the text system what you're more
interested in this apply PostScript
window server this is our graphic system
at the client-server architecture using
the PostScript imaging model and
compositing was added as a generalized
bit blit for interactive operations and
EPS is a structured is the structured
graphics format in the yellow box and
that's really powerful any application
that can draw in any view can also print
fax or generating EPS file from that
view without writing any code that's as
part of the view system so all the
graphics
you draw on your application can be
captured as EPS and also you can render
a pre-render EPS there's an object in
the kid EPS image rep that allows you to
insert EPS files into your application
in a very straightforward way and
actually see them on the screen which is
a great thing and it really kind of
raises the bar as far as structured
graphics format code and is great for
publishing there are two sessions about
graphics and imaging today there's
imaging under Rhapsody later this
afternoon
and there's printing I will be covered
tomorrow java application integration
obviously the first thing to say support
100% pure java code we're going to do
that with a high performance vm and AWT
JFC implementation also as announced
we're collaborating with java soft on
JFC to make sure the direction that
takes meets all your needs for a real
shrink-wrap native yellow box api S will
also be available in Java so that means
you don't necessarily have to wait for
Java soft to figure it out you can using
the app get in the Foundation right once
and run on any yellow platform which
essentially is all the interesting
string craft platforms anyway so this is
great news because you can have a single
quote unquote binary which you don't
have to recompile for each platform and
also will run on future platforms
wherever yellow goes for more
information on this there's a talk on
Friday about the the Java integration
there's also a couple of other talks I
think the uncommon object model talk is
going to be repeated tomorrow happen
this morning you didn't see that that's
worth checking out
I also talked on object oriented
programming languages which goes into
the whole objective-c syntax how that
relates to Java and covers the things in
a language level and that's on Thursday
the enterprise objects framework I put a
couple of bullets here and send you on a
pointer to that fitzy as I said a
relational database to object mapping
tool it's very powerful this was kind of
the crown jewel of next when it was
going after the the corporate
mission-critical custom app business its
database independent scales to
multi-tier client-server models you can
write clients and servers that use AOF
and it's got a pretty flexible
transaction management system to find
out more about that there's a talk on
Friday that will bring it through that I
encourage you to check that out so the
next section is to talk a little bit
about some comparisons of what we have
with the yellow box and what other
platforms are out there basically there
are four interesting application
platforms there's obviously the Mac tool
box
1:32 MFC Java scoffs Java platform which
is kind of an emerging emerging platform
and apples yellow box platform which is
what we're talking about today not
really into talk about the Mac toolbox
so much because I want to contrast
yellow with this win32 and the Java
platform so to run down win32 basically
there's tons of shrink-wrap for that
that's that's really no surprise it's
not really cross-platform there are some
attempts at cross-platform MFC but
fundamentally it's not really a design
point of 132 to be cross-platform the
AAP is for a large to a large extent are
really procedural low-level ap is NFC is
true as in C++ but it's really sort of
c+ closed bindings for 132 almost
there's not really a lot of value added
an NFC layer objects kind of are an
afterthought the API is pretty old and
things like MSC and Comm
I've kind of come on as as as blue
layers almost on top of 132 and Java
Microsoft taking very pragmatic view of
Java basically it's a language primarily
and it is you know it's a great language
for doing comm objects I mean let's face
it built-in data types in win32 aren't
necessarily cross-platform things like
BMP GDI metafiles
character encoding tables and that sort
of thing I'll tend to be very Microsoft
operating systems specific which is a
different design point than we have
which is sort of looking to see what's
common in the industry and building in
something like TIF into the operating
systems that have inventing something
new so to compare to Java soft Java
platform with Java soft basically it's
object API is only that's great it's
cross-platform and processor independent
really architecture neutral distribution
format which is pretty cool on the other
hand if you have legacy procedural C
code it's sort of considered impure to
use that in your java application so
sort of a radical radical shift at least
to get the hundred percent pure Java
branding to sort of rewrite everything
and it's you know it's not really mature
technology it shows a huge amount of
promise and but it is you know it does
need to do some producing growing before
you can really do shrink wrap with it
and everyone has their performance and
scalability concerns and again they
haven't really set up a fundamental set
of data types in some areas obviously
for images and the lab they have the
JPEG and gif support built in but they
haven't really addressed rich text
structured graphics in a reasonable
layette and lastly it's really not ready
for shrink wrap maybe for some very thin
client web applications
but if you're designing sort of
next-generation fairly large app I
certainly wouldn't embark on job at this
point so the yellow box platform is a
superset of the Java platform and that
we we definitely think Java is an
interesting direction and we want to
ensure that that it gets as good as
possible but we realize it's not quite
there yet so we're encompassing the Java
platform and kind of inheriting the good
and overwriting the bad if you will our
implementation of the yellow box is is
highly portable so similar to the JDK
which is a pretty portable hunk of C
code our yellow box runtime if you will
is also pretty portable the api's we
have our mature proven technologies both
the Apple API is from QuickTime and the
openstep API is that we've been shipping
for a long time they really work and
it's true that the object API is
primarily which is which is really good
all the standard system services are in
terms of objects but at the same time
we're not religious about that and
procedural api's are okay too we also as
I said have a wide variety of
cross-platform data types which we think
is really important if you want
applications to leverage each other and
provide a high degree of sharing of data
and it's ready for shrink wrap today and
we think that it's going to be a great
basis for future innovation and we're
really I can tell you at that next we
kind of been getting tired of porting
open stuff and Mach 2 you know the
platform du jour but we're all looking
forward to doing some great innovation
on top of this moving forward so we
think it's a great foundation so let's
talk a little bit about opportunities
here and really this slide what I'm
really going to build up here is kind of
how I would view a new generation of an
application to be built using the yellow
box technology and for example two
examples kind of think about if you're
doing a 3d modeling package or something
like that you have a bunch of rendering
code it's written in C you've been
tuning it for 10 years it compiles on 30
different platforms a great piece of
code you don't really want to rewrite it
that's great
you can start with that suppose you have
a bunch of C++ code you use it for
document management and sort of your
application core logic that's fine at
the interface layer you want to use the
the open step ap is to do your to your
application presentation so use
objective-c for that using the yellow
box and then because we all think Java
is an interesting platform and a lot of
attributes of Java really make it a
great sort of plug-in basis in that its
architecture neutral and you have to go
back to your plugin vendors when you
need them to recompile for another
architecture the the attributes of Java
I think I think will probably end up
seeing it used in mainstream
applications initially sort of for
plugins and we really want to enable
that in a nice way and over time of
course you can use Java wherever you
could as we've said before right your
presentation logic in Java with the open
step bindings or with JFC for that
matter if it meets your needs or your
core logic can also be implemented in
Java so really it's all about using the
best technology for the job you have at
hand and that's that's always been our
pragmatic approach so in summary the
yellow box is a robust cross-platform
application substrate it's out there
today next has a bunch of customers
using it and there's actually a bunch of
shrink wrap that has been done over the
years
in the yellow box and we're looking
forward to a whole lot more so with that
I get Jordan back up here and invite
some of the team up to take some
questions
Thanks so wanted to make sure that we
had plenty of time for Q&A so we'll be
folks from the yellow box engineering
team come on up
why don't we do a quick introduction I'm
Scott Forstall I'm an in java
application technologies well Dan mold I
manage yellow printing
I'm Michael Pierce I manage the graphics
group I'm Blaine Garth I manage the
object runtimes group which is Java and
objective-c runtimes I'm a Leo sir I
manage the application frameworks group
great well then let's start with some
questions
let's take from here Bob Krauss and Neil
logic listen you're talking about open
stuff and everything being shrink wrap
ready now and I know that next step
before open stuff and everything was
really on a proprietary box but that has
been under windows now for a while given
that there has been some time can you
cite any shrink-wrapped applications you
know general purpose mass appeal
shrink-wrapped applications that have
been built using the open stuff
environment my hospital yeah there's a
bunch of technology from well Andy stone
should create earlier which is a nice
illustration package or the light house
applications there's sort of a there's
been a bunch of sort of page layout
oriented applications that people have
done here come later there's actually a
bunch of stuff on the web their various
next FTP sites if you go and look around
you'll you'll be able to see some cool
stuff what about those mass-market
products you know like CorelDraw or
something like this is it suited for
that kind of thing is absolutely yeah I
mean understand that while being next we
had a very different business model
Mathematica is one of these a climatic a
great thanks Mathematica works works
great on Mach because of the virtual
memory it's really the joy to use there
when we were next don't forget we
charged runtimes so there really wasn't
a business model set up for application
developers and you know after after we
got rid of hardware that was the way we
had to make our money and so now all of
that's changing again
kind of looking forward to it also
illustrator and framemaker there's also
a Photoshop life program called Tiffany
that's very interesting
so there's libraries gaps that have been
built here hi Jim Jarrett from Eastman
Kodak I work on an application that for
the most part was a port from Solaris
and then we basically grafted a Mac app
interface on top one of the last slides
you showed was talking about get your C
library with a C++ on top and then
Objective C on that am I going to
generally be able to do the same thing
rip my Mac app interface off and put on
them yeah I mean assuming that your code
is reasonably well factored and the
interactions are manageable that yeah
that's sort of a whole a lot of it is
C++ libraries for talking to devices and
things like that I how much of that
carries over well as far as the API is
like into the core OS or whatever for
device management I mean that's sure you
know that's obviously a core OS issue
but I mean as far as the engine logic
that you might have that's totally
totally portable great over here hi
Peter's not local with design
intelligence I understand
Apple is going to continue to support
the open step platforms that currently
exist on hp-ux and on the Sun okay okay
okay if I could yeah go ahead
so okay I understand yellow box is a
little different than just open step are
there any plans to either move the
yellow box stuff to hp-ux Sun or should
I consider open step to be a common
denominator I can develop two and have
it run on Rhapsody as well as those
other platforms first off the yellow box
is a strict superset of the of the open
step API so if you develop to the open
step API today that will work as the
yellow application terms of hp-ux and
Solaris what we're going to continue to
support in terms of going forward over
there is basically the foundation kit
and the portable distributed object
that's back-end we need for our server
based applications for example web
objects and things like that and that
will continue to be there
the yellow box as you
as we will not be completely supported
over there in terms of like the app get
and things like that so the app - it
won't be supported the future extensions
- that will be will not be support or we
currently have no announced plans for
hp-ux or for Solaris in terms of the app
kit in terms of yellow box platforms
that the yellow box is targeted for our
Rhapsody Intel and PowerPC Windows 95
and its successors Windows NT and Mac OS
would you considered a good strategy to
code to the open step stuff or server
style applications I'd have to turn that
over that some like blame the foundation
kit provides a lot of OS isolation as
well as it's treated objects framework
we use it underneath our EOF layer and
people people have done distributed
access built sort of an object cache on
one machine that uses databases on
another and spreads clients around with
with do it's not it's not everything for
distributed computing there are tons of
problems in that area and I don't think
of these days it might well be might
well be suitable for what you need I'm
going to be talking a little bit more
about that on Friday at the networking
api's talk ok coming back here Owen Owen
Hartnett harlequin I'm interested in
Corvis support and what's the extent of
it and when will it be available like
that you blame the best person for party
on tape it ok um what we're looking at
doing I think is is integrating the the
Corbett facilities not necessarily
directly into the objective-c runtime
but as you know Corvo requires going to
stub technology so we had a project on
going and
next to to provide corporate facilities
and that's basically what we're what
we're carrying forward I think it's in
TBD item as to whether or not we'll
actually ship or technology as part of
the yellowbox but the facilities will
all be there also a sense we're going to
provide a full Java platform and of
course a lot of other vendors like busy
genex are going to provide Java orbs
you'll be able to use korva fully if
you're using our Java stuff okay thanks
Penner over here just neighborhood an
arc I haven't had the opportunity to
program for open step before but I'm
interested in what sort of issues if I
were to develop a cross-platform
application using yellow box what would
I see in terms of big-endian
little-endian issues in terms of data
files and things like that have you
dealt with that and how would we deal
with that yeah I can take that basically
I mean over the years we've I don't know
ported to six or seven different
processor architectures and one of the
nice things about the development
environment from a AC language point of
view is that they're they're standard
pound defines for OS and processor
architecture standard macros for you
know swap big to host swap close to big
that sort of thing that that we tend to
you know we have used in our
implementation to make it totally bites
X new strokes so you know I think rather
than having to invent your own sort of
processor pound defines and that sort of
thing we we provide a lot of that since
we're using the same compiler across
platform so we have all those facilities
and deal with them in the standard way
the foundation layer offers about two or
three different serialization protocols
there's a persistence framework in there
that we use say to store the nib files
that hold all the connection glue for
your UI and when you go to and you get a
chance when you build objects to encode
them and that encoding format I mean we
do all the byte swapping inside there's
also various serialization techniques we
use inside so that when
messages across with discrete objects
they all show up with the right fits and
right patterns and stuff and so you
typically don't have to do you know even
know about those macros unless you are
building your own file formats and stuff
so we try to even isolate you from from
some of those problems for we Canada
over here
Jory shields Eastman Kodak I'm
interested in whether you're going to
support certain other graphics file
formats I didn't see picked and things
like picked and bitmap on there I'm
hoping those were just left off because
they were obvious they were um they were
they were left off because they're very
obvious okay also I've actually done -
we have picked good also flash pics as a
graphic file for men are you planning on
supporting that I just sort of been
learning about flash pics a little bit
and it is pretty intriguing so I
definitely plan to look at it so you
would you classify that as a nice to
have yeah I mean it provides some some
nice features and I think now at photo
finishers you can get plastics as well
as photo CD pictures out so that's kind
of an interesting sort of emerging
consumer level format which can be
pretty interesting
there'll be more of them - great let's
say I go to this huh - the open stuff
api's deal with what open doc was trying
to do in anyway embedded documents with
on others and so forth and and if so
could we see a demo I love you I'll take
that there I know for the most part we
don't provide the rich you know open doc
had a lot of functionality for
containers negotiating each other and
getting their menus set up in the right
places and so on but however what we are
so therefore no demo but what we can
what we are providing is you know we
have very similar concepts to open up
one piece of open dog was and I guess
maybe ODF provided this was the
framework for drawing and so on and so
forth and we are view hierarchies and so
on provide all those features in
addition we're going to be
you know we're going to allow you to
integrate ActiveX components ActiveX
controls and javabeans and AWT
components within open set view
hierarchies and that will get you that
integration with the other technology
that is fairly powerful as far as though
that user level drop three components
and they negotiate with each other for
space and so on no we do not have those
features I think there there is a lot
missing that you didn't touch on but I
is probably not the right forum to talk
about this I mean documents container I
mean what single document that all these
embedded things can be contained in are
you talking about this rectangle right
talking about the view part of it which
is what app kit does as far as that's
that's how I was approaching it but yeah
when you start talking about document
format I think again we have we have
several formats and foundation we
provide serialization and peanuts
formats for allowing that documents to
be saved and read back in with various
features such as blank mention cereal
the Indian 'less problems you know go
away and so on but as far as embedding
documents and so on we do not support
those things and I think the right way
to support those is to look at the
standards out there and see if we can
just support those better and well open
doc I mean okay why don't we take this
offline to the to the wrap the yellow
box API feedback form on Friday
afternoon I think that's the right place
and voices and we'll take it there
Center I'll hear the Chells walls UK
next step user group first I just like
to follow up on the guy who was worried
about the suitability of next step open
step yellow box for shrink wrap apps I'd
encourage anyone who's interested to go
along to the next step open step
development civilian because there's
people there actually demonstrating apps
that have been written and also just as
an aside both doom and quake were
originally developed on next step and
now my question is do you have any you
mentioned in the presentation that
you had a sequester mark when you were
talking about the platforms that the
yellow box runs on saying you could move
it to other systems do you have any
interest in doing a yellow box for Linux
no comment on that
let's go to be out for one over here
hi Steve Omni hacker design intelligence
I noticed that you had support for jiff
and I wanted to know if you have to get
some special licensing to shrink-wrap
something with chip support and also
what kind of overhead is the yellow box
going to have under Windows NT 95 or
going to be like feet next we'll load up
the hello world or something like that
or on the firaon the first question in
terms of the jiff support my
understanding is that Apple has done a
blanket patent license with data general
is it over the what unisys excuse me
unisys for that patent and so you're
covered with that as far as the
footprint on under Windows I think where
we are right now is about something
around four or five megabytes for the
first app and then incrementally a few
hundred K for the next app after that
because all the libraries are shared and
obviously over time we're going to
compress that as much as possible we
really believe in the philosophy of you
sort of pay as you play and probably
will separate things out in a little
more lazy fashion to get that down even
further what about just a general
performance is it going to essentially
be I guess axes in native libraries so
if it comes to the cross-platform
session on Friday we're gonna have a
demo of the same app running on openstep
mock at 4:00 - as well as on the open
step Enterprise over the in T versus
four - and I can't tell the difference
between the two oh the hands of my boss
will have that yeah you can also check
that out in the hands-on lab back on the
structured storage issue something just
occurred to me that from I understand
plastic uses all a structured storage
there's kind of a competitive there's a
real client file format that is more
likely to be interesting Eric Eric
Shapiro r le M Corp one of the nice
things about the BOS is that it's very
highly threaded and there's been some
talk that openstep isn't very threaded
that you can't for example draw to a
window from two different threads within
the same application I'm wondering what
kind of limits like this we're going to
hit up against and whether they're being
addressed
currently yeah you cannot there are some
limitations in some pieces of the
application framework the foundation
primer is actually most pieces of our
thread safe line right an application
framework it's not as much thread safe
and it's trying to draw from two
separate threads into the same window
will get you into trouble
however I mean it's not clear why you
want to do that but for instance one
thing that wants to do that is AWT turns
out and we're actually putting in some
hooks here and there to assure that aw
can do this for now and that it works
you know with great performance and so
on in and it looks like we're gonna be
able to do that but also we're
definitely our intent is to build more
thread safety into the app kit and this
is you know this not long-term it's not
beyond unified we're looking at it to be
able to do that in the short term so
that you can do a lot of reasonable
things from different threads now you
realize that currently you can spawn off
a thread to go do a lot of computations
message back to the main thread and all
that just works it's just when you start
getting to things like drawing through
the same window and so on and it's
possible there's just a bit you know
weird pathways you have to take but
we're going to try to make it easier
because you know like AWT is an
interesting client and there might be
others one other suggestion along that
lines would be to document which classes
and calls you can call from other
threads I didn't see that noted in any
of the documentation good feedback
the only follow-up on that briefly it
turns out that my team which is working
on doing a full implementation of all of
the standard Java platform including AWT
today has multi-threaded drawing
happening into the same window back in
the labs right I mean it's happening and
so the answer is you'll definitely be
able to do it from Java and we certainly
my team is pushing very hard to get that
into the kit as a whole but we certainly
will do that for Java Kenner it's Chris
Evans with Microsoft my question is
related to undo which I've noticed is
lacking in most next-step applications I
know that it isn't really handled by the
app kit per se so obviously it's the
core functionality in the Mac OS will it
be addressed and if so at what point yes
very
it'll be addressed in you know in a
short timeframe we are we have several
undo technologies available for instance
the EOF comes with an undo package that
is fairly reusable and very easy and if
you look at one of our draw one of our
example to draw application it comes
with a fairly good undo libraries and
we're actually evaluating them too and
put one of them in the kit where it's
available in the framework to any app
and it's really high in our blood over
here I'll be a new software I just have
a short question regarding the
commentary adding scripting support thus
this means that we have Apple script in
the yellow box we're looking at Apple
script strongly because there a lot of
muched word there a lot of people out
there who use Apple script and who have
written scripts and so on now and but
the very first thing we're doing is
getting script ability into openstep
because we currently do not have script
ability I mean maybe hand in hand with
undo obviously because you know the same
sort of mechanisms are used but we want
to get the script ability in the short
term in there so that apps can be
scriptable and then definitely you know
look at the language problem and Apple
script is high on our list however you
know one thing that's not going to
happen hundred percent compatibility
first of all the vocabulary the same the
same underlying toolbox calls might not
the same and you know in addition there
are certain necessary features of Apple
script which probably will not be
sported just because of the manpower
involved but it is high on our list and
we're looking at it Henner so quick
comment my name is Mark Hartman with PDA
solutions the gentleman on the end who
just handed off the mic you might want
to back you yes you mentioned that you
wanted to make sure that we could do
reasonable things with the app kit and I
just wanted to remind you guys
especially the ones that came over from
next that what we Apple developers do is
do unreasonable things because that's
what progress depends on right well you
know what you like we helped you do
reasonable things and make unreasonable
things possible so I think I think the
comment that I'm Peter made in his
presentation is a very beginning which
is making easy things easy to do and
making complex things possible is the
whole under giant paradigm and I just a
little bit of a thing here when we made
the acquisition announced it on back in
December I have to say that my reaction
was fairly negative and I was going what
the heck have we done and I'm I started
digging through the stuff over Christmas
through the month of January and such in
my opinion went from you know oh gosh
well I guess we can live with this -
okay this is pretty good - damn this is
the best thing we could have done and as
I've seen the progress over the app over
the few months and I've seen how open
these guys are I think you're just gonna
be astonished at how quickly this is
going to develop how good it's going to
be and I really just encourage you work
with them communicate what you need and
they'll work to make it possible and I
should I should actually add one thing -
they're a bunch of unreasonable things
that you can do that a lot of them you
know turns out objective-c is a you know
fairly open to runtimes out in the open
there's nothing really private if you
want to I mean
but you know it's like you're going to
discover that their private methods
public messes but they're really only
unnamed because you can run around the
runtime and do whatever you want and you
both can address one buddy I mean I
should warn you that you know doing
those unreasonable things rather than
finding the public api's and using them
will really make our life much more
difficult and also you know introduce a
lot of compatibility concerns which will
make going forward a lot more difficult
so I think that desires wait to go
forward should be communicating back to
us saying there seem to be these api's
are private we'd like to see them public
or you know let's do the addition of
these API that would really be the you
know reasonable way to go here and and
you know with developer feedback it's
probably want to grow RAF City because
you know bottom a lot more developers
out there who've done a lot more than
we've ever seen as next developers and
we want to hear from you so bottom line
is you still will be able to do awesome
hacks from that cat this mic here Sam
Griffith an interactive web systems I
was wondering if you were going to do a
source-level postscript debugger for the
display PostScript system in the past
it's been something that's been very
difficult to debug your graphics so um
we have no one from the tools came here
the nearest thing is it graphics is
Michael but um we'll give it to Peter I
can answer one piece of that which is
there is there was what the display
stock seeing ages ago that was done
under next step and I'm not sure where
that code or who owns it now but we do
have a little interactive program we
call Yap on the system which is a
interactive PostScript previewer where
you can type in move to line two and see
it happen
which is maybe not quite the power you
were looking for but certainly it is
sorcerer yeah I mean we don't I mean
other than this display talk thing it's
actually pretty tricky to to implement
because you end up implementing an
interpreter on top of an interpreter but
Michael is your goal also to make it
possible for people not to have the
right display PostScript
I mean that's what you're shooting for
in terms of Jarek we've got to talk this
afternoon at six o'clock and we'll go
into more detail there okay great let's
push that off to that
Center here with Michael up there
there's obviously some work going on
with GX topography how much of the rest
of the GX graphic slide is going to make
it interesting to learn about GX
topography there's a session actually
it's coming up you speak up
coming up next in the room next door GX
is not part of the yellow box as far as
a graphics API come to the graphic
session and we can talk about that more
there okay far Mike over here yeah I you
mentioned earlier that Apple script is
high on your list can you mention there
things it might be on your list like
frontier or for what else well there's
actually in the in the next step
community I can't remember the name but
no one knows that shout it out but
there's been a number of scripting the
objective-c runtime is so dynamically
bound there's been like objective Perl
and then all these very sorry pickle
tickle you know if you surface the API
in terms of Objective C there's a lot
you can do in terms of scripting so we
actually don't think there'll be a lack
of obstructing opportunities out there
Apple script has certainly been heard
loud and clear as as something we really
need to figure out hand in hand with
that is frontier and figuring out how to
bring that for so you know we'll be
talking to Dave Winer figuring that out
great thanks Senator Mike and then we'll
go over here for one laugh and then
that's it all right general Kenan had
creative got a lot of things to ask
about the imaging tomorrow I'll try to
not bring them up here but actually
today six o'clock six o'clock okay one
the variable well the one suggestion
hold on the one question about logging
made me think of one thing that I hope
you'll consider
if we can't get any more of GX into
Rhapsody we at least consider putting a
layer on the output end of display
PostScript that lets us catch rasterized
shapes as some sort of object perfectly
make build-up display lists from the
output end of display PostScript that
would be awesome technology for the
pre-press industry oh it's just the
comment suggestion text Michael you know
lot of okay so what is the possibility
of that happening I know snowball's
chance in hell
well I there's there's no way that
anybody up here can make a commitment to
do that or not to do that right now and
so you just have to follow up with us
it's good feedback zone and I think one
thing that we have been investigating is
PDF distilling which would at least get
you to a non language saying out of the
solve a language problem the norse
parsing those object far cry from GX but
i guess it's better than nothing for
Mike over here yes you hi Ben wise from
Digital Arts and Sciences Corporation
just a comment I think what a number of
us have been talking about when bringing
up subject like which reject and open
dock is we have a number of technologies
we have a gigantic user base out there
that are all used to having things like
internationalization based on the
Macintosh script manager which handles
Asian multi by characters that it not
far better than anything you've in a
code is capable of and to just name a
few the transparent drag manager where
we can override an app drag tasks so we
can have whatever is being dragged on
the screen being in whatever code we
want to write instead of whatever is the
default and when we say Apple script
we're talking about script ability and
record ability so that no matter what
the actual dialect of the script is in
the users can have scripts made for them
automatically by the
actions and I just want to hear from you
guys that you understand what we're
talking about when we ask you these
things what we're really saying is are
we going to lose capabilities that we
already have had for years that's
clearly not enough not the intention
here and what I mean that's why I
feedback forms like this are great
because we want to hear
I mean clearly we know script ability
part of script ability is record ability
so you know I mean all of those things
are known to us and we're just trying to
we're trying to carve kind of a
pragmatic path through all these
technologies we're throwing together and
I mean last thing we want to do is hold
up getting things in your hands because
you know there's some feature that some
of you might want so we're trying to try
to be pragmatic and some of the choices
are quite difficult but we hope you're
you're patient with us to comment call
so one is you know this session for
example just scratch the surface of
what's in the yellow box and before you
make judgments and decide that
something's in or it's broken or doesn't
work you know hit the other sessions for
example International Tech is next next
door right after this session and I
think would be surprised to what you
hear there and promote the right now let
me just add something to that I mean you
mentioned international text and that's
yours my heart when you say Unicode
you're right Unicode by itself is just
you know it's not doesn't make
International International System but
one thing that we're really happy to
find out that with our text system which
is a unicode days and which is very
expensive and so on combining that with
the international technology and
expertise Apple has we're in fact an
account with something that's better
than both of us had and I think we're
very conscious in that area you're going
to see some great advances in other
areas as well you know we're working
together to do the same sort of thing
but in some case it's not so obvious or
we have to do more work also I think I
think people do understand what people
are asking for and they're making
choices one of the things I wanted I
think that should be really made clear
before we go off the air is that this
you know we're bringing the best of both
worlds together there our next alumnus
working on this team
there are Apple alumnus before the
acquisition on this team people in key
positions nobody has taken over it is a
team working to bring a product to
market I want to thank you for coming
today
encourage you to go to the other
sessions and learn more about the yellow
box and where it's going
[Music]