WWDC2000 Session 158

Transcript

Kind: captions
Language: en
so you're all very welcome here today
it's great to see such interesting that
want the first of two
this week mmm my name is Colin Murphy
and I manage a localization tools group
for Apple so I'm absolutely delighted
and privileged to be here today to
announce two new technologies that are
going to make your lives as localization
tool developers and tool users a whole
lot easier the first of these two new
localization technologies is a project
called Monte it's a codename for a
project we've been working on for about
a year and a half now and the first
version and I'm absolutely thrilled to
be able to announce today this project
called Monte is actually middleware it's
a service data services library which
provides a lot of services and various
features for you the localization tool
developers so the second technology that
I want to talk to you today about is a
project cause apples large version tree
it's a third generation of a tool that
has been in existence for some time but
this is a complete revolution it's a
redesign it's a new modern feel and look
and it handles modern data types and
techniques and so forth so the complete
spectrum of localization tools and if
you look at any modern localization
process you're going to see tools in
many these different types of areas
whether it's in release engineering or
in the translation and localization
process itself and the two technologies
that we were going to talk to you today
about fall into the area of text
extraction and text insertion are
probably more accurately localizable
data extraction and localizable data
insertion so what is Monte well first of
all in order to illustrate this what I
want to do is explain a an industry-wide
problem on the bottom here you can see
that we've got some structured data this
is any type of data probably packed
binary data of some flourish might be an
lib file that might be a resource file
it could be anything and presumably this
structured data contains some
localizable information so it's
information that you want to get out
whether it's strings that you want to
extract to try and
or whether it's bounding rectangles or
whatever that you want to actually
localize for a particular product
another top what have done is grouped
treat different types of localization
tools and together such that these are
the types of tools that actually
typically manipulate those types of data
in a localization process and the first
and type of tool that we have is there
to date editing tools there these are
the tools that are like interface
builder and residents and resources etc
and they typically and need to interface
with this structure data in some format
okay
the second type of two groups of tools
that we have are the incremental
localization tools and these tools are
the the apples lots and so forth to hurt
form the core of your localization
process and the third type of
localization tools that operation on
structured data are and are those are
those tools which specify localization
rules they specified the relationships
and the dependencies between different
types of data to be localized so across
the industry what has typically happened
is that and the tools themselves have
always operated directly on the data
types
they've interface directly with that
structured data they've had to interpret
the format of the data they've had to
interpret which elements of that
formatted data actually are the
localizable ones and have had the
responsibility of extracting and
inserting that data during any sort of a
localization process and this creates a
couple of fundamental problems first of
all what happens when - data changes you
know your engineering department might
bring out a new kind of variant of that
data type to describe new structures or
whatever suddenly the localization -
developer has to go off and describe
that new format either with a complex
template mechanism or revises till his
localization - which is typically what
he does to handle this that variant of
data type and more important what
happens is that the data type changes
altogether so what you've got is you
got for some strange reason maybe it's a
engineering department producing a new
data type maybe you know it's it's Apple
producing new files that may be of
interest like help files or something
like that or might be the industry
actually producing maybe new different
types of technology whether it's xml
files or HTML HTML files etc so the
burden falls on the localization to
develop our art of the process
developers themselves that actually
respond to these new different different
data types so what has happened across
the industry and I've looked at many
different companies and have seen
similarities right across the industry
here doesn't matter what platform you're
working off of the same thing happens
the localization tool development
department are the process people what
they do is they develop new tools to
handle these new data types so what
happens over a tree or a four or five
year period is that you end up with
hundreds of different types of tools all
fundamentally the same the only thing
they're doing is actually extracting and
inserting different types of data from
different types of data forms so what
we've done at Apple is we've recognized
that this is a fundamental problem it
certainly caused has caused me grief
over the last few years as a
localization to a development manager so
what we've done is sat back from the
problem looked at it and said well there
must be a simpler way there has to be a
more efficient way of doing this and
there is and that M project is called
Monte so what we've done is we've
created this middleware and this is a
kind of like a toolbox which the
localization tool developers can
actually build their tools on top of so
what happens is that when a localization
to will actually wants a piece of data a
piece of localizable data what it does
is it asks Monte first Monte then takes
the request takes care of any sort of
translation of script systems or
character formats or whatever it is can
interpret the actual structure of the
data through a very simple translation
mechanism and it's also capable of their
identifying which are the localizable
elements within that structured data so
what it does is it
the data in question presents a backup
through a common API back up to the
localization tools so what you have is
you have something that's actually doing
all the work for you in the same way
when they the localization tool itself
does its manipulation of at the higher
levels presumably it sends it out for
translation the translation comes back
in the translations encapsulated and the
tool itself makes a basic API call to
Monte to read repack that data once it
takes to takes that data itself does any
necessary encodings and script
conversions etc and repacks the data
into that triangle structured form you
don't need as tool developers you do not
need to know what type of data it is
Monte takes care of everything for you
and why is that important well it's
important because the structured data
shown at the bottom of this program and
again it could be a nib file or
resorption doesn't matter what it is
that danger can change can change
significantly and your localization
tools and your process tools and
everything else don't have to change a
very simple translator which plugs into
monte represents new different data
types very very simple
compared to previous and complex
template mechanisms very very simple
model it also handles very modern data
types and object oriented structures etc
so enough about Monte for a second we
get into that in more detail in a minute
so what is a pelage well a lot of you
were going to be fully familiar with
apples large apple Tasha's actually was
a revelation a revolutionary tool back
in 1987 the first version was released
and created a complete revolution within
the localization industry because what
it did for the first time was a created
an incremental localization model and
what is an incremental localization
model well an incremental localization
model is not only where a process where
it gives you where it can extract the
localizable.strings and inserts to
translate strings into your objects it
is actually a process which allows you
to propagate previously translation and
localized information from preview the
previous builds and for previous
releases
and typically these are the information
wouldn't have changed between bells it
also is again capable of extracting and
inserting your clays text so what's new
about Apple gosh
well first thing it's a completely new
application it's designed from the
ground up using modern development
techniques modern architectures etc it's
a carbon based application which is
going to provide M support for all the
modern different data types that you're
seeing under 8 9 10 etc the second thing
is that it uses Monte for all that is
the reasons are just described earlier
it doesn't need to know about data
formats
it basically Monte handles a forest so
it's making a very simple API calls to
Monte Monte is doing all the work for it
so it's the first serious application
that's actually using the Monte
framework the second thing is that this
is actually a flexible framework the
application architecture itself is
actually a base the roundest
essentialized state machine and it's a
very modular in design such that you as
a localization tool developers can
actually create custom plugins into
apple blush to customize this operation
I mean incremental localization is only
one of the things the Apple glut can do
you can now customize by developing
these plugins to a series of SDKs which
you are providing you can actually
create these plugins to interface Apple
lock into very simple are very complex
and localization processes and why is
that important well what you want to be
able to do is you want to be able to use
Apple gosh so she can you know interface
possibly with some computer-aided
translation machine in a different tack
form or a different country or interface
with some article database of
translations somewhere or whatever and
that's what people typically want to do
so what we've done is designed it's very
modular architecture it provides all the
basic functions of glossing but also you
have the capability of expanding it
it's totally extensible and very very
flexible very very flexible very
important for a modern localization
process but do you know what the most
important thing and the most important
aspect of these two technologies are I'm
going to bring up some my engineers in a
second to go true
two types of technologies in more detail
but the most significant aspect of these
two technologies is one we're not going
to charge of fifty thousand dollars for
these technologies and we're not even
going to charge at $6.99 for these
technologies right and you definitely
don't have to buy a box of cereal to get
these to technology because what we're
doing is is completely free we're making
these available free of charge
the SDKs the examples the technologies
who are making them available free of
charge to developers to do whatever you
want to do with them and we have the
necessary support to our worldwide
developer support services and you'll be
able to feedback any comments and
suggestions for upgrades in the future
so what I want to do is thank you so
what I want to do is I want to bring and
the chief architect of the Monti project
up on stage Krishnan March to go through
the finer detail of what Monty is and
what is going to do for you thank you
[Applause]
hello so I'm going to talk to you in a
bit more detail about the Monty
technology that Colin was given such a
excellent sales pitch for so first of
all first of all technology
first of all what is Monty well Monty is
the foundation for the next generation
of localization tools inside Apple and
we're hoping outside Apple as well it
provides data extraction and editing
services to any type of tool that wants
to use them now this it may not be just
in the localization area but also for
data editing tools for example so the
main features of Monty are first of all
the big thing we're going to provide you
with a way of developing your
applications quicker and that's always
good
because we put in a lot of effort into
getting the data extraction and
reinsertion features of Monty working
you don't have to so you can just take
our work and build upon us and
everyone's happy
second Unicode support we are fighting
support for Unicode in Monty if you've
seen any of the other sessions and I
hope you have you'll know there's OS 10
is Unicode based the future of the Mac
OS is Unicode so we're providing you
with a way of editing creating
manipulating Unicode based structures
third we have support for
object-oriented data structures all
modern software is object-oriented the
data structures the juices are also
object-oriented this means we need tools
that support them unfortunately the
current generation of localization tools
don't deal very well with
object-oriented data Monte hopefully
will change this and most importantly we
were insulating your tools from any
changes in the format of the data they
need to manipulate so so looking at
Unicode support of Monty you can see
there's in title Monty which is the two
boxes in the middle in this diagram you
can see that Monty by providing the
extraction and recoating services into
Unicode text for you insulates your
application from the details of what a
macintosh roman encoding is or what big
five encoding is on the other end so for
the tool developer they just replaced
the text their sample text with its
equivalent in chinese and let monte
worry about the recoating and the
repacking so if we look at Monty's place
in a typical range of localization tools
we see this
Monty's purpose is to take the original
package data structure and it converts
us into
there's generalized representation which
is a tree based representation let the
blue box in the middle from there the
different classes of tools can either
modify or edit or just look at us
for example workflow and localization
tools our workflow localization tools
generally don't need to make any
modifications they're just there to
count strings layouts and provide some
sort of estimates as to how much work is
involved in the localization so they
will read the data only
but because Monte provides all this
extraction services they can produce a
better estimate of the workload involved
in their project localization tools then
we'll typically extract some parts of
the information either a layout or just
simply text send it off to be translated
and then reinsert that information again
and that's the middle purple box up
above and then the last two which are
probably the simplest are the data
editing tools they just open the
structure look through allow the user to
make changes and repack the whole thing
and when the changes or whatever have
been made Monte also provides the
features to get our the facility to get
from that internal representation back
to a packed binary data structure if the
same for most of the original data which
the tools didn't even need to know about
so how Monty gets from a packed binary
structure into a generalized
representation is by means of what I'm
calling it as a disaster it has a
translator file oh yeah that's a
translator file is an object-oriented
data description
it's a text-based description of the
data but because it's object oriented
generally we have very simple
translators but we use a lot of them to
define structures we do this where we
have substructures list items or any
kind of common sequence or macro
sequence within the data structure we're
also using inheritance which means that
if you have one data type that is very
similar to another but with the addition
of a several fields then you can inherit
the new type or you can hurt the old
type when you create a new type this
means to modify your translator to deal
with a new type you typically only have
to add one or two lines to the data
translator now you don't have to edit an
8000 line template file anymore
which means which means yeah which means
we can finally deal with P pops easily
come back to the keyboard so we look at
a sample - a translator for a very
simple data structure you can see that
main points first of all that this
structure is a text or the translator is
text based now doing this allows us to
extend the translator language in the
future which was a problem we had with
the template mechanism that really
wasn't able to be extended very far so
if in this particular structure here we
have six fields and they're each
represented by a line and the translator
we've labeled them top left right bottom
this could be an item within a graphical
user interface at layouts and has some
text and has boundary
bounding box it's a very simple
structure it's probably so simple that
you never come across one in real life
but it fits on the slide so but most
structures are more complicated than
this and the first level of complexity
away from this is lists of items but in
Monte when we define a list we use two
at least two translators first of all we
define a translator for the list items
and then we can include those into the
larger enclosing translator which
defines the the item the entire
structure so for the example here we
have a very simple styled text type
resource or tiled text list item and
this could be for a font menu or it
could be for anything that needs to
gather a list of style texts and we
first create a translator for each
individual item and in this case there's
an integer font ID and followed by a
string with the text of the item then we
can include that translator to define
each item of a list of the list of items
and that's the second translator does
and you see the reduces the list
commands to include the first translator
this way this if the list item changes
we don't have to change the simple list
translator
we just need to redefine the structure
of the list
and it's the time-saving again
especially if those items appear in
other types of structures on their own
or in different arrangements you change
in one place the next problem we have
typically is this a list of voya items
where all the items are the same is
quite rare in even the simplest
structure like a digital resource from
the classic world we find that there are
different types of data and they're
identified by one or more key word
values so in Monte we refer to these as
variant structures and I've shown two
very simple variants up above where the
type of the structure is decided by the
value of the first field now one is an
item a textual item the other as a
picture item there could be other fields
but to define this in Monte we first
declare make a translator for the basic
type these are the fields that don't
change no matter what the format is and
in this case there's only one field that
doesn't change it's the first item which
identifies then having done that we can
define variant translators by just
saying that this translator is a variant
of the basic translator where the type
field is equal to 1 2 or anything this
Monte uses this information when it's
presented with a block of data it uses
this so that it can yeah it uses this
information to decide which format of
the data it has and generate the proper
information
so no more case statements you're
actually dealing with actual structures
so I've only shown a single layer Y of
level of variance here where we were
deriving two variants from a common base
but it's possible to derive a variant
from a variant from a variant and build
up entire frameworks of translators and
a very important framework for a lot of
you is the power plant one which I'm now
going to demonstrate thank you
right so I could show you a more
complicated translator file and you'll
see why it didn't fit on the slide so if
we look as we have a basic set of
powerplant
P pub templates defined using the Monte
translator language if just out of
interest you see the lot and make use of
inserting existing types to the finest
for example this L text column class is
four lines long it's definition the old
template for this class would have been
20 or 30 lines long so by making these
translators smaller they're easier to
debug you're building on existing work
you don't have to try and debug the
whole 8000 thing line thing every time
so I have an application here that I
know has a custom type finish and the
custom type is a class with the IDE RCL
now the existing templates don't include
this but I can just produce a definition
by looking at the C typed or talking to
the engineer whatever we normally do and
adding this new type I know that this
type is based on the text column class
which I just showed you so I but it has
the addition of an icon ID so I've got
to add this field here and I'll give it
a little label
let's leave that off and now I'm going
to show you a little tool that we
developed pretty quickly just to test
the Monti API and to show how really
easy it is to produce applications
developed are based on this technology
this is simple data viewing application
and I'm going to use it to open our
little power plant application and have
a look at the pea pumps inside us in
fact there's only one peep up but if we
look down the list this first element
here is defined as a see error table
which was the class that I've just
defined with my one line and right at
the end these are all the information
that came from the original column view
and there's the fields that I added the
icon now to implement that new type I
just had to add one line and create a
new translator file because this thing
was in a separate file it's easier to
version controllers because you're not
modifying the same translator over and
over again and you can create translator
files for particular projects and manage
them better but that's about that so
come back to the
look all right now because it's easy to
add new data types we have another
problem which is more problem of success
than anything else that will sooner or
later end up with about three or four
hundred different data translators so
we're nearly back to the situation we
had before where the tool needs to know
about every single data type because all
of these types have different field
names different structures and they're
different things that need to be taken
out for example the localizable text of
a button could be called title whereas
the localizable text of a static text
item could be called the text the tool
would need to know this information well
it would if it wasn't for Monty because
Monty provides a mechanism of mapping
complicated data types into a set of
standard properties which tools can then
use to extract for example the
localizable text so we'll take two
structures here where they have very
different internal structures bus in
both cases there is some element of
localizable text but what we can do is
we can define a Monte translator that
says for structure age the fourth
element is the localizable text and for
structure beads that are adult now tools
can just look for the local text
property and say I want that or I want
to change that or let me do this and
that we've defined several standard
properties with Monte for things such as
localizable text in bounding rectangles
and all suggestions are welcome but the
ideas that keep the names consistent so
now we can treat very different data
types basically using the same tool and
now the tool doesn't even need to know
what it's dealing with if the tool is
lifted away from needing to know about
add it'll or a power plant layout and
now it just knows I have a layout with
text and bounding rectangles so I'm
going to show a little demo of using
this
so I have a very very simple application
here and that's what it says hey that
took months that did okay so I also have
an Apple script and that Apple script is
going to interface with an application
that we've written that provides an
Apple script interface to the Manti
library and what it'll do is it'll open
that applications little resource which
was the source of that message and
changed the text of the items and
resized the button and I'm just going to
run this and it's going to ask me for
the application that I wanted to change
which is this simple application missus
run it's done now I'm going to launch
the same application and it's been
translated in notice the button has also
been resized
but this Apple script didn't know
anything about the digital format if we
look at the script again the brains of
this is down here and basically it asks
for two properties it asks for the name
or it asked for the locale text which is
the localizable text of the item and
changes it and then it asks for the
bounds of the box and changes that the
script doesn't know that that was a
little it just knew that it was a layout
with text and bounding rectangles and
this is one of the things you can do
with Monte so if you have tools that
need to work on layouts then Monty is
going to make these a lot easier for you
if you have data editing tools Monty is
gonna make it a lot easier for you in
fact Monty is going to be pretty useful
if you're involved in any kind of
localization so we hope you're going to
use this now then go back to this
and one of the applications of Monte
which I'm sure you'd be very interested
in is Apple droite 3 and to talk to us
about this we've got Mike Butler thanks
hey you hear me yeah so what is Apple
got 3 I'm sure most of you know what
Apple ID is so you don't really need me
to go through that but just say that
Apple got 3 is still a text extraction
and insertion tool it still performs
incremental localization but as condom
said the important thing is that it's
completely new we've thrown away all the
sources we've start from scratch so all
those problems you've had with applet
we've had a blank sheet we can start
again decided how to do properly so what
are the benefits of apple graph 3 well
the reason we're all here this week is
Mac OS 10
so applet 3 provides my co-host and
support but as Colin said Apple got 3 is
a user of Monty and Monty hides all that
low-level stuff for us now we no longer
care about data formats all we need is
get Monty to look at our data and decide
that's localizable so it could be oh Sh
OS 9 r OS 10 all right we also have full
Unicode support and as Krishna also said
Unicode neatly gets around a lot of the
encoding problems that you normally have
besides this it's one of the base
technologies of our Stan and it's also a
base technology of Monty itself we know
that and performance is a big issue for
a lot of Apple users but if you think
about it Apple glad has been around
since 87 the files that app about used
to process back then were in tens of K
hundreds of K now they're in tens of
megabytes and up a block just wasn't
designed to handle that sort of data so
we started scratch so we can we've
designed we've used modern technologies
like Monte and we've used modern
techniques to solve these problems we
also know from talking to you that Apple
art is not so easy to use
so we've designed a modern unison
interface and whatever we could make
automate of a to take the dredge out of
the work we did and whatever we couldn't
we made it easy to use but we also made
it as safe as possible we have a number
of versions of the same file hanging
around we want you to make it impossible
to choose the wrong version and this is
the biggie you made it extensible and we
didn't want to be back here in a couple
of years going everything's changed
again and we needed to do a flick off
from scratch so we've made a plot
scaleable in the first night case but
we've also made it completely modifiable
if a new data farmer comes along well
Monty you look after that first but if a
new process comes along if you want you
to do something different well then you
can modify Apple like yourselves to do
whatever you need to do as common said
if you needed to link up with the
machine's translator then you can do
that yourself
so before one you can look at Apple go
from two ways you can look at it as just
a user I want to use Apple got three
just the way I've always used up with
let so I just look to some of the you
new UI features that were we have an
appetite but you can also look at it
because it's so flexible you can look at
it from a developer it's almost like a
framework for localization tools you can
decide I want to do something something
completely different without a lot you
can do it chances are you can do it so
we look at that in the second section of
the presentation so some of the main
features is the UI and we have automatic
and intelligent foreign matching if you
have a project of say 100 files and you
have four very well if you're localizing
in under iOS 8 or 9 you'll have four
versions of those files hanging around
you'll need to match all of them up
together to perform incremental
localization if you have OS 10 you'll
have to match up two versions of each
file obviously you just takes quite a
while and so Africa 3 provides a couple
of different mechanisms first it will
provide automatic and matching if I can
where can't it will try to intelligently
match the files and we really can't
match any of the files at all it'll let
you do it but first it makes it easy and
second it just won't let you or we'll
try not to let you choose the wrong
version it should
make it a lot more safe again if you
have large project say for example the
system folder you're not going to work
with all of those files that won't go
you really only generally going to work
with a small section of them so again if
you had a system full you might only
work with the control panel so you might
only work with the extensions so we've
introduced the concept of file groups
and this just lets you group your files
together you can look at all your files
as normal under a cloud 3 or you can
decide I just want to look at the way
one of my groups so I only want to look
at saving my control panels or I only
want to look at my extensions so file
groups allow us to do this we wanted to
make the UI itself extendable so we've
added script support and you can run
scripts yourself so you can choose a
number of files inside applet and run a
script under those files or you can run
them on all the files in the new lock or
whatever you want to do you also added
external school support so if you want
to view files in external tools
interface builder or resource or
whatever and you can just choose it very
easily with about 3 and 2 sports some of
the stuff we've extended the environment
we have a couple of new folders in there
to handle say plugins and scripts that
I've talked about but we've also given
it a distinctive icon to make it easier
to recognize and we've made the folder
itself intelligent so you know if you
drop and support files on the folder the
environment folder they'll automatically
get put in the correct subfolder so if
you have it's like the system folder
again if you're dropping on control
panels on to the system folder they go
into the control panel folder you drop a
plug-in on the environment it'll go into
the plugins folder so I have a tool here
then which we use to test Apple ID
itself
but it contains some of the features
that I've just described and may make it
more clear so I'm just going to choose a
small environment here in this window
would look pretty similar to what you
normally see what up a glutton huh oh
sorry can you switch screens
okay so I've just opened actually I'm
drawing the grammar there they'd open up
a small environment first
okay this looks pretty much like your
old epic lot and we have our four
columns representing the four files that
we need to perform incremental
localization under OS 9 and as you can
see epic lot hasn't been able to match
some of the files and it's done one of
them but we need to do match some of the
others ourselves now if this is
applicable that we'd like you'd have to
go off into another file all your files
would be sorted in a different order and
you'd have to use standard file dialog
to choose whichever file with applica
lot 3 we have Excel contextual menus so
you can simply go down and choose a file
but you're only presented with the
appropriate files you're not given a lot
of the files there you just did the two
that in this case are available in the
new lock folder so I can simply just
choose the appropriate file now you can
see that it's been able to make an
intelligent guess at the old lock
version but this also fills out some
more information so it's being able to
guess at all the other ones as well so
it's not a little bit of automatic
matching for you but you've done some of
it as well so just take a look at a
slightly larger environment
go to the demo okay it's probably a bit
more normal you have a whole load of
files and there's a lot of information
here so as I said we have file groups
and this is an environment I've used
before so I've set up a couple of groups
myself I have a control panels group an
extension group so I jump it simply just
select one and then I only have those
three files I can work away on those I
can process them as I want all right I
switch over to my extension files do the
same and when I want to batch all of
them together I can simply show all of
the files and do whatever I need to do
but we've matched all the files here so
there's a whole lot of information here
to be don't need we don't need all these
the tree columns on the right so we can
shrink it down to just show one column
as my hair dry students that is my hair
dry but it's not that slow don't worry
ha okay well it was a test - it's not a
real application anyway what would have
happened there was that you just see the
one column you could resize it as and
all you'd have is your one set of files
so I just go back now to the slides so
as I said the the UI is not the big part
of cupola 3 it's the architecture what
that allows you to do so if we'll just
take a few look at that now and Monty as
I said we use Monty so that takes away a
lot of the icky low-level stuff first
that leaves a bug light itself being
much simpler and much cleaner so and
that leaves with a plot being say a set
of managers that provide services and
just the state machine the managers
provide services like managing the
environment for you they manage plugins
they manage the errors and lugs and
stuff like that but the power comes from
being able to write your own plugins you
can write a plug-in that will change the
way the managers work so you can read
plugin that would chase a change the way
the glossary manager works so instead of
coming back with just one translation it
would come back would say maybe flavor
the closest matches are go off to a
machine translator and pull back and
translation from that similarly the
state machine processes the files for
you but you can write plug-ins that
would fit into the state machines so you
can change the way the state machine
works so you can if you want to handle
the particular data format a different
way yourself you can do that just by
overwriting the normal default behavior
of the plugins now there's no UI shown
here it's completely separate it's just
a user of a padlock there's just a user
of the services so you can write your
own UI or whatever you want to put on
top to control it the way that we
provide well that also has plugins so
they just let you alter your own plug-in
behavior or let the user alter your own
plug-in behavior without you having to
write user interface code yourself so
just to look that in slightly more
detail we have the state machine of the
managers which make up Apple ID itself
then we have the plugins that the state
machine uses to alter the behavior of
the
a machine now how it processes files and
we can also see here of our Monty
fitting Monty fits in under under the
plugins so if your plugin if you don't
want to use Monty as your your based
technology you can go do whatever you
want but obviously we believe Monty is
the best thing to do
the managers manage the environment for
you and you can write plugins that will
change the way the manager works anyway
just sits on top of it all and you can
write any other entry you as you want so
you can write a command line interface
package the whole of upper glut up and
use it as part of the build system or
you can package it up with Apple events
and just use it completely from scripts
if you want so just go through some of
the services we provide we have
environment services that I mentioned
these just manage files they do the
matching of the files for you if you
want we have glossary services and these
look after the internal glossary so they
look good look after and we're looking
up translations or and start asking for
translations like that we have logging
services which just log errors and
warnings and our ever notes you want to
log we have plug-in services now you
would normally use these up you like
himself uses be used to manage all the
plugins but if you needed to control the
plugins yourself you could do that and
finally we have state machine services
so this just lets you control the state
machine start it off stop it and get
information from it so to think machine
itself and a bit like the passes you
have in the current a burglar and it has
three modes of execution we have
extraction where you would run to the
state machine just to extract data we
have insertion where it just runs two
distinct machine to insert data and we
have a final mode which Appa got three
itself doesn't use but it's there after
any plugin who ever knew anybody who
wants to write a plugin he could maybe
do verification our tidy up or do
whatever you need to do after the file
has been created so state machine itself
is just like any state machine it runs
through a series of states it completes
everything it needs to complete in one
state before moving on to the next the
states are came they're separated out in
three we have pre processing the states
and these are called before any
processing is done obviously and so
you'll be called say before if I let has
opened be processed you would be called
before
a clicker datatype is processed or it
would be called before the individual
piece of data is processed we have the
data processing state itself where your
data extractor and start data and we
have the post processing states and
these states just give you a chance to
clean up so after the data type state
you can maybe get rid of the translators
or the templates which are and after the
file state then you may be close to file
or do whatever you need to do to tidy up
after proceeding left where the states
themselves don't contain any logic all
they do is they correlate to all of the
plugins register to be executed in that
state and they execute those data
plugins in order before moving on to the
next stage where they will execute all
the plugins that are registered to
execute in that state and I will keep
going on as it moves through all the
different states in the state machine so
two plugins themselves a padlock comes
with a set of default plugins and these
implement the normal behaviors that you
expect up a lot to do and but because we
have these as plugins you can just very
subtly override what it does by
providing your own plug-in that does
something but doesn't do affect any of
the other behaviors or you can ditch
them all together and do whatever you
need to do yourself
one single plug-in can act as a number
of different plugins so you have one
plugin that may be a state machine
plugin or maybe a preference panel
plugin and it's nice for packaging up
your plugins if you want to send it out
or it's also handy for passing
information between plugins so two types
of plugins we have as I said we have
service plugins so glossary plugins
again you're managing your glossary so
you can change the way the glossary
lookups are done an example of that as I
said was fuzzy matching our machine
translation weave glossary file plugins
this just manages the way the glossary
is written to disk so if you don't like
the way up a lot writes what the
glossary chat is you can maybe write it
as an XML file our record in some form
that some other process needs to use we
have log exporters so if you like
writing a log exporter plug-in if you
want your errors and warnings to go
through the screen so the user can do
something straight away but you can do
that or you can even go out to the files
normal
we have state machine plugins and as I
said they altered the way the state
machine behaves and we're gonna treat
that we have preference plugins and
these just let you give the user a user
interface to choose what it wants to do
with your plugins without you having to
race the interface yourself so the
things to take away from Apple grab
three apricot three works simply and
efficiently with Mac OS 8 9 and 10 Apple
R 3 can be customized to fit your own
requirements so you get a plot to do
what you want to do you don't have to
fit in with the way Apple art works and
I put about three well the UI has
evolved but we believe that the
potential with the architecture means
that it's a revolution and we believe it
is as revolutionary as the original glad
itself so I just like to welcome coming
back onstage to run through the more
information and to get the questions
answered started thank you okay thank
you so and I hope - and these two
technologies that we're making available
- you're actually going to be useful
within your processes I know that's
certainly going to be useful internally
in Apple I mean our own localization
processes so and you know there's
certainly plenty of information we could
go into an awful lot of depth here I
don't think it'd be a value of this
stage but and these are fairly complex
and applications and tools here and but
we've provided very very simple
interfaces for you as the user of these
and technologies and so what we want to
do is we're going to make available and
quite extensive examples application
sample applications and UI documentation
SDKs etc and we're going to make these
available to you troodon the normal wwm
DRM websites and we also have a contact
manager as well for who's going to
basically handle all questions and
comments and suggestions which you may
have and I actively encourage all you
users of these particular technologies
to you know send your feedback send your
comments to us and we'll certainly
respond to them it's only by
you know and getting us the information
and the suggestions that were actually
going to make these and evolve these
into even even better tools and
technologies so and what I want to do is
just give you an idea of where these are
in the development cycle first of all
Monte is almost GM in the next couple of
weeks you're going to see this
information become available on DM
developer.apple.com websites and the
information we provided up there we
packaged in the format that you require
the Apple's framework itself were
actually currently just finalizing the
internal architecture at the moment so
in the next and monitor so you're going
to start see the first am alpha and beta
applications up there and they actively
again encourage you to take those
applications use them for you know
whatever you want sample projects are
live projects give us the feedback
because and this we we have a fairly
aggressive GM target dish and in a
couple of months time and we certainly
want to incorporate as much features
from you from you guys as possible and
we also actively encourage you to start
with the D SDKs look at how you can
actually customize the operation of
particularly apple collage and how you
can get that working more effectively
and efficiently in your process so what
I'd like to do is just point you at a
related session and immediately
following this session we've got a Mac
os10 localization session session one57
following in this hole and encourage you
to attend that session also there's some
very valuable information to be learned
about what you need to do to localize
retain and and do same that session is
going to run for approximately an hour
and a half also so what I want to do now
is actually I know a number of you have
have questions so I'd like to encourage
it
you