Is this on? Can everyone hear me? Good morning everyone. My name is Miguel Sanchez. I'm a member of the WebObjects engineering group and with me is Mike Hoffhines who will be helping me out during the demos. Let me get a quick read of the audience out there. How many of you are WebObjects developers or have used WebObjects? Good.

How many of you have used Direct to Web? Okay. For those of you that haven't, the first half of the talk will be an introduction to Direct to Web, so don't freak out. But we'll also be talking about some advanced features of Direct to Web for those users. Has anybody used Direct to Web in 4.5 yet? Okay, one person. I'm going to be talking about some of the new features we have. So what is Direct to Web? Direct to Web is a Java-based technology for rapid development of database-driven web applications.

Whenever you install WebObjects on your system, don't go out looking for an application called Direct to Web because you won't find it. There is no such thing. Direct to Web is really a set of things. It's a Java framework called Direct to Web. It's a project builder wizard and a web assistant applet that will help you configure applications at runtime. So the first thing we're going to do is jump right into a demo.

We're going to make your head spin with demos today. We have four demos, so I hope we don't lose you. Can we get the demo machine up on screen? So we're going to give you a very quick demo of what Direct to Web can do for you. What we're going to do here is create a very simple database administrative application that uses a restaurant's database. We're going to use a restaurant's database throughout all of our demo. The database models restaurants and their locations and the type of food they serve and we're going to be customizing our site along the way. So what we would start out doing is bringing up Project Builder.

and typing in the name of our application. In this case, it's going to be called Tengo Hambre, which in Spanish means I'm hungry. We pick the application to be of type WebObjects application. This is the first place where you see Direct to Web as a project builder wizard. Within project builder, you choose your application to be of type Direct to Web. We go on.

And here we specify the model. Before the demo, we created our database, we created a Neo model, and that's pretty much the only thing that Direct to Web requires to jumpstart the application. So Mike just picked the model, the Tengo Hambre model. We'll be talking about the model a little later on.

And we click Next. We choose a look. I'll talk about the looks later. Neutral look, and then we launch. And that's it. Based solely on the information you gave us in the model, Direct to Web has built this very generic application for you with a login page. We log into the application.

and it automatically knows about all of the tables or the entities in your model, about their attributes, and it gives you a whole set of pages to do stuff with them. You can query on them, you can insert, delete, you can list them. So for example, we're going to look, we're going to search on restaurants, we're going to go to the restaurant search page, and we're going to look for restaurants that begin with the letter M.

And this is live, we're hitting the database, we get a list page with all the restaurants. If we wanted to delete, we could hit the icon on the left hand, the right hand side of the screen, or we could drill down into a more specific record, like we're going to look into my restaurant right now, Miguel's Mexican Food. So we get edit pages. We could, let's say that my food chain is doing so well and my chicken fajitas are hit, so we add a new location. Actually, we don't have any locations, so it's my first location.

So we have pages to edit, to add objects in relationship to other objects. Okay, we'll be talking more about all this. Right now, what I wanted to let you know is that you get all of this for free, just by giving us your EO model. And this is live and hitting the database.

And another thing I'd like to point out, could we bring up the project? okay so he introduced a new location he saved the project okay the main thing I'd like to point out here is there is no code okay there is no here's your project and there's no reference to any such thing as query restaurant page edit restaurant page all of these pages are being generated generated dynamically at runtime for you okay so it's not just a wizard that dumps code on enter your project this is all dynamic and we that what that means is you can you can change it at runtime you can do a lot of customization without having to write any code so we'll get back to the slides now so that was a very very quick introduction to direct to web What kind of applications would you want to use Direct to Web for? Well, first of all, I think you should all consider Direct to Web as your generic database administration application for any application you do.

Without doing anything, you have this application that gives you edit pages and query pages and delete pages and all. This is probably the first step to validating your model. Does it work? You don't have to write anything. You just want to make sure that relationships point the way to what you want them to point, that things make sense on the web.

But you can also use it to create very real, very functional intranet and workgroup applications. This isn't just a prototyping tool. And the reason for that is that we offer you an iterative application development cycle. Direct to Web plugs into all the data. You can use it to create different layers that WebObjects provides you.

So you're not just playing around with prototypes here. What are the advantages of using Direct to Web? First of all, you get a rich set of default pages and behaviors, things you don't have to write. Hopefully this will allow you to concentrate on your business model and the specific logic of your application.

