WWDC2000 Session 406

Transcript

Kind: captions
Language: en
my name is andreas venca I'm one of the
managers in the web object engineering
team and I'm responsible for the
development technologies and right now
we have two technologies that fit into
this category it's directed at Bend dr.
Java client so I hope that most of you
just joins the last session the brigade
is about cadet and it's not my pleasure
now to talk about the Java client so dr.
Java client is one of our newest
technologies you just chipped it a few
months ago the first time in the lease
for five and it has a very similar
purpose of story to verbs but it's
targeted at a different kind of
applications it's not used to create
Internet applications or web
applications that run on the web browser
it's used to create desktop applications
that are useful in the Internet so what
I'm going to show you is the dr. Java
kind is a very very strong rapid
development technology for desktop
business applications you will see that
the Java track a dollar sign is nearly
ideal for prototyping purposes and later
Java kind is not just you know a cool
visit that makes a nice demo it's
actually very serious stuff that that we
very helpful in your user applications
so what I'd like to talk about this I'd
first like to give you a short technical
introduction into directive Java client
then give a demonstration of about a
typical development process then talk
about the very important topic of
customization give another demo about
with an application that uses various of
our customization techniques and then I
give you good few good reasons why you
should why we think you should use the
Java client and then have summary end
Christian answers okay I first would
like to talk about a typically typically
application architecture of the object
applications and they are usually in a
usual scenario there are three tiers one
is the database then the second T is the
web objects application it's safe it's
the application web server and the third
T is the client the 2g is a bad problem
so the applications are started when the
user types in the you are a right which
sends an HTTP request to develop this
application and then the the top of the
web of this application is to create the
HTML page that is supposed to be
displayed in the browser
and in order to vote for the for the
application server to generate this HTML
page they usually have to retrieve some
data from the database so we would send
some SQL to the database which results
in the fetch and the database gives us
the data back in a format that we call
raw rows so just the raw raw data such
as tables and columns and then of
objects will actually take these destroy
data and map it into business objects so
we use the file that because the EU
model and and we talk it was probably
mentioned a couple of times already in
the previous sessions about the objects
the year model describes the mapping
between this raw data and the business
objects that you have so and the nice
part about web objects is that you can
determine what kind of classes are used
to represent your your data and so what
that means is that you can embed your
your business logic directly into the
object that represents the data so if
you want to write validation code he
will do it inside these objects and
anyway they've upped its application but
then you know create the HTML page based
on the business object edit page and
then create HTML send it to the browser
and it will be displayed now that is the
usual scenario in which web object is
used and the doctor is doing a great job
in serving these kinds of applications
but there is a problem with it and the
problem is the browser right mhtml based
applications are not very user friendly
applications and what what the more
context your data gets you would the
browser gets get some or to represent
this application the browser gets more
and more complicated you will end up
doing a lot of navigation the data is
highly structured and and you can only
do one task at a time
so the browser start with a very good
tool to run complex business
applications and so we have the second
technology in the boxes which is called
Java client and in the Java client
scenario you pretty much kick out the
web browser right and replace it
you place the client that the full java
application that is based on unseen so
the JC digit classes
and so that allows you to run
applications are bit smarter windows
motor dialogues
menus everything that you expect from a
user-friendly application so the typical
data flow is pretty similar Java client
applications also use HTTP as a
transport layer for connecting to the
server so when the application starts up
if you send an HTTP you access to the
application server it's probably resides
in the fetch from the database then on
the server side
we met the raw data from the data
against Business Objects and then
something different happens we don't get
generated HTML but we actually send
these objects as a copy to the
client-side so the missing piece of
information here is that we actually
replicated a lot of the functionality
that we have on the server side
to deal with business logic for the
client side so you can view this
Business Objects on the client side in
the same way as to deal with them on the
server side and since the client side is
purely written in Java its platform
independence you can manage on Windows
you can run little necklace 9 you can
write on records 10 now to develop them
a Java client application in the
traditional way you will find you pretty
much like we have logically pieces for
your application first of all you have
to create a database and you have to
generate a new model that describes this
database and and you probably also want
to write some business logic food so
this is kind of one unit then it's a
second step and I'm probably not going
to I will not be able to show you there
today but the second piece of your
application is the user interface and we
provide you with a graphical user
interface editor which is called
interface builder which you can use to
generate windows and to draw text fields
in it and Labor's and buttons and table
views and other stuff so these these
interface files are the second unit of
your application and second part of your
application and you probably also have
to write a little bit of logic around
this user interface to for example react
and other kicks and pay reviews also and
then the third part of the application
is what I call application logic and
that is all the code that you need to
connect the various using the
components of your application so right
that if you press a button and one they
know that another window open side so
all this code that connects that various
pieces in your application that's what I
call application of it now that's a
problem with that and this problem is
that these pieces depend on each other
if you change the database if you change
your model then you will also have to go
and change all your interface files if
you have a localized application but not
really interface files for the different
languages it even gets worse right then
you have to change my two interface
files just if you change your database
and the worst case is that you might
even have to change your application
logic because then you might even have
to you know open different windows
depends on how complex your changes so
the maintain is cost that you have for
these kinds of applications is pretty
high another downside of this is that
unless you do blackity simple API
testing of your business logic testing
is pretty complicated you need all you
need all these three pieces so you have
a long bootstrapping time yes you first
have to sit down and write code for all
these three pieces to get something on
the screen that you can test and but
obviously that's pretty bad for
prototyping because you you waste a lot
of time so when we ship the Java kind
technology the first time in in for
which is under a few years ago no I
think we we thought it's actually pretty
complicated to create an application
right I mean there are lots of steps
involve just to bootstrap this
development process and we want to do
something for you that makes it much
easier to develop these applications and
so what we came up with this direct Java
client and the idea behind directed Java
client is to generate the application
logic and the user interface dynamically
for you just based on the you model like
we do it in directive F so the advantage
is that you can sit down and develop
test and produce your business logic
without wasting any time on user
interface development or writing your
application logic but you can really
fully concentrate on the business logic
and then when this is done you know when
the business logic is kind of finalized
then you could go ahead and and invest
time into the user interface so the
kinds of stages you go through if you
use direct Java client is that like the
traditional development you would have
to create a database and the model and
some business logic around it
and then you take that and stuff it into
this dynamic application engine right
and what you get is a default
application very similar than the like
the standing interactive app so this
default application might actually
already be good enough to show it to a
customer how to it can actually act as a
force the first prototype already but
you probably want to tune it a little
bit and do some relatively simple
customizations for example change that
our selection of properties that we use
to query for data object or you want to
maybe just you know change the order of
text views in the user interface stuff
like that and for that we provide you
the tool which is called the assistant
similarly to director bet and the dis
assistant you can do these relatively
simply customizations and so you will
end up at the customer application and
our recommendation is that you kind of
stay on this level as long as possible
right and first invest the time to
implement your business logic and then
be assured to your customer again and
again and he's finally you know contend
with to the business logic happening in
your application then you could go ahead
and polish it right and and make you
know for example layout changes that are
very specialized so I will show you
sounds of it so how do we generate this
user interface and the first thing you
need to know for that is that we on the
client side provide you with a bunch of
objects that we call controllers and we
have controllers for all kinds of tasks
one controller is is the application
object itself
the application object the update that
is responsible for bootstrapping your
application or it's the object that has
the main function that starts the
application and that takes care of of
you know opening the first windows and
it's also kind of the central point of
contact if you're looking for other
controllers and other windows in your
application then we have purely user
interface related controllers for
somebody every window controller right
there knows how to how to you know react
on changes in the window that the user
presses the close button also we have
tab view controllers all the stuff
another
type of controllers and controls that we
called entity level controllers so these
entity level controllers work with your
business objects under the level of the
object it said they define how you can
query for object or you can edit them or
how you display them in the table in the
list and then the fourth type of
controller that we have is called these
called property level controllers and so
they also do with your business object
but they do just one property at a time
so for example a text view controller
that just displays one actually like the
name of a customer right or extra
buttons or things like that so now this
controllers not only know how to you
know react on events that that are
triggered and user interface for example
button shaker so they also know how to
generate the user interface or detects
the controller knows how to create a
textview the window controller knows how
to create a window and then they also
know how to lay out the list of the
views that are generated and in a
reasonable way and the most important
information for them to do the layout
it's actually that the controllers are
organized in a hierarchy so the easiest
way for me to expand it is probably by
taking a look at an example so if you
take a look at this window here you see
that there's a toolbar in there it has a
text field and the tab view the two to
two views in it and so the route
controller for a window like this would
be a window controller alright and then
inside this window via the toolbar
controller so the toolbar controller is
a sub controller of the window
controller and then inside there we have
a text field and the tab view and as you
can see in the tattoo we have two more
viewers one is for the roles one is for
the plot summary and so in the Royal
view we have table view with two columns
and in the plot summary we have or you
can't see it but it would be reasonable
to assume that they have something like
a text area they display to see on a
larger text so the the hierarchy of
control is pretty much also reflects the
view hierarchy that you generate for the
user interface now so we know what kind
of objects we generate we use on the
client side to change the user interface
but the question is still available
objects come from and the answer is they
come from the server and the reason for
that is
most of all well I would say security
and and saying about performance so the
server or as I said before the user
interface is generated based on the ear
model right and so to generate the user
interface and society of controllers we
have to take a look at the model and
this is information that we for sure
don't want to send to the client right
because it would be very unsecure and in
addition to that most of the user
interfaces are the same for all time
kinds of clients so if you generate the
sake of controllers on the server side
you can do it once and then we use it
for formal fix lines so the format that
we use to describe the sake of control
is this XML and I gave you an example
it's actually pretty much the same
example as this one here so you would
probably see that so we have a window
control a toolbar controller right so
this is the hierarchy of control as
described in XML so like interactive app
on the server side we use a root system
to generate the set it's this XML
description of the user interface and
for now it's good enough if you just
keep in mind that the root system is is
customizable that you can plug in your
own rules and but okay so you can pack
in your own words but that X should be
provided that's a huge set of default
rules and so these default was analyzed
the ear model and then try to come up
with the reasonable user interface for
the data and the first thing they need
to do is then do categorize the
different entities that you have in your
ear model and we pretty much have three
we distinguish between three kinds of of
entities one we call the main entities
the other one we call you numeration
entities and for the third time we don't
have a name with just everything else so
main entities represent the the the
business objects that are kind of the
primary object in your database
typically examples are a customer write
an object is an entity that represents a
customer that's a typically main entity
but on the other side the address is
attached to the customer or maybe the
phone numbers attached to it right that
is kind of secondary information this is
what's called the other stuff and then
it also turns out that most databases
have
actually a huge number of entities that
also match the definition of a main
entity but they are much simpler they
are just usually just useful for pig
lists so examples are the 52 States of
America right or another example could
be a category for a movie that it's a
drama or that it's a comedy alright so
these kind of pick lists they are
usually stored in in very simple data
database tables and the real vibe you
distinguish between them is that it
allows us or it actually makes sense to
create two different kinds of user
interfaces for for these Maenads
numeration entities and four main
entities will create a query window and
that allows to search for four objects
and then from this query window you can
open other detail in those right and if
you need to select one we have more a
dialog for you and for enumeration that
is we can make that much simpler because
usually there are only a few objects in
the entity right there only 50 to 52
States and so for in variation it is you
create a much simpler editor window and
then we need to select a reference then
we just create the combo box also to
display them but if you don't need a
full window and the query interface for
that so on I'd like to also give you an
example about that and have something
that looks similar to an entity
relationship diagram here and so this is
this is pretty much a subset of the
standard movie went to the example a
little bit modified to make the example
to do clear so we have a you know pretty
much we have a talent in there we have a
movie entity in there the movie has a
category and then attached to the movie
here at the top summary and voting and
so when the default would start
analyzing this this database scheme
let's say they started telling photo
they will fight these two photos just
find out that the talent for the actual
depends on the dead end right there's no
reason to have it or there's no you use
for having Italian folder without the
talent so the default would analyze most
of the relationships between these
entities and then in this case they've
come up with the two major groups one is
is the group around the talent window so
on the talent entity so telling this is
what the default was identified as a
main entity and telling total a movie
role depend on it you know at the second
group
it's around the movie so the drop
summary and devoting I attached to the
movie and the movie role actually
belongs to both kind of groups right so
then we edit the movie we want to see
the information about the movie roles so
what kind of roads they played in this
movie on the other side if you take a
look at the tail-end we also want to see
what kind of roads Stalin say and then
the third group is is actually this
category which which matches the
definition of an enumeration entity as
you can see it just has it has a primary
key and then just just a name ID so it
could be a drama or a comedy also so the
default words wouldn't identify two main
entities in this case and one
enumeration entity so now we have pretty
much all the pieces together to take a
look at the complete director Java
client architecture it's still a
three-tier architecture we have two web
objects application and we have a Java
client education but but both on the
server and the client side we have
extensions right the extension on the
server side of the moon system and the
extenders on the client side all this
view controllers that is scribed before
now there will be a difference when the
application starts up because there is
no user interface defined for the client
side like in the traditional development
they create your interface files and
interface builder so the first thing
that has to happen is that these
extensions talk to each other and the
client ask the server so what kind of
user interface tell a display write what
kind of Windows shall I open then the
application starts up so now the rules
are simple we'll take a look at the ear
model and they you know just create this
XML description of the windows that are
supposed to be shown on the client side
the client side will keep track of all
these different windows right keep it in
mind and be able to to use a bit this
next my description this is pretty much
a template for creating you know the
hierarchy of controllers and so so the
clients have to keep that in mind and
then later when the user trigger
searches on the database you do another
request to the server side which will
probably result in fetes in the database
to get business objects so they're sent
to the client and then to use it stuff
so the difference between a normal or
traditionally developed application and
the director Java client application is
that in addition to exchanging objects
and information about the object you
also have to exchange information about
the user interface or the service
responsible for generating the user
interface on the client side okay so I'd
like to show you how the looks
okay so what I have here is a mecha
stand server machine web object for five
and I'd like to show you how to create a
director Java client application and
when you look over when you join the
dock to that session you solidly have a
visiting project builder so you just
create a new project and actually we
didn't have the time to finish that for
directing traffic sign so the thing that
you have is just a template that is
placed inside our examples so if you
want to start developing a directed Java
clinics application look inside our
beverage X Java client examples and
there you will find a template it's
called directive Java client it so for
the purpose of the demo I placed it on
my desktop and actually I just copied it
to my file system now it's another place
and then open the pv project and
according to the theory that I explained
before the only thing I need to do is I
need to add an database modern your
model to it and so I'll do that now and
I have a model prepared so I'll show you
this model it's actually just a tiny
little bit modified statin or just
modified our standard example movies and
renders a tiny little bit so if you
already know the object you will
probably recognize this year so it has
about 20 entities it's it's not super
complex but it's actually you know
decent amount of entities so now I just
go ahead and compile this application
takes a moment that was it then oops
then I'm going to start the application
and I configured my user defaults so
that it actually uses the fixed qra so
it has a fixed port number which you can
see here now I'd like to switch to
number four screen number three so here
at the Nexus 10 VP for machine and like
in the keynote we have had this icon on
the desktop here which is just the
generic client pre-configured to connect
to the URL that i hard-coded here and on
my server side so I just double-click
the client now and now what happens in
the background is that the server takes
a look at the ear model analyzes it
makes a sentence about what kind of
entities are the primary entities and
then we try to create this user
interface that you probably already saw
during the keynote it's really similar
one so in this case I decided that these
six entities here customer movie studio
television video are the primary main
entities of the application and I can
show you that you know for the entities
it created a different kind of caring
user interface for them so for example I
can go ahead and search for movies and I
guess whatever
and then they're stupid sky wars movie
now the database that I'm using here
actually does not have the information
about the movies that we ate in the
keynote so it's not going to have a
trailer component but I'll show you
later how to plug in QuickTime so this
movie window now displays the detailed
information about the movie so if you
text it doesn't for me about the movie
it's a tie to the category and then down
here in the tab view I pretty much take
a look at all the relationships of this
movie so I have a plot summary voting
the list of Directors the rules and if I
want to take a look at the roads or at
the talent I can just open it right so
we don't have a folder for for Harrison
Ford and he never directed any movie but
you played actually a bunch of roads I
can show you another movie a little more
interesting you've seen the before half
so there's our u.s. movie and a few
roles in there and one of my colleagues
who later come up for question answers
is my critic Eric and here we actually
have a photo
oh okay so now that you've seen what
kind of application we generate you
probably would like to know how to
customize it and like a director web you
have this assistant to the assistant is
a pretty pretty unconventional
development tool because it's actually
not it's actually running inside your
client application right and it allows
me to consider if you displace me for
example the choice of main entities and
immigration entities that they don't
make that the default hood so I can
change this order now and for example
say that studio should be at the top and
telling us there and so let me just
applied it and start to clean up so now
as you can see the order here and
they're using the phase change that so
give movies to the Italian now whenever
I want to change the attributes that I
used to search for movies actually can
just show you that so this
tries to follow the user right so if
they actually you know try to try to
make and find out what kind of window
that the users currently working in what
kind of component so if I want to
customize the movie query venules I can
just remove a few then Studios actually
nice information and the release date if
this goes to studio the budget I never
know that anyway so I don't need it as a
very property for tally ins yeah the
last name should be first now if you
wanted that some of these attributes
don't show up in the Clary
user interface like the four to one then
it is just because data type is not very
good to create I mean you cannot really
describe the photo like I am in an image
data internet Expedia so and for
customer that might make a little more
sense here so that may be order there
and then city and I never know that
credit card is really boring but maybe
the zip code and we can remember so now
the say apply and let me show you how
will you crave in Toulouse actually we
can hold them side by side now so as you
can see I changed the attributes that
are used to create for movies and for
studios and for talent right and for
customer so it's very very simple to do
these basic kinds of customizations
changing the order of affiliates and and
the selection of properties that you
made to search for them I want to show
you a little bit more segregated move
even though and the default widget that
is used for four character fields in the
database is a normal text field but
actually for the summary for proximally
that can get pretty pretty command
pretty big right so I would like to see
another visit for that so let me explain
you in a moment what I'm doing here this
layers now that the this assistant
actually derives a lot of information
from the server side about the ear model
so in the case of the assistant it
actually is okay that they sent the
information of the UM oil to the client
side right because in the developer
model strided this is not the deployment
mode so so it's no problem sending this
information to the client
time and so I now selected the the kind
of widget I want to work on and as you
can see for the plot summary by default
is a text view controller I changed it
now to be a text area I can change the
resizing I want it to be resized ability
I'll give it a minimum height and no I
don't want to show later okay so let me
apply that and then create your window
just to lay against that now it just
kind of has to bootstrap this this this
dynamic is on the fifth generation again
I just changed the way the user and if
it's generated so as we said all the
caches and that's why we see this today
so now if you can take a look at it the
movie changed right so now I have a
completely different vigil so these are
just a few examples of you know kind of
customizations that you can do it you
can change the order of attributes you
can choose for cut text fields or kind
of bridges in general I use
you can change form a pattern strings
for numbers or so the Deb
bunch of customizations that are
supported in the assistant okay so
actually can we go back to the slides
now peace
okay so I'd like to talk a little more
about customization and we have
interview were developments now you
there are you know different things you
need to change and for for different
needs you have different techniques to
customize and they actually get get more
and more complex so the first technique
to customize is the assistant I already
showed that to you and then we allow you
to write your own rules for the
server-side route system if you allow it
to freeze X an area extending moment
what that means if you allow you to
implement your own controller classes
and to plug them in into the client side
and then count the last step you allow
you to transition into the traditional
development they create your your user
interface by hand and this interface
builder user interface creation tool and
then just load them on the client side
so I want to talk about all of these a
little more the assistant I already
showed you so I guess most of you have
seen the doctor web presentation just
the previous session and so I'm going to
make this pretty short but the rule is
pretty much just a question and an
answer so typical question could be how
many columns you know to should be used
to display 10 texts for item and
typically answer could be to another
question is what kind of Windows should
be displayed when the application starts
up the default answer for that is the
query window
other examples are what kind of widget
what kind of controller should I use to
work on the character for use at the
default answer text view but actually
you can you can choose what kind of
visits you want to leave in and you can
even plug in your own ones and then you
can use so you can use routes to to
integrate your own controller classes
you can use words to customize layout
how many columns are supposed to be used
over the layout this you know it in rows
order that's and columns yeah things
like that and rules are very useful in
in multi user environments because
actually the routes allow you to create
different user interfaces dependent on
the user currently locked in so if you
have two different users on the client
on two different clients you can create
two different client user interfaces for
them and it's also very useful for
localization
you can choose different different kinds
of labels for example depending on the
under language of the user who's
currently logged in but would you know
would pretty much change one aspect of
the dynamic generation at a time and to
achieve more complex changes you might
have to write a bunch of rules to get
there and so that might get you know
pretty complicated and so so to make
your life easier we even allow you to
completely bypass the root system and to
take the X ma which is the reside that
the dual system is supposed to use right
and freeze this XML into a static file
that you can then edit by hand so if
it's complicated for you to to change
the layout by by writing rules you can
just take the XML that is generate by
the default words and freeze it into a
file and then just tell the server start
to use this file instead of doing the
dynamic rule evaluation so again this is
useful to customize your layout to
integrate your own custom controller
classes and it's also useful if you need
to specify parameters that are not
supported by the assistant the assistant
just displays the the most common
attributes of controllers that that that
people want to customize but there are
actually some that that are not
supported by the assistant so if you
want to add and change these parameters
you might have to freeze the XML and
enters by hand so in general I think
roots and freezing XML is pretty much on
the same level just freezing XML or you
will freeze the XML and it gets pretty
complicated and you have to change a lot
of rules right then freezing XML you
might become actually much simpler and
the other advantage of freezing XML is
that you can actually see the entries I
directly rules are pretty abstract so
it's kind of hard to understand but if
you see the XML in front of you you can
you can very date very very you know
what's really going on so the next level
of customization is pretty much to start
adding a little bit of source code so we
allow you to write your own controller
classes you will usually use our classes
as a base point and then subclass these
classes and for sometimes you want to
support new widgets if you don't support
so far I'd say it's a lot of digits and
maybe if your own one so if you
support right so for all these kinds of
support of new functionality you will
have to write some some source code
that's been used on the clients you
write you write client-side controller
classes and you can do a lot of stuff in
controller classes you can change
completely how the application works how
controllers interact what kind of
reaction happens when you make a double
click in the table view so you could
change all that in the controller
classes and some generated it's good to
add problem application specific
functionality and then the kind of the
last step of customization is and that
is very important and it's to transition
into the traditional development where
you can start interface builder create
your files by hand and then you have the
maximum control over the layout that you
can place your text feeds on the pixel
basis you can you can have multiple
interface files for different languages
all this stuff so and then it's actually
fairly easy to plug in these
traditionally develop components of your
application into the dynamically
generated part of the application so you
do that again by writing your rule
rights you pretty much the server's to
pay to the server side instead of you
know doing this dynamic creation of xm8
and you get to the client just use this
interface file alright and the class is
coming that this interface file so it's
it's important to keep in mind that it's
really easy to combine the two words of
dynamic generation and traditional
development okay so I'd like to give
another demo and show you an application
that makes use of a few of these
customizations I'd need screen number
two again perfect so this is an
application that are already booked on
and you can just start that again it
uses since my user defaults are
configured correctly using the same URL
now and number five now please screen
number five
Thanks so this is my Chris 9 now I want
to show you how the application is Omega
is 9 I have like on mecca's 10 I has an
icon on my desktop which is the generic
client and this in this case it again
connects the same URL as before but it
actually uses a few clients are classes
that are all for this application so
this is not the complete generic Landers
has a few plans edited so the first
thing you will notice is there then the
application startup sequence change
completely right I don't get a clear
window I get a login window so I'm
forced to enter a name with the password
and then afterwards if we go over to the
traditional one which is the carreño so
this is a fairly easy database just as
persons and some addresses around it so
the application looks pretty similar let
me search for some data here let me open
one of these windows next thing you
might notice is stared here in this user
interface
I actually have my layout of you
customize if you look at this lower
section here with the addresses you see
that it's not just you know the standard
one or two row or column layout right it
actually has it you know it's beautified
a little bit here in the middle at the
street and and it uses you know it mixes
rows of columns in living another thing
you might notice is that there's a new
button in the find window which allows
you to experience reports so if I click
on that I get this motor Diavik and can
choose types of reports and then if I
press ok I will actually get an HTML
report and display it here on my client
side they can do it that's another form
on the sphere so I can create different
kinds of reports another thing you might
notice is that the menu here we have the
additional menu items to export and
import the database I'm not going to
show you that because it would take too
long but you can also say you know
create records by based on the category
so for some other nice companies and and
persons actually this so and and then
that's the last thing that I want to
show you this there's a little info
panel and this is what you've been
waiting for right
so ah they're our team by using that
before so so they're they're you know a
bunch of things happened here that I
changed the startup sequence I now have
a login panel and actually something
that you didn't see right now because it
just stopped it wants but the
application actually stores the user
preferences so the window sizes that are
just generated in the database now
I then edit you know additional actions
in the in the in the craving I have this
report button and then this complete new
functionality to generate HTML which is
actually done on the server side and
then sent to the client and just
displayed there I Edition menu items and
incomplete you windows like like the
info panel so if you can go back to
screen number two please I know there
was not in the script I was back already
okay so let me just show you a few
things so this is the XML for the login
window right so in this case I used to
frozen xma so it just has a modal dialog
controller and action buttons which are
for the cancer and okay button then here
you can see that it is my own controller
classes right so I have my own special
controller class that I use on the
client side to do my login another thing
that might be interesting to point out
is that there's
sub-project for reports and then here I
have all this wrap up stored so I can
actually open one of them into objects
builder so I can use the objects builder
to evaluate the HTML right and this is
how I did the report and then there are
a bunch of these components and of these
four components that contains the layout
of the report what I think that should
be it for now so
yeah not like the slides back please so
before I go into summary I'd like to
give you a few good reasons why we think
you should use that java client and I
think the most obvious reason is they're
fed up that your development gets gets
much faster right I mean we can save you
a lot of time if you use directed Java
client and that also means it's not
cheaper for you to do the development of
your application another good reason for
you might be that the learning curve of
them to enter the object's development
is flattened if you're new to web
objects right and you would have to do
the traditional development process
right you would have to know about all
these pieces you would have to know how
to create interface files you have to
know how to create and modify and and
you have to know how to read business
logic or the stuff but the detective
Java client you already get an
application right without knowing a lot
about it you just be the database in
your model and that's it for now
and so so and then you know once we have
here application you can dig into all
the pieces that need you know heavy
customization but it's a different way
of learning the objects so if you're new
to web objects this is a very
interesting technology for you because
you might will be much much bigger at
the beginning also since since the user
interfaces is highly dynamic it is
unless you freeze it the reaction time
to requirement and database changes we
go down a lot and so if you if you
modify your tables if you add the
different attributes and the tables if
you add additional relationships the
application we pick it up pretty much
automatically for you so your reaction
time is much faster
I also claimed that the testing time
should be very reduced because our
controller classes are you know we
invested of time in testing our
controller classes and our application
logic so you don't have to test that
much and well I guess just in general
the message is that later Java client
allows you to focus on your business
logic right you don't base time and
doing the same steps again and again
drag a text field out of a plate
intervened over customize your layout so
that it looks nice all the stuff this is
done for you so you can really focus on
your business logic and this is what
you're paid for right so you don't based
aim time that anything else and then
before I
in summary I'd like to commend on on a
statement that I heard from a couple of
people and the statement is you know dr.
Java client and the same you know is
true for dr. Webb it's just this the
super-duper visit and you know it makes
a hell of a demo but but in my
reversionary I can't really use that and
so I wrote down a few comments on that
and most of them are already mentioned
so I'm not going to read them to you
again I think my take on this is that
people who make the statement has a
fundamental misunderstanding about Dec
2010 Java client and the fundamental
misunderstanding is that directed a
vitally to Java client live in their own
world right and that you cannot get out
of that word and that is not true it's
really easy both protective and write a
Java client to transition into this
traditional development you can use that
objects be the creative or components
and interface builder to create your
interface file so the the two words can
be mixed very easily and then if you
look at it like that then the dikes of
their protected Roxanne technologies
have you a lot bootstrapping your
development process right it's really
getting much quicker for you and and but
if the dynamic generation is not good
enough you just do it in the old way
there's no problem mixing there and you
can use both types of a pen type in Java
clang for all kinds of applications
right database administration might be
very obvious I gave you two examples
here movies database and address
management but you know if you want to
do some order processing or building or
everything that runs on the back office
area right Directorate Java clang can
help you with that
so most of some time the summary that I
showed you that title Java client
enables very strong rapid development
and it's very useful for prototyping
generated a lot of parts of the
application dynamically and you have a
lot of predefined functionality in the
form of view controller classes your
powerful ways of customization for for
different needs and the last step of
customization is to transition to the
user development
okay two more sessions that might be
interesting for you
you have synchronization caching and
advanced UF so you would probably not
hear anything about the except entire to
Java can you say
but you they about writing business
logic right so so how to do validation
and how to write business logic in a
good efficient grade and so this these
two might be interesting for you for
more information
I guess it's usually stuff you can go to
our website they have a lab downstairs
you all got an evaluation CDs so just
try it out and so now I'd like a few of
my colleagues to come up and be
available for question answers
you