Hello, everybody. Welcome back. And let's get started. And I'd like to introduce our next speaker for introduction to WebObjects Tools, Stan Jirman. And joining him will be Tom Naughton. Hello, everybody. Welcome to Introduction to WebObjects Tools. I'm Stan Jiurman. Soon, Tom will be joining me here up on stage.

What will you learn? Well, that actually depends quite a lot on you, how much notes you will be taking, whether you're going to fall asleep or not. I'm going to try to not make you fall asleep. We'll be talking here about the WebObjects tools. What are the tools used to build WebObjects applications? And we'll show you how to build a very basic application.

How many of you have been here, this usual poll, how many of you have been here for the 7.01 session, the introduction to WebObjects? Most of you. Okay, so you had the humor for the week and probably a lot of this will be repeat, but there will be some new stuff. We'll be talking about the WebObjects Tools. What are the WebObjects Tools? We have Project Builder.

Project Builder is the same as is used by CoreOS for all the Carbon and Cocoa applications. We have WebObjects Builder. We saw that in the previous session as well. EOModeler. We will not get too much into EOModeler here. There will be an advanced session that will discuss EOModeler in great detail. We will not be talking about the EO Bean Builder and the Rule Editor. It will be discussed in other sessions.

First, we will start with an introduction to EOModeler. What is an EOModel? What does it do for you? And why should you be using it? Then we'll get into the project builder introduction. This will be a project builder introduction from a WebObjects perspective. There was a project builder discussion or show before in the development tools track.

We'll examine the resources, we'll compile a project, and we'll launch an application. Then we will get into the WebObjects builder introduction. We'll be editing components, we'll be showing you the path view for HTML selection, and we'll show you binding validation, which is a very powerful and useful feature.

and we will be doing everything on the example of a common web app. We have a real estate app where if you're in the market for a house, you're probably familiar with that. You shop online what house you would like, then you check the price, especially here in the Bay Area, you'll find out you can't afford it and you're frustrated.

So, first we'll start with eModeler. They put those two things so close together this year. You know, last year we had people running up and down the stage and so they wanted to cage us in. And it's really difficult to see things. So first eModeler, what is it used to? It manages an eO model.

Enterprise objects, short EOs, they are Java objects which represent records in a database. EO modeler manages the EO model, which is the mapping between the database, which is not object-oriented, and your Java application, which is, hopefully. It provides persistent data store connectivity. It maps this data, as I said, and it also defines relationships.

Oops, excuse me. That's one too many. EOModeler provides persistent data store connectivity. Each model... Each model is used in WebObjects application to connect to a specific data source. You can have multiple models in one WebObjects application also. It maps native data types into Java types because database types are not necessarily clearly mapped into Java types. So here you see varchar becomes a string, and becomes a number.

It maps data into objects and there's usually a one-to-one mapping between a table column and an EO attribute. It creates templates for you so that you can plug in special getters, setters, and code validation or data validation. And it hides the whole middleware. The EO model is just the little tip of the iceberg, the part that, especially when you're starting out with WebObjects, that's the only part that you need to deal with. There's the whole stack of the two enterprise objects, frameworks, EO control, and EO access. And that's hidden, and that does all the work for you.

So basically the EO Modeler provides a layer of abstraction that minimizes the cost of change. So when you change the database, you actually just adjust a few settings in EO Modeler and your application continues working because that's the whole abstraction layer and the rest of your application should not know anything about the database that's being used. Now I would like to welcome Tom on stage. He will show us EOModeler. Tom, thank you. Thank you, Stan.

Tom really loves EOModeler here. Oh, yes. Everyone loves EOModeler here. Yes. I'm just going to show you some basic things that you'll use EOModeler for. If you're starting out and you already have a database, the first thing you'll need is a model so that you can start using the EOF framework.

And EOModeler has a nice assistant that will reverse engineer that database into an EOModel. And this is always the standard beginning EOModeler demo. So first you choose the adapter that you're going to use to access your database. Then you need to enter the URL. And here this is the special time that we saw in the previous demo. We are actually using stickies to write WebObjects applications as well. Yes. Stickies is the demoer's crutch. It avoids typing in public.

which can save one a lot of frustration. There are various options that you have in the assistant that helps you reverse engineer your database. For simplicity, we're just going to go with the basic default options. Just click finish here. And now it runs out, it accesses the database, it finds all the rows and tables, and it figures out what the entities are, what the relationships are. It maps their types to Java types and creates this model for you. The next thing we can do is take a look at some of the things we have in the model. This is the real estate example that you're going to see quite a lot.