You also get something, what we call WYSIWYG application customization. What we mean by this is that we offer you a tool so that at runtime you can customize your application without recompiling. It's a good starting point for learning WebObjects. If you feel intimidated by the learning curve, this is probably a good thing to fire up and have a quick running application right away. And don't forget, it offers you a layered approach to application development. If you're an experienced WebObjects developer, you can plug in your application. You can plug into the more advanced layers of Direct to Web. Direct to Web is not just a prototyping tool.

What is the typical development cycle for the Direct to Web application? As we saw, we begin with a Neo model. The basis of a Direct to Web application is a good database definition. With this we give you a default Direct to Web application. What you saw, you get all these pages to edit and delete and administer your database.

Then you bring up a Java applet which we call the Web Assistant and this applet runs alongside your browser and you can tell us to configure certain things, certain things in your page the way you want them to be. After having done this, you have a more customized Direct to Web application. Notice that at this point you still haven't written any code.

But you can get to that. There's going to be a point where you probably want to touch your HTML and you want to write your own Java core or tweak some of the Java we have. You can do that. And the end result will hopefully be a custom WebObjects application.

So remember, Direct to Web offers you different layers in which you can program. You can be at the very top layer using a Java applet, no code, and using all the default behavior we give you. You can also work at a middle layer when you want to change the way your pages look with the layout. And you can get down to the guts and write Java and do your own HTML. So we're going to focus on layer one right now.

This is the zero lines of code layer. What we ask from you right now is to give us a model and we'll give you a lot of default behavior. First of all, you get three different looks that you can pick with Direct to Web. You also get nine different task pages and a web assistant to configure these with. So we're going to take a look at the looks now.

These are the types of looks you can have in your WebObjects application by default. This is what we call the basic look. The menu bar runs across the top and the main content of your application is in the middle. This is the list page for the basic look.

We also have the neutral look, which is the one we're going to be using in our demo here. The same functionality as the basic look, except that the menu bar runs across the side and there's no references to any Apple icons. This is a good starting point for customizing your own application for your corporate look and feel.

And the WebObjects look. Very similar to the neutral look, but except that we have Apple icons here and there. For those of you that have used Direct to Web in the previous versions, the neutral look is new for version 4.5. Once you pick the look you want for your application, we give you task pages.

With this page you'll be able to query on, you'll be able to insert new entities, you'll be able to associate entities and relationships and you get all this for free. But there's going to be a point where the default behavior we give you is not good enough for you. You want to tell us a little more about how you want your attributes displayed, which entities you want read-only, which ones you want read-write.

For that, we offer you a web assistant, which is a little Java applet, which we're going to show you right in a moment, where you can tell us how you want certain things displayed. You can make certain decisions. And you can do all this without writing any code.

So the Web Assistant allows you to configure things like your access permissions and the entities, the way you want to display your attributes, and general page layout issues. This is the final application we're working towards, the Tango Ambry application. We're going to have three pages. In the first page, we're going to have a query page for restaurants where users can log in and query on a particular restaurant based on a certain type of food or where the restaurant is.

After they do their query, they would see the results of all the possible restaurants they can go to. And then they would pick a particular restaurant and get the information such as where it is and how to get there and the phone number. So that's what we want to get to.

It's going to take us three demos to do that, but I want you to have that in your mind. This is the model we're using. The main entities in our database are going to be restaurants and locations. Where they are, each location might have a different price range depending on the city. And each restaurant might prepare more than one type of cuisine. So now we go off to demo two.

In the first demo, we created a very generic application that allowed us to access the restaurant database that we had created prior to the demo. In this demo, wrong screen, oh no, I'm looking at the wrong, yeah, I was looking down here, it's okay. So in this application, we're going to start to customize, give our application a little more the look and feel that we want. And the first thing we do is bring up the web assistant, which is a Java applet, runs alongside our browser.

Coming up. We're running this on Mac OS Server 1.2 with OmniWeb. So here's the Web Assistant. And the Web Assistant has different tabs depending on the function you want to perform at that moment. So let's look at the Entities tab. If you bring up this tab, you'll be able to tell us which entities you want to have in your application be read/write, which ones you want to read only, and which ones you want to hide altogether.

For our purposes of the demo, we want everything to be read/write only. We don't want the users out on the internet changing our information on the database. The next tab you see is the Pages, the Page tab. Here you can customize certain attributes about your whole page. For example, let's go to the list page on restaurants. Let's do a query.

And here, notice that the live assistant is following you, depending on the page you go to, that's the display of the live assistant. So here you can tell us things like, well, do you want to show the banner or not? What kind of color do you want for the background tables? Some pages even have more than one way of displaying themselves. For example, you can display the results of a query in a plain list format or in a master distal format or in a list page that shows the results in columns rather than rows. In this case, all we're going to do is get rid of the banner.

We do save and then we refresh. Notice that we changed some configuration in the Live Assistant, we refreshed the page and the banner is gone. By the way, the banner was the thing that said list, not this thing which is called a batch navigation bar and you need that because you might have more than one page worth of results. So the next tab on the Web Assistant is called the Properties and this is probably where you're going to be spending most of your time.

We're going now to the query page for restaurant and the properties tab. And you'll be able to see in the middle column right here, You'll be able to see all of the properties that are currently displayed for that page. In this case, querying on an icon for a restaurant does not make sense, so we want to get rid of that so we can hide properties. We also want the name property to be the first thing on the page so we can move it up to the top.

Then we can click update on the web assistant or save and do a refresh and we see that change in our application at runtime. We also have, in addition to renaming them and reordering them, we can choose to display them using different fields. For example, in the locations, we don't want people to query based on street address, we want them to query based on the zip.

SIP code. So we tell her, you know, display the SIP code for this field. And then for Cuisines, which is a too many relationship, that's a very non-intuitive way of seeing all the types of food you can query on. We offer you a type of component called D2W Query Too Many Relationship. Where you can tell it to use the text description of the... Are you... You're still in locations, Mike. I'm sorry? You're still in locations. I didn't hear you from... Yeah.

So we're picking to display Cuisines using a relationship component in a browser with one column. and we read this play. Okay. He put this in also as a too many relationship. Okay. But what I'd like you to see here is that you're doing all these configurations with your application at runtime and your application is still live.

There's way too many components that we offer you here to talk about all of them during this presentation. That would take all of our time. So just go away with the idea that if you have numbers or strings or relationships whether they're too many or too one, we offer you different types of browsers and tables and color strings and all of these types of configurable components for you to use. So this is our page. Now we query on American Food.

See, the app is still live. We're going to configure this page to show the locations of the restaurants. So we go to the Live Assistant. And by default we hide relationships in list pages. So we tell it, you know, we want to see the locations of the restaurant.

And we want to use a display-to-menu table to see them, see all the types of components you can use, and show the city of the restaurant. So we're doing all of this configuration at runtime. We pick a particular restaurant. Can you click on Palo Alto, for example? We're going to a restaurant inspect page. In this case, we're going to hide all of the address attributes.

And we're also going to see, see where it says price right here? We know that in our database, price holds two things. It not only holds the description, such as inexpensive in this case, it also holds an icon showing a dollar sign or two dollar signs based on how expensive the restaurant is. We can traverse to one relationships in our pages and we can choose to display the price icon. You've got to get rid of the price first. Yeah, you can say, I want to choose the price relationship, display its icon attribute as an image.

You get a very rich set of components that you can use here. And you might be wondering, well, this is fine, but in the first demo you showed us that there was no code, so where is all this information going? Well, if we bring up the project, you see that we still have no references to any specific pages. All of that configuration you were giving us goes into a model. We call it the D2W model. And it's nothing more than a text file with all the rules that you're telling us.

For example, in this rule you're telling us, if you're in the task inspect and the entity is location and what you want to display is a price.icon, then you have to use the display image as your component. So all of this information you're giving us using the Web Assistant is being stored in a text file. So that's the end of demo two.

Can we go back to the slides? So we've been working in the first layer of Direct to Web where without writing any code and using a Java applet that runs alongside your browser, you get to customize a lot of things about your page and how you want to display parts of your attributes.

Now we're jumping to layer two. You might say, "Well, Miguel, that's great, but you know what? I don't like the menu bar. I want my icon, my company's icon to show up on all the pages. I want this banner to be here. I want this other component to be down here." We understand. We can't guess everything that you want right off the bat, but we give you the hooks to do that. So this is where layer two comes out. In layer two, you can begin to customize the layout of your application, whether it's application-wide or task-specific.

For application-wide layout, for things that you want displayed on all of your pages, you're going to edit something called the page wrapper. The page wrapper is a piece of HTML which is going to be inserted in your project when you create it, which tells us how you want your pages laid out.