If we look at a listing, you'll see that there's attributes for things that you would expect to find about a house for sale. For example, the bathrooms, the price, the size of the yard, the size of the house. And there's a relationship to a user who's the agent who listed this house.

Next we can take a look at objects in the database by clicking on the database browser button. This brings up Just some tables from the database so that you can make sure that your model is working, make sure that you're connecting to the database, and make sure that the values in the database are pretty much what you expect.

Another thing that you'd probably want to do next is maybe add some custom business logic to your objects. The way you do that is you generate Java code for some of these entities, the ones that you want to add custom behaviors to. First, we save the model. When you save the model, EOModeler does a consistency check.

It looks and makes sure that everything is kosher in its opinion and gives you a list of things that might be problems down the road. I don't really agree with it here. What did you screw up this time, Tom? It doesn't like that something is using the name description, so whoever designed the database is in fact the one who screwed up.

Oh, okay. But it's not really a problem. All the demos work, and it's not my fault. So we're just going to save, give it a name, save that in the home directory so that we don't mess up other demos. And then you click on this little Java button, and it wants us to specify a class name. It's recommending we use listing because we're generating Java for the listing object. I'm just going to go ahead and do that. All right.

I could, let's see, actually I meant to do this on the user object, but we've done the listing object, and I was going to add a method to get the full name of a user, but let's say we wanted a method that returned the total number of bedrooms and bathrooms. Let's see.

Total rooms. That probably won't work. What's that? Total rooms. Total rooms. Yeah, but I'm running into this number of class issues. Here, let me just do it as I originally planned, because I don't want to embarrass myself excessively. Go back here, choose the user object. Users are down here.

Click to generate Java, use user, save, and the home directory will be fine. Go down here to user Java, where we in fact do have methods for getting a first and last name. In there somewhere. You could also just find it. There you go. So first name, and we've got last name. And we wanted to add a method for the full name, which I have here in stickies. This is why I wanted to use this particular object, because I could just base the code in.

Nice blue palm. Yes, there we go. Very visible. So there we go. So now we have an additional method that produces a derived attribute of the full name of the user. Now, you might want to do something like, when you set the name, you could... You know, make sure that you don't have someone else with the same name that conflicts, maybe unique things.

You could, when you create a new user, you could make sure that each customer is assigned an agent or other various, you know, business logic type things. So then the last thing I wanted to show you. So let's say you started with a brand new database that you just designed here in your modeler, and you want to hook it up to Oracle and have it generate all the tables and rows for you. You could write readings of SQL, or you could just have your modeler do it.

You click here, and you specify that, you know, I want to create and drop tables, and I just basically just want to do everything to create the entire database from scratch, and this is all the SQL that would do that. And if I went ahead and executed that, it would delete everything out of the database, and the rest of the demos wouldn't do anything. So I won't do that right now.

But anyway, that was just sort of a quick overview of what you use your modeler for and how it works, and how it works for you and how you work for it. Yeah, especially the last part. Thank you, Tom. Just stay here with us. Yeah, I'll sit right down here.

So let's go back to the slides. So much for EModeler. We will now turn to Project Builder. Project Builder, what is Project Builder? Project Builder is the IDE for all WebObjects 5 applications. You use it to manage your resources, your static data, images, and also dynamic components such as actually EO model files are considered database dynamic elements.

Now in WebObjects 5 we introduced this new no longer bucket scheme. Until then we had those buckets that all classes had to be together and all WebObjects components had to be together, et cetera. Now you can have stuff all over the place. Now if I can take a quick poll, who likes this new style better? Raise your hand if you like the new style better.

And for just because maybe people don't know the difference, who would like the old style better, the buckets, like all classes together and all Java components, I mean web components? Nobody. You see, we improved the product big time. Project Builder allows you to edit and debug the code. It builds whole applications or frameworks. And it also allows you to launch and actually be active in the debugging procedure. Project Builder has two kinds of assistance that are specific to WebObjects. There is the project assistance and there's the file assistance.

First, what do the project assistance do for you? They help you with completely new project creation. They create, build, compileable skeleton applications. So whatever comes out of a project assistant is completely compilable. It doesn't do much, but it compiles, which is already a plus. And those assistance allow you to add basic resources to the project and also your models. Then we have file assistance. File assistance are used for when you already have a project, you are editing a project, and you want to add new files to it, such as Java classes, such as web components, and Java client NIPS.