Where does the menu go? Where does the content of the page go? So you can plug in your own stuff into this page and say, "Well, I want this icon to show up on all the pages. I want this banner to show up on all the pages." And that's how you get your specific corporate look and feel.

Now, how does a page know what to do with itself at runtime? How does the rule information get translated into something meaningful? As we saw, rules are stored in a file in text format. For example, here we're looking at this rule. This is very similar to what we saw in the demo. If we're listing a restaurant's locations, then we want to use the display to many table. So that's a text file.

To evaluate rules at runtime, we use something called a D2W context. So all of the bindings in your HTML template that we give you are going to have reference to keys of the type D2W context dot something. So when you see D2W context dot something in your WAD file, in your bindings file for the HTML we give you, that's when the rule system kicks in. And we're going to show you some of this in demo three.

So in our second demo, we customized the query page for restaurants, the list page for restaurants, and the inspect page for locations. In this demo, we're going to begin to give a more corporate look and feel to our application. And because we start to use our own company's resources, our images and our source code, we need to add the framework to our project, which is what Mike just did.

The first thing we do is bring up the page wrapper component, which is in our project. And as you can see, this tells us, well, the layout of this application is this blue bar with a menu and then the content. We don't want the menu. So Mike goes in there, wipes out the menu component, and replaces it with an image.

And we say that the image we want is the logo for our application, which is a gift called Tengo Number 3. There it is. And our marketing department decided that we also want to advertise our sponsors and our site. So across the top, below the content, look for the content. Yeah, I lost that here. Yeah.

We want to insert a reusable component which we wrote before. It's called the add component, the add banner. So now we've modified the HTML surrounding our layer of application. We recompile. Notice we haven't added any code. Well, we have added a little bit of code where we do the advertisement as you'll see once the application runs.

So we log in and there it is. Our application is starting to take more the look we want. This was a very simple change. All we did was add an icon. But what I want you to realize is that you have the HTML there so you can do whatever you want. And we can click, let's go to the restaurant list page. We search on restaurants.

And you can see that the icon here changes because our add component is clicking into place. So that's how you use the page wrapper to customize the whole layout of your application. But now let's look at this list page. In our application, we don't want this icon to show up.

This icon allows you to go to the inspect page of a particular restaurant. We don't want that to show up. In your case, it could have been something more complex. In this case, we don't want this column to show up. And we don't give you access in the web assistant to get rid of that column.

And you're probably going to come across moments in your development cycle where you say, "Oh, I really wish these guys would have given me this checkbox in the web assistant to do this or to do that." Well, that was a problem in previous releases of Direct to Web.

I think it's much less of a problem now because you can bring up the web assistant. Is the web assistant up? Okay. I think you have to restart the web assistant. Yeah, but there was also an error on startup. So just restart it here. Okay, so what we're going to do once the web assistant comes up is we're going to go to the restaurant list page.

and we're going to generate a template for that page. And once we generate the template, we're going to have the HTML for the template and we're going to be able to edit it, but it's still going to be the dynamic version of the HTML. We'll be able to do stuff to it, but not lose the accustomed... whoops.

Oh, the port to the web assistant, right? Yeah, the problem we're having here is each time the application comes up, it comes up on a different port, and the web assistant connects to that port. So we were restarting the app and the application had changed its port, so it didn't know how to talk back. We thought we had set a default for that port, but obviously we hadn't.

So we're back here, we're in the list page and we say we want, we hope, we wish we could get to the HTML of this piece of Direct to Web so we can get rid of this column here. So we go to the generation tab of the Web Assistant and we choose list.

and we tell it to give us the template for this component. So that was a very simple operation. Let's see what that did. If we go to the project, We see that we have something called neutral list template and we opened that in WebObjects Builder. Can you show a little bit of the HTML? Scroll down.

Actually, first show the other view, the display view. Yeah. But scroll down. All right. So here you have the HTML that displays the list page. Go down a little more, a little more. But notice that there's no reference whatsoever to your model. There's no reference to a restaurant because this is the dynamic version of the HTML we're using in Direct to Web.

And can you go back to the bindings view now? In the binding view, you will see a lot of references to things like D2WContext.ComponentName, D2WContext.DisplayPropertyKeys. So at runtime, all of these things will be evaluated for you. So, okay, so what's good about this? We're going to get rid of the column.