Since Tom is already camping out here, why not use his time? Get rid of modeler. Get rid of modeler. We'll not save this time. And the sticky. We don't need stickies anymore. So I'm going to take the database that I showed you in the last example and show you how quickly you can just take that and generate a working HTML-based application using one of the assistants. So we're going to make a new project.

Let's go all the way down to the bottom. You get a list of all the WebObjects assistants. There's a variety. You can create an EOF application that uses Cocoa and Java so that you can have all the functionality of EOF and then a nice Cocoa interface. We have a bunch of direct-to-star technologies, we call them. There are lots of other sessions that cover that. But basically they allow you to sort of dynamically configure your application as it's running.

And the one I'm going to show you is kind of an old-fashioned type of example. It generates just an HTML page that you then take over and make pretty. So it's called a display group application. A display group is an object that manages a bunch of objects from a data store. So, for example, it could paginate a long list of data.

You could say, you know, I just want to have ten per page and it will automatically handle going to the next page and showing the next group. And it does searching and lots of other handy things for you. So we're just going to call this demo or dem. Demo or dem.

We'll put it in tem. No sticky for that, Tom? No, no. It doesn't really matter. It's not important. Oops, okay, and I just passed. We're not going to deploy it as a J2EE, on a J2EE-enabled server. We're not going to vend or consume web services. We're going to use the JDBC adapter.

And we're going to add a framework that contains the real estate model and uses the real estate database that I showed you. This framework also has a lot of business logic already added for the, for the, for the Java real estate database. Now, Steve, in the session before, he was showing a relevant demo for Canada.

This will be a very relevant demo, or the rest of the session will be very relevant to the Bay Area to get you familiarized with the Bay Area house prices, et cetera. So. And Stan and I took all these pictures. Yes. Which you'll see. So it found the model that was inside the framework and listed in the models. We could add additional models and it would use them all together.

Next, then it's opened the model and found all the entities within it. We're just going to display a bunch of attributes on a listing. We get to choose the layout for our HTML page. I'm going to do a table and I want to be able to search it. So I'm going to have some query fields. And I just wanted to show all the attributes, I guess.

That was a shift click to select everything and then just drag them all over. And I'm not traversing relationships because I just want to show these. Now we choose the attributes for the query. I'm just going to be able to search on number of bedrooms, number of bathrooms, selling price would have to enter a range, which would be a lot more complicated.

And what else? I wanted to search on the address so that we can look for houses in San Jose and houses in California. That should be good enough for a demo. Click finish. It makes a project with a web component. Start that building. It added the framework down here in frameworks. A few Java classes.

So very soon, Internet Explorer will pop up. I'll show you the application. OK, so it basically gave us-- it's got a form with the query attributes that I asked for. And it's got a table down here that's currently just got the headers. So we're going to search for houses in California. I guess that's probably going to be all of them.

And it's not a very pretty table, but you can go ahead and beautify that, pass it over to the artist, have them draw some pretty pictures, and make an appealing interface for it. So that was just an example of a project wizard that'll just get you started along the road of building your project. We also have some file wizards, which we'd use to add resources to existing projects. So, for example, if we wanted to add a Java class, we go down here to WebObjects Java class and give it a name.

is able to type. And it just adds that to your project. You can actually customize these templates. They're just in the project builder extras folder, which you can find out all about in one of the project builder sessions. So if your company has your own company header and you commonly include other packages, you could add that to templates and save yourself a little bit of work.

That's it? That covers assistants. I think the basic point here is, as Tom showed, the resulting application is maybe not the prettiest application, but let's face it, most people on the planet, they are much more at ease with designing a web page to make it beautiful than with talking to a database.

And that's exactly what those frameworks are all about, and those tools help you to do-- get the hard stuff done. And us programmers, at least many of us, are really not that good with beautifying web pages either, but we can outsource that, right? There we go. So, okay. The next thing is project structure in Project Builder. I already touched on that. That has changed quite a lot between the old WebObjects project types and the ones that we introduced in WebObjects 5 just a year ago. The project structure in Project Builder is target oriented.