We're going to get rid of this whole column to select... I think that's it. Okay, and then we recompile. So we're editing the HTML. In this case we're doing a very simple edit. We're just getting rid of a column. But it could have been something much more complex in the way you want to lay out your display, your list display. We recompile your application.

And we're going to go once again to the restaurant list page. Just click on restaurant, right? Okay, so we no longer see that column. Okay, so what? Right? Well, we can still use the web assistant. Go back to the web assistant and we might have lost the port again.

In previous versions of Direct to Web, when you generated the HTML, you didn't have the dynamic version of the HTML. You had a very static, you had reference to the specific entity you wanted to display. So you lost all the ability to customize it. But with templates, you're able to access the HTML, do whatever you want to it, but still be able to customize it using the Web Assistant, which should come up in a minute.

So we're in the list page. The redisplay of-- go to properties for the list page. And let's say that we want to display this column, this redisplay. Let's say that we want to display the name of restaurants using a... A string that allows us to configure color to it, something called a style string, bold, italic, and then justifying it to the left. We re-display.

And there you go. Okay? So you get, you don't lose the ability to customize your pages using the Web Assistant and for those of you that have used Direct to Web in the past, I hope you see the power here in not losing the customizability. So, I think this is the end of our demo two, right? Demo three? Which number are we in? I forgot.

So we've just finished doing the second layer of Direct to Web where we're changing the layout of our application. But you're all developers, so you're probably itching to get to the Java code and plug in your own functionality. You can do that. Okay. You can, in layer three of Direct to Web, you can modify the behavior of your application.

And we offer four ways of doing that. Something new in version four or five is called D2W custom component. We also offer the Direct to Web components as reusable components to use in your application as embedded components. We offer Direct to Web API that you can program to. And you can always generate the code.

D2W Custom Component, second time for developers to wake up here. Nguyen 45 You can plug in your own reusable component to display a particular attribute in a page. All you have to take care of is that that component implements two keys, one called object and one called key.

That's how we're going to instantiate your component and tell you this is the object you're displaying and this is the key you want to display right now in case it's a reusable component. Say you're displaying dates and you have three instances of dates in your page. You need to know which particular key we have at that moment. And then you use the Web Assistant to configure to tell us we're going to... And for this property, please use my component.

You also have all of the Direct to Web pages available to you as reusable components. In fact, there is a palette in WebObjects Builder where you can just drag things into your HTML and set up all the bindings in case you want to embed one of our list pages in one of your more complex pages.

You have API that you can program to. You can jump into the dynamic world of Direct to Web from your applications, even if they didn't start out being Direct to Web applications. All you have to do is add the framework to your project and you can call methods. Let's say that you have five pages in your application which you wrote, but you like our list page.

You would like to do 80% of what you do, but at some point have a hyperlink that jumps into the Direct to Web list page because you don't want to rewrite all that functionality. You can do that. The key to doing that is messaging a class called D2W. We got a static method called Factory, which gives you the main instance of the Direct to Web class.

And in that class you're going to find a lot of methods like list page for entity name. You'll find another method called query page for entity name, inspect page for entity name. And you give us the entity and the session and we'll give you back the page. So from your code you can message us and we'll give you back the page for you to jump into the dynamic world of Direct to Web.

And obviously each one of these pages you get back is going to have its own associated API. In the case of the list page, we have methods set data source and set next page. So for example here you can tell us if it's a list page where are you going to get your data from? After I click return on my list page, where do you want me to go back to? You can do that. So if it were an inspect page you would have slightly different API. But you have API to all of the pages in Direct to Web so that you can jump in and out of the list page. into them from your code.

And finally, you can generate code. You can say, "This is all great, but I really, really need to see the Java code to see how you're doing this particular component." Well, there's a button in the web assistant where you can say, "I'm done with all the customization you give me.

I click on it and we dump all the HTML and all the Java for you to see and to touch and do whatever you want with it." In fact, we try to remove all of the references of Direct to Web in the Java code we have, so it's all unrolled so you can edit it without being dependent on Direct to Web so much.

The downside of this is that we're not smart enough to reparse the code for you to be able to customize your pages using the web assistant. So you've got to give up something. We give you the full access to the HTML and the Java, but you can't use the web assistant to change your pages on the fly anymore. We now go to our final demo.

What we're going to do here is, if you've been paying attention to the first page that comes up when we bring up the application, the first thing that comes up after our user logs in is a query all page where they can query on all the entities. This does not make sense in our demo. We want the first page to be the page where they can query on a restaurant. So for this, we go into the code for the login page.

And we change this method to, it used to be D2WFactory.defaultPage. We now rewrite it to be D2WFactory, give us the Direct to Web class, and give me the query page for the entity. That's what I want to be my default page. So when this method, default page, is called, I want you to return the query page for a restaurant. And I want you to, that's the first thing I want to see on my page.

So we recompile the application. Again, a very trivial example, but this could be any, this could be your code in your method in your classes. We bring up the page, we log in, and we get an exception. . Yeah, Direct to Web does not come with spell checking. yet.

The yet part was a joke, okay? I'm not announcing new features here. Some of you took it too seriously there. So now we log in and the default page is our Query Restaurant page. We could have chosen any other page. This could be your page. This could be your code. That could be your button. And you could click on that button and choose to go to another Direct to Web page. You have the ability to do that. You have the API. Now we're going to search on American food again.

We're going to pick Cafe Max and Cupertino. And notice the street address here. We removed all of the other fields like the city and the zip code and all that. We did that for a reason for this part of the demo. We wrote a component that displays an address all compacted into a little It's compacted enough to fit all here, so we don't have different rows. We can just type address and we'll see all of the address.

But the important thing about that, that, What Mike is doing here is getting back to the applet viewer, if you're wondering what all that spew on the screen is. He's trying to get to the port of the applet viewer so he can bring it up again for this part of the demo.

So we're going to plug in our own component. So imagine you're coding along and then you say, wow, I wish I could write my own component to display the address the way I want it to display. You can. We wrote a component where you can display the address as a hyperlink, which takes you to Yahoo, and you can see a Yahoo map of the address. This could be any other component in your application.

So we go to the web assistant and we say, you know, the street address, I don't like the components you give us, Miguel. They're good, but they're limited. I want to use my own. So you tell us, D2W custom component. And my own component is called StreetMapper. And this component implements the object and key bindings.

You display at runtime and then we have our component here. Don't click on it yet. So now we're showing the address the way we want, implementing the functionality we want, because what we wanted to do is for people to be able to click on that and take us to Yahoo. So I think that's the end of our four, actually that's the end of all of our demos. We have a little summary.

So we've just finished customizing our application at the third level, which is the full-- we didn't show you, by the way, but it would have been just a CC. You bring up the web assistant and then you click Generate Code, and we would have dumped all of that Java and HTML for you to edit. But I mean, you've seen that before, and you can do whatever you want with it. So in summary, Direct to Web.

Java based technology for rapid development. Keywords here are rapid. We want to do things fast for you by providing a lot of functionality. Another keyword is database driven. All of your Direct to Web applications start out from a model. And I guess another keyword is web applications. By web I mean HTML. This is the HTML part of the WebObjects. The next talk, Java Client, is where we bring up the nice Java applets which Steve showed in his demo.

How do you configure things using Direct to Web? You can work, if you don't want to get your hands dirty with code, you can use the Web Assistant to tell us how you want things to be laid out, how you want things displayed. That's okay, you don't need to do that much. You don't need to know much of WebObjects to do that.

But in 4.5 we've introduced two powerful features. Very simple, but I hope that the WebObjects developers out there realize how powerful these two hooks are to your applications. You have access to the dynamic version of the HTML using the 2W templates without losing the ability to customize your applications using the Web Assistant.

And you have a way of plugging in your own custom components to display the attributes the way you want. And implement your own functionality. You might have a hyperlink or a button in one of your custom components and do whatever else you want with the page without losing the ability to customize other parts of the page dynamically. And ultimately you can do code generation.

Where do you go from here? The best place to start is probably go to WOL Info Center. There's two new books for Direct to Web. We still have the tutorial in the WebObjects Tools and Techniques part of the WebObjects manual. We also have a new book written by Cliff Liu, one of our doc people, a wonderful book called Developing WebObjects Applications with Direct to Web.

This book goes into a lot of detail about the architecture of Direct to Web and the rule system and how it works and the context and how you can overwrite it and how you can write your own task. A lot of stuff I didn't cover here because it's just too much for a one hour presentation. There's also an updated reference of all the frameworks and all the classes in Direct to Web. You now see that you have this API. The methods are explained in this.

I would recommend beginning WebObjects developer, actually anybody that hasn't used Direct to Web, is to just bring up the movies model which ships with our product and create a generic Direct to Web application and start playing around with it. Configure your pages and generate code and see all of the functionality we give you.