and it's just a modified version of the OS X normal build system. It's a quite substantially modified version, but nevertheless it's basically the same foundation. For those of you who are not familiar with the build system of WebObjects, what is a target? A target defines which files are parts of a particular component of a build product. One file can be part of multiple such subproducts, such targets. For instance, there's Java components for clients that are both on the server and on the client, so they will be part of both or multiple targets.

This is typical deployment scenario. We have an application server. We have a web server. I would like to point out that these are probably some old Solaris servers. Of course, as of next week, today, you will be able to buy those nice, what Steve showed, this little thing. New Apple branded servers. Then we have a firewall. And then comes the big old intranet with nice and not so nice clients.

We have the web server target. It was the first machine up there. The web server serves the static data. The static images, static HTML, like your price list, client-side Java classes, Java client Nib files, and anything that's accessed through a normal HTML that you could type in, and when you type it in again, it will be still the same thing. On the other hand, there's the application server target.

That's for all the dynamic content, such as server-side Java classes, which are classes that get downloaded that stay on the server. Web components that get dynamically built and they're displayed in your application. Images generated on the fly. One of the biggest examples for that is iCards. When you go to Apple's website and you want to send a cute email with a nice card to your mom because it's Mother's Day coming up, and your models, for some strange reason, they're considered dynamic. Now, warning, do not rename targets and don't really mess with them unless you really, really know what you're doing. It's a dangerous thing.

Tom is more or less the only person known to man on the planet who can fix them. If he's on vacation, we're in trouble. So chances are, if you go and mess with the targets, your application will not get to the better. So, Tom, we just said your name, and since you are Mr. Target, don't drop your mic. My mic falls to the floor. Gravity at its best. And then I stepped on it. Yeah, let's hope it still works.

Still works? Still works. Okay, so targets. Let's see, we're going to go back to our DEMP project that we created earlier and just show you the targets in there. So as Stan said, there are two main targets. Here, let's click on the targets tab so you can see them.

There's the application server target and the web server target. And then one more target that's kind of the root target, really just there to build the other two. But it can be a little misleading because that's always the default target that pops up whenever an add to target panel comes down.

So I always have to remember when you're selecting targets, the default target probably isn't where you want to put things. You either want to put things on the application server if it's dynamic and needs to be part of your application, or on the web server if it's going to be downloaded to a client.

So as long as you keep that in mind, is this going to the client, does it belong on the web server, then you'll be able to choose which target to add your resources to. So we can click on these targets, and we get this nice panel that shows us everything that's in the target. So the application server has all the Java classes and component resources for application and a number of frameworks. Look on the web server.

There are all the frameworks because each framework can have web server resources. And there's a bunch of GIFs that the assistant put in there for us. If we'd actually chosen an option to add and remove records to the database, it puts nice little buttons with pretty GIFs, and it just puts those GIFs right in your project because you've chosen that project type.

So another way to look at targets is click on the files tab. Then you'll notice along the side here you have a bunch of check boxes. And the check boxes are turned on for things that are in a target. And I just noticed when I added that Java class, I put it in the main target. So that's wrong.

Let's get that out of the main target. It would actually go in the application server target. It's actually a very important thing. You will see that when you go, maybe you play with the product down in the lab or when you play with it at home, it's really important to which target you add a class.

You might find yourself, well, I added a Java file to the project. I'm building it, but it's not showing up. Make sure you added it to the right target, not to the main one. Because the main target is just a wrapper for the other two, which is the web server and the app server.

But unfortunately, PB's interface is to always default to the main target. So if you just follow the default behavior, it will put it in the wrong target. Very important to keep in mind. So this is everything that's in our application server target. It's sort of just like the other target viewer that I showed you, except it's easier just to turn the check boxes on and off, I find. So take a look at the web server.

And it's like I showed you before. All of the GIFs are in the main target. And then you can see that the main target is the main target. So this is everything that's in our application server target. It's sort of just like the other target viewer that I showed you, except it's easier just to turn the check boxes on and off, I find. All of the GIFs are in the web server because they need to be downloaded over HTTP and all of the frameworks, except for a few that we added.

For example, the JDBC adapter doesn't need to be on the web server because no one's going to download your adapter for talking to the database. So it just goes in the application server target. Anyway, this should give you an idea of what goes in which target and how you can move something from one target to another. Well, thank you, Tom. Sure, Stan. You don't even need to sit down because this will be just one slide before you do the next demo.

One picture says more than a thousand words, so we'll let you do the magic soon. Let's get to WebObjects Builder. We saw already a demo of WebObjects Builder in the previous session, and we'll see now another one. What is WebObjects Builder used for? For editing of HTML, binding of HTML objects to your project, the dynamic connections, integration with your model, of the EO model into your HTML pages, and it integrates with Project Builder. So both applications, Project Builder and WebObjects Builder, are talking to each other to synchronize the IVARs and method names that might be around. So let's go straight to the meat, and Tom, show us about WebObjects Builder.

Okay, so for this demo, we're gonna build an extremely simple, brand-new WebObjects application. We need to start with the assistant again. And this time I just used, down at the bottom, WebObjects application. That's the most vanilla template that you can start with. Choose that, give it a name, we'll call this demo two, or DEMP two.

We're not going to do anything terribly fancy, so we'll just go with all the defaults. It builds us this project and this default web component, which we're going to open in So the builder is basically a cross between an HTML editor and a code browser. Up at the top there's the toolbar, which is mostly for HTML editing. There's a range of buttons for HTML text styles, some buttons for HTML elements such as tables and links and lists. Then there are form elements, text entry fields, submit buttons, et cetera.

And then there are dynamic elements, which are things that are going to actually be changed at run time. Like you just put placeholders into your HTML, then the WebObjects framework actually figures out what belongs in there. So our app is going to be very simple. It's going to ask you for your name and then tell you what you entered.

So it just basically shows you how to do, how to get data from a web page and how to stuff it back into a web page. So since it's going to ask for user input, we need a form. So we make a form and then give it some text. What is your name? Add a text field and a Submit button.

So when they enter their name, we want to put that somewhere. So we're going to add a key to our component. And it's going to be a string, call it the name. That's a good name. It's just going to add an instance variable. We could have it add getters and setters, but we'll just go with the instance variable.

And then we just drag connect that to our text field and say that's going to be the value of the text field. So when they click submit, it's going to stuff whatever they typed into there into our IVAR. Then when they click submit, an action has to occur, so we're going to add an action. So the action will be called name entered.

This is kind of a convention that it always ends in action. And then you could have it return another component, or if you just enter another, it will return the exact same component. So we'll do that just to make this simple. And we want to show the final result, but we only want to show the name if they actually have entered a name. So we're going to add a conditional, bind that up to the name.

So if there is a name, then we'll say hello, helloee. Hello, and then add a string. Hello, the name. It'll put the name in there. And did I wire up the submit button? Let's look in the inspector and see if I did. I did not. Okay, and you'll notice some of these attributes are in red.

And that's why I'm trying to tell you that you've done something wrong. Corresponding with that, there's this validation panel. This icon actually changes color when there is a problem with your component. And it's saying that we need to bind. There's a variety of ways that you can bind an action class. The simplest is to just bind an action to it.

And it's trying to tell us that, you know, according to its validation rules, this isn't going to work. So we just drag connect this up to submit, bind it to action, and then all the validation errors go away. So in theory, when I build and run this, it should work. So I'll go back to project builder, go and run.

Hello, Tom. So that just basically shows you how we built an HTML component. We added dynamic elements. We didn't really write very much code. Wob wrote all the code, and the code is very simple. It's a view source file. And we see that it added the I-bar for the name, then it added an action.

This is sort of the absolute simplest WebObjects program that you could have. Other things we might want to do would be return a different component. We would do that here. And we could set up the component. We could stuff values into it if we wanted to have multiple components and pass arguments between them. So I hope that gives you an idea of how you use the builder.

and the rest of the team. Thank you. So, this is the WebObjects field. It's just an open and closed WebObject tag, and it just has a name which points to its bindings in the WAD entry. This is called the WAD file, dot W-O-D, for WebObjects definition, in case you thought it might refer to anything else. And these are all WAD entries. So, if you wanted, you could just edit the text files this way. You could even do it from Project Builder. For example, if we twist this open, you can see, you know, here's the HTML page.

Here's the WAD entry and here's a WOO entry, which holds the encoding for the component when you save it, or it can also hold information about display groups if you've added them to your component. So let me just show you a few more things you can do in ROM mode.

Just to point out, these are two files. There are some other products that maintain everything in the HTML file with special tags. We have it split up into two files. So it's a somewhat cleaner approach, as Steve pointed out before. And, uh... WebObjects Builder maintains both of those, plus the woo file.

So instead of having Java code embedded in your HTML and having to sort through the HTML mess and then the Java mess, it basically just points to the Java file and keeps everything separate. I'm gonna try and reformat this a little bit. It'll probably just move the body tag down there for me. So that doesn't help very much. Let's add a table.

There's a little table assistant that comes up. You can tell it, you know, maybe you want four by four columns. I believe this still works in ROM. There we go. So it's added a table. And I can hit that command R to reformat. It will indent that in the proper location where it belongs. And the reason I add the table really is just to show you this nifty feature that we have for tag matching. So if I double click on this tag, it, you know, selects that tag.

If you triple click, whoops, it's going to It'll go and select to the tag that it matches. And then if you start dragging, it'll select the containing tags. And as you drag further, it selects that containing tag and further in the body tag. So it's a very easy way to go ahead and match up a bunch of embedded tags.

Do you also want to show the selection? The selection preservation? Okay. Well, another thing that can be a pain when you're editing HTML is to find the range of text in the raw HTML that corresponds to the range of text in the WYSIWYG HTML. And while there's a nice feature, if I just select name here, then switch back to GUI mode, it'll select name there.

And if I wanted to find this table cell in raw mode for some reason, you just select the table cell. And yes, that's the path view, which I'll show them in a minute So, and then it selects the table cells. So it's very easy to go from one mode to the other and not lose your context.

So here's another element that Stan was pointing out. This is the HTML path view. It's similar to some other HTML editors, but just basically shows you the containment hierarchy from the selection all the way up to the root of the document. So sometimes, you know, if you have this table and you wanted to select just the table row, it's kind of hard to do that in GUI mode, but it's very easy to do with the path view. You just click right on the parent element that you wanted to select. Do you have any questions about that? No, no, I mean... I guess we'll take questions at the end. Yeah, I guess we will. Okay, so much for the demo of WebObjects Builder. Thank you, Tom.

Next is rapid turnaround mode. Again, this is something that we saw briefly mentioned before. Rapid turnaround is something that was introduced a while ago. It improves the development time, your whole experience, because you don't need to do a full install build just to test your application. So you save time this way.

There's no need to perform a split install, as I mentioned, and it allows you to tweak HTML components and some other components as the application is running, so you don't even need to restart the application. No rebuild and no restart of the application. And images you can change. That's one of those other dynamic components which you can replace on the fly. And you do not need to run a web server. It means you really can use the whole box or your development machine for running and testing the application.

Project Builder needs to be running. We saw before that Project Builder and WebObjects where they communicate with each other through special means, and they both need to be running for this to work. Project Builder is... like the big overseer of this whole development mode. Of course, when you're using rapid turnaround, chances are you are in Project Builder to edit your code or to start and stop the application, so that's not such a big deal.

Tom, it's your name again. And show us a little bit about the rapid turnaround. Sure, I have a lot of demos, so let me get out of... And also you have to show the nice houses that we took pictures of. Yes, now you get to see the houses that we took pictures of. There you go. So I'm going to open up a new example that we've been working on. It's called iShax. And it has a lot of components.

Okay, and I'll just build and run that for you, just so you can see what the application looks like. And we'll just run it because I've already built it. We built it before.

So I came logged in and it goes, you know, sort of to my home page. And this is my agent and these are properties that she suggests I take a look at. She's more than just your agent. She's more than just an agent.

So also once you log in, there are other options that show up in the toolbar on the side for selecting a different agent. God knows why I would want to. Or changing your personal information, etc., etc. Let's just take a look at a few of the houses that she's recommended.

So here's a condo in a very cramped condo area. There are maybe three feet between each condo. So I'm not very interested in that. And I took that picture and I wasn't really happy with how the light was falling out. Yeah, it's kind of the shadow is too harsh down in front. But, you know, the condos around it, you know, had their garage doors open and it wouldn't have made as good a picture.

Anyway, so this is an installation. This is an instance of the listing entity that I showed you earlier where you have, you know, the number of bathrooms. There's a relationship to the picture, etc. So what I want to do, though, is -- let's go back to my home page.

There are a few things that I don't like about this application. I'd just like to change the appearance a little bit. And using WebObjects and Rapid Turnaround mode, it's easy to go ahead and do that while the application is running just using the builder. So let's first go to that home page. I really feel all of this should be centered, the agent stuff, the picture and the name, and then the option to choose another agent, just center that in that table. So just to show you how you would do that, that's all in the homepage component.

Open that up. I'll make it big so everyone can see. So, I don't know, it's kind of, you'll get used to deciphering what all this means, but this component is all contained within a layout component. That has the header component at the bottom, there's a footer, and the component with all of the options. But right here we have, this is a woe image of the agent, and I'm just going to go over here to center that.

And these are all inside of a table cell, so I can't just select them all and center them at the same time. I have to center each individual cell. Select her name, and then select this option to change to another agent, and center that. If I can get the mouse over there.

I save this, and I just go back to IE. I don't have to rebuild or anything. I just hit refresh, and everything just updates right away. So that's a very handy way to go ahead and you can change colors, you can change your HTML. Another thing I'd like to change is this user logged in message.

I originally had that up as part of a large banner up at the top, and I think I'd like to just go ahead and put it back that way. So let's go find out where the header is. So you can see this entire component is embedded within this layout component.

So if I double click on that, it brings out the layout component. And there's an option to render the HTML inline as it would actually appear in the page. I believe that's here. There you go. Display components is rendered HTML. That makes it a little easier to figure out what component this was.

Then you see this user logged in stuff. Okay, yeah, that was another component. That's the header component. I need to double-click to open that. And then now I can edit this. And so let's say I wanted to remove this stuff. I'm going to get that out of there and stick it in here. Oops, and I actually need its container as well. Because this is only supposed to show up if the user is in fact logged in.

There. OK, save that, and let's see what I've actually done. So I hit refresh, and I've broken something. Great. I put all of this outside of the table that I wanted to put it within. So let's select this table. - This works in rehearsal. Okay, here, let's just put this back where it was at least.

I'm watching him on there. All kinds of things going on today. Okay, well, I've horribly broken it. Well, let's just imagine your name is up there. Let's just imagine that I put that over there. We are actually demoing on an alpha system, so this is unreliable. I know, I know. I'm finding excuses for you, Tom. But it is alpha software. We're doing it on alpha software. It's an alpha builder. Right, yeah, it's really, really.

But I think you get the general idea. If you're good at editing HTML, you can make all kinds of changes. You don't have to rebuild your application. You can change functionality. You can have things hide and show. And you just hit refresh in the browser, and you can make all kinds of refinements to your app in very little time.

Show us some more houses. Some authentic Bay Area houses. A few other houses. You want to look at some houses? So another one that she recommended. Here's a nice duplex. If you want to live in a house connected to another house. You can also search for houses. Trash days on Monday. Trash days on Monday. So which one? I don't know.

Search for houses in San Jose, maybe? Just to show you what the app does. Ooh, I like the top one. It's nice. Ooh, somebody. Stan took this one. Yeah. They had a lot of trash, I guess. It was trash day. Okay. All right. Anyway, I think we've made the rapid turnaround point. Yeah, more or less. Yes. Let's go back to the slides for the last chapter.

Back to the slides. Thank you. The last part of the presentation will be about CVS integration in Project Builder. We'll discuss what is CVS and what can it do for you in WebObjects. I guess, how many other people are here OS X developers of some other kind in WebObjects? And do you use CVS? Do you like CVS? Do you like the CVS integration in PB? Yeah? Okay, so for those of you who don't know how it works, this will be about CVS integration in PB. There are some particular features which are useful for us WebObjects people. What is CVS? Well, first of all, It stands for concurrent versioning system, which allows multiple people to concurrently work on the same version.

of the source file. It's open source, which is a really big thing with Apple, it seems. And we really stand behind it that it's not owned by some big evil empire. It comes with OS X, so if you get the developer CD, CVS comes pre-installed as part of the developer system.

It is cross-platform, which is very important for us WebObjects people because we have development both on Windows and on Mac OS X, and therefore we need a cross-platform integration with a persistence, I mean with a CVS. It's command line only. Now that is a good and a bad thing for some.

It's a good thing. It seems to be getting a good thing. I mean, even Steve is showing off terminal and transparent things running in terminal. So that is definitely a good thing. Sometimes it gets to be a little bit tricky, though, when you have to do a complex operation like dealing with wrappers, with directories. At that point, you don't necessarily want to deal with command line only. So we have a solution for that. And Apple loves it and uses it internally. All of Apple's OS X and all the projects used in it, they are maintained through a CVS system.

What does Project Builder do to help you with CVS? It shows you little marks next to files when you show--when you add, delete, or rename a file. It actually can help you rename those files, which is especially important when you have, again, folders, so-called wrappers. It supports deletion of such files.

When you try to do it on the command line, chances are the first five times you will fail and give up frustrated and go after the CVS repository and delete it there, which is not the point. Project Builder can do that for you. It allows remote CVS servers, which is a part of how it supports security so that you don't actually have the direct access to the CVS server. Maybe your employees who are not so experienced don't have direct access to the CVS server. They can go and rename and change files. you have to go through the server itself, which is an added security.

So Tom, Tom once again, show us about CVS. There's a similar issue with my legs. Yeah, just stop. I think it's like crossing my legs and then it goes around the leg. I don't know what you're doing behind there. But this is the last demo? That's the last demo.

And I won't have to think about demos for a long time again? About a year. About a year. A year, I'll begin to think about demos again. So let's look at this project from Project Builder that I've been modifying. I believe I made some modifications to the toolbar component. which is Here it is, the toolbar component. So we twist that open, the localized English version of the component. And the little m's aren't showing up. So we'll make sure that we have CVS integration turned on. Here, maybe I didn't save the component.

and you see that it's put this little M next to the file because it's been modified. So we can go to the CVS menu and see exactly what I've broken by choosing compare with base. Then it's going to launch file merge. - So, well, it's kind of hard to see in here exactly what I've done because it just shows the entire, table cell in one line. But basically you can use this to review the changes that you've made before you go ahead and check them in. And if you left a component horribly mangled, you can revert to the latest revision.

and that should fix it in theory. So go back to here and hit refresh. And there we go. Everything is back the way it was. No harm is done. CVS has saved me. Want to give it another try, Tom? Give it another try? No. We'll do it again next year. Okay. Next year we'll just move that little piece up into there. Next year it will be much better.

Yeah. But anyway, so it's very convenient to use CVS from Project Builder. It shows you exactly what you modified. I guess I wasn't terribly risky in this demo. I didn't modify a whole lot of things. I believe I changed the agent detail page. No, that was the home page that I changed. The home page.

So what if you want to rename one of those files? If I wanted to rename one of those files, well, traditionally, if people have used CVS a lot, you'd first have to remove the file from the repository, then add it again with a different name. And of course, CVS won't let you remove the file until you've deleted it, so you have to move it aside and give it a different name. But Project Builder actually makes it very easy to rename files. I don't want to rename that one, though. We'll rename this one.

We'll call it "The Cookie." So that goes, it removes the old one and marks it for removal in the database, puts a little R next to it. It adds the new file that we've changed, and it's a whole lot easier than doing it via the command line. You'll also notice when I bring up the inspector for the file, there's a list of all of the commit messages for all the modifications that have been made to this file. So let's take a look at another file.

This one shows you all the commit messages that, these are the actual commit messages that we've had since we started working on this project about a month ago. And this is an easy way to get a high-level view of all the changes and who's been working on what. It looks only you've been working on it.

Is there some teamwork on your team, Tom? Is there what? Is there some teamwork on your team? There's plenty of teamwork. It's Tom and Yuji. Oh, there you go. We'll find him at Gala here somewhere. Well, anyway, so you can basically see who's been working on what and what they've changed and review their changes. And it's very convenient.

Thank you Tom. The really nice thing about this is it really supports also naming of folders which is even much more of a pain to do when you're doing it on command line. Slides. Slides or not, doesn't really matter. We're kind of ahead of schedule it seems. When we rehearsed we were way over time and somehow... I think we had longer demos. Yeah, we had longer demos. He's a slacker. So this is our schedule.

There's the WebObjects lab located downstairs. Tuesday, today, it just ended. Okay, there was the porting lab. It will be open all week long until Friday 6 p.m. How many of you are planning to be in the WebObjects lab on Friday at 6 p.m.? Don't miss your flight. Okay? So... This is the roadmap, things that we would recommend.

There's advanced data modeling and connectivity. That's much more EOModeler work. EOModeler is one of the more important tools used for WebObjects, so you might want to attend that if you are planning to get serious with WebObjects. And of course, the feedback forum, where we would love to hear from you.

Who to contact? There's my boss, Tony. There's Bob, who introduced us. That's the guy with the hat. He still has it. And then there's the consulting part. For more information, Go to those sites, other places. Those slides will be coming over and over, so you will see them if not now. This is new documentation. How to access the documentation, those...