Good afternoon, everybody, and welcome to the WebObjects overview session. My name is Bob Fraser. I am the product manager for WebObjects and also Java now. And this is going to be an introductory overview to the WebObjects technologies. And I'd like to start with the usual exercise. Anybody who's using WebObjects, could you please raise your hands? Yeah. And for how many of you is this the first time you're coming to a WWDC session on WebObjects? OK, great.

So what we're going to cover is an overview of WebObjects, some of the things that Apple is doing with WebObjects, how to get WebObjects, and we also have some members of the community here who are going to talk about some of the things that are going on in the whole general WebObjects community.

So WebObjects is a great set of tools and frameworks for doing rapid application development of Java server applications and web services. And it's really, really neat stuff. What you get is the easiest way to build J2EE-compatible applications. So Java's the way to do server applications, at least if you're not Microsoft. And one of the things, it's great because it's standards-based, it's cross-platform, it's interoperable with a lot of things, there's great connectivity to a bunch of stuff. But building a real enterprise-level three-tiered application, you know, almost takes a rocket scientist. It's a complicated thing. So if you look out there, what have a lot of people been doing? They've been trying to reduce the scope of effort involved, come along with tools that can increase productivity and reduce complexity.

You know, you see that with an example of the Sun Creator product that's been announced here. And at Java 1 is exactly trying to solve that kind of a problem. Well, we have a mature product out there, WebObjects, which addresses the same kind of issues and the same kind of problems. And what you get is everything you need to build enterprise class applications in one box. So with WebObjects, you get an integrated development environment. It layers on top of Xcode or Windows. And it gives you the IDE for all your editing and rapid prototyping.

It does database mapping. It includes a full object relational mapping model that will take you back and forth between SQL databases or JNDI data sources and do that mapping and turn that into objects. It also gives you some really incredible assistant and wizard technologies that lets you do code-free prototyping.

But then these are extensible, and then you can extend them and turn them into full scalable applications because they use the powerful frameworks that are built in that are all very, very scalable. It is also an outstanding package of web services, both as a consumer and a provider, and there are not that many great web-- there are not that many great web services packages for providing web services out there. We think this is a great offering. And it's--one of the more common uses of it is to do HTML presentations or three-tiered HTML-based websites.

So the advantages are the usual, the one things you want to have, the three things you want to have in your product, faster, cheaper, better. And how that relates here is it accelerates your time to market because we have a developer tool chain that walks you through the process of building these applications, and it's visual. It's a visual IDE, so it simplifies this and makes this much more approachable. You get better code at the end of the day because there are years of best practices that are built into these frameworks. So we've had a lot of bright people working on this stuff for a long time, and it's all encapsulated in these frameworks that come with WebObjects. So there's usually a tool and a framework that go together. And what this does is it does a lot of the heavy lifting for you. So a lot of the object relational mapping, a lot of the templating, a lot of the generation of web pages, a lot of the request response handling, a lot of these things have been well designed and baked in. That lets you worry about your domain expertise, the piece that you actually really want to build and not have to worry about a lot of the infrastructure and the plumbing.

And because you don't write a lot of code, you don't maintain a lot of code. And so your overall cost of ownership of a project, of a product, of a lifecycle of something is reduced. And the other thing you'll see is you'll see how easy it is to do incremental development. And you get an idea and you go, oh, what if? Or I need to make this little change over here. You'll see how fluid that is. And that also reduces the cost of ownership because requirements are always changing. People always come up and say, I'd like the button, but I want it here and I want it blue and I want to do this. And with WebObjects, that's really neat and easy to do.

So let's look at a classical three-tiered application architecture. And we have on the left your data access layer. With WebObjects, you can talk to JDBC databases and JNDI data sources. And then you'll typically have a business logic layer, or fancy word for if statements. And then you have different presentations that you may want to do. And with WebObjects, you can do HTML-based, web service-based, or rich client-based presentation layers, and you get your choice. So that's kind of like, you know, when you're mapping out a nice enterprise application, you've got your different layers. WebObjects has a tool and framework that pretty much works in each of these different layers. So let's look at, that's the architecture, now let's look at what the developer flow would be like.

So with the data access layer, we have a tool called EOModeler. So this is the modeling tool. So what we want to do is we want to get away from tables and rows and JNDI attributes, and we want to model that at a higher level and get that to the object level. Once we have this, now we can operate at a higher level in our application and in our application development. So then we bring it into Xcode, and we start writing a little bit of business logic in Java. So everything's portable. And this is where you would do your rapid prototyping. And then from here, what you can do is you can take it and use our WebObjects Builder design tool for doing HTML web page generation.

There's a web services assistant for building web services. And there's also a way to do rich Java client applications in a tool there as well. Now, one of the interesting things to notice about this diagram, if we look in the middle here at Xcode, we see three lines coming from that same point there. You get one model and one set of business logic that's operating on that, and you're kind of presentationally independent. And so what you can do from the same model-driven design, you can actually go to a web page, go to web services, or go to a rich client based on that same model.

The model-driven programming is a really powerful paradigm here, and we put it to good use. And we find it very common for a lot of our customers and partners to actually do that. They'll actually have multiple applications, or they'll have multiple access points driven this way. So a scenario that might make sense, You've got some data. You've got a website. For the front of the house, you may want to have a web interface, HTML-based. People come to your website. They click on things through an HTML interface in a standard browser.

Okay? But then you may want to have an in-house, behind-the-firewall DBA app where you're updating like a product inventory. That you might like to have as a rich client. You can drive that off the same model. And then you decide later on you want to automate some business processes, so you may want to add some web services. And that can be lights out, computer to computer. And all of those can interact with the same model, either in the same application, or you could just build another quick separate application. Thank you.

So step one is building the model. Now what EO Modeler allows you to do is it allows you to reverse engineer the data source. So all you need is a JNDI URL and a JDBC access to a database, an SQL database. And you can basically go in there, and it will find the tables, the columns, the rows, and understand all of these entities and properties.

Or what you can do is you can use EOModeler for doing forward schema design. So you can drop in entities, drop in properties and stuff like that, and it will actually generate the tables for you. We support a wide variety of databases in this modeling tool and the mapping layer that goes with it.

Everything from Oracle and Sybase and FrontBase and OpenBase and MySQL and MSSQL, and I'm probably forgetting, but if you go to the website, there's a list of a bunch of them. And then there's other people who've done plugins for like DB2 and PostgreSQL and stuff like that. So pretty much you can get out there and get access to just about any database that you want. So that's the design tool. Now we have this conceptual model. So now the next step... Well, here's a picture of the tool, and we're going to have a little demonstration here. But one thing to notice is that we have kind of like an ER entity relationship diagram here. This was actually generated by a modeler, and you can also see that we've also gotten the relationships as well. So not only did we find any of the tables, any of the properties, and we now also have the relationships and the interaction between this. So now you actually get a high-level picture of this. This alone would already be kind of worth the price of admission for a lot of people, for a lot of projects.

We get so much feedback from places such as universities. They've got a lot of turnover. They're working on grad student power. And then basically after like five years or four years or something, nobody knows what this thing is doing anymore. Somebody can pop into the model and they can open it up and look at it and go, oh, these are the entities. These are the things that are in there.

Or you could walk up to a database, an Oracle. We have people go in and reverse engineer Oracle databases, and there's stuff in there that the DBAs didn't even really know that they were really still playing around with anymore. And you can get a quick view of everything this way. What did that just do?

That's what that button does. OK. Sorry about that. OK. Now at runtime, we do all of the object relational mapping for you. So we do all of the database access. We do all the data persistence. So you don't do any SQL. We do the fetches, the read, writes, updates, deletes, all that kind of stuff. And this model and the mapping is database independent.

So it would be analogous to container managed persistence, only we believe a little easier to implement. It's database independent, and you can also query across multiple databases simultaneously. So you can actually build a model and actually pull data from, like, a JNDI source, pull data from, like, an Oracle database, and then actually put those in your application and mix with those. So it's nice because you get transparent persistence, you get database independence, and you get the ability to do at a nice high-level data aggregation. So those are all really nice, really nice features. And with that, I would like to invite Daryl Lee up to give a demonstration of EOModeler.

Hi, everybody. So I just want to show you a modeler. Let me bring up the demo machine. OK, great. So I just want to show you a quick reverse engineering demo and just how easy it is to reverse engineer a database. So let's create a new model. And I'm going to select a JDBC data source. And I'm selecting our standard WOE real estate database that comes with every copy of WebObjects. And I'm just going to take basic defaults here and finish my model.

And boom, you know, that couple seconds, and we have our whole database reverse engineered. As you can see, we have all of our relationships modeled. If you look on the left side, all these what we call entities are mapped to your tables. And if you select the user table, we also have the attributes, or what we call, for that map to your columns. So first name would map to a column in your database. So if you use the inspector, you can check it really quickly, and that maps to the user table in the database. Another nice feature is, say, instead of reverse engineering, you actually want to just model your database and your schema first, and then you want to blast that to your database. And just say we had done modeled this already, but it wasn't in our database. What you can do is select our SQL generation assistant. And what you can see here is that we've composed all the SQL queries and statements that you'll need to create the database, all the foreign keys and primary keys and constraints you'll need to create the database. So with that demo, it shows you just how quickly you can get up and running and how you can model your database in minutes.

Thank you, Daryl. OK. We have a model, a way to get things in and out of our database. So now that we've done this, we can start prototyping. So the next step would be to bring this into the IDE and start writing a little bit of code and start developing a prototype. Now, the advantages of this, what happens in WebObjects is you get a better way to write code. It's a better development process.

Basically what you do is you start prototyping the application and you get something live running right away. So contrast this to let's say something like the aerospace industry where you're going to go with a six month design requirements and then you get a bunch of programmers working on it and then six months later you decide that isn't quite what I wanted. This is a much more fluid interactive way of working. a simple approach in a few minutes, a few clicks of a button, like that.

You get your customer on whatever that is. If you're in-house in IT, you get the people who are going to be your end user, customer that you're consulting for, you get them in, you see. very can nail down the design fire they actually have can touch feel and see to really this is what they're getting gonna work then you start you start occasion you add in last parts of the function and stuff that you need and you deliver the application. Each of these steps along the way, it's the application. And so what happens along the way is continuous integration somebody coming in at the end of the thing saying, that's. So I feel this gives you actually a better way to develop an application.

Some things generally web applications. Now we're going to move. So with WebObjects, you get a tool, a web builder. WebObject Builder, both like a great email editor, but a concept that it has is kind of like a binding editor. And it allows you to actually tie the data to the page. You can write a bunch of JSPs and bind things that way. It's really elegant. You can do the drop with it. You can also build pallets of reusable components.

over and over again in WebObject. Very powerful. You can compose and picture of the and at the bottom we've got some of the keys and some of the that actually came from the model. So we actually are aware in there. We're also aware of your added code and your properties, keys, and methods. as well. So it's sentient and aware of what's going on in your code and the actual data mob by the database as well at the same time.

Then at runtime, what we do is we take an HTML template, we take data coming from the web, it is with the business logic, and we can kick out the personalized web pages. So that there's a binding page, and then the data sources can be something that's comes from your business log, just the code, or it can be something that came up from out of the database. And then this the final output in HTML.

Another demonstration here of building a single application and how you can finally modify it. Thank you, Bob. What I'd like to show you is a real example of a design. location that you can build right out of our tablets. And so we'll go straight to Xcode and just and we'll-- there are a number of default panes.

faults. We'll just select our real estate model really quickly. So the next thing it'll ask me is, what is the main that I want to display? And I'll just pick listing address to keep it simple. And in this pane, it's giving me options to select layouts. As you can see, the preview mode gives you an idea of what the HTML page will look like. I'll just select this layout. is figure out what we want to display, all the address information. And then let's just query on the city. And let's finish that. In a second, we'll Xcode. And-- whoops. Hello.

And let's that really quick. So as you can see, there's really not too much complex stuff here. What we got is a few Java files. We have one component, and our model. where we modeled our database. And boom, there's our app. And it's fully functional out of the box. So let's just search for an address.

And boom, we have our results really quickly. If we search for something that wouldn't be in there, then we have this table showing everything. So let's say I don't like the way this interface is, and I want to make sure this table does not show up. We can go into WebObjectsBuilder.

woe component here. And let's just look at it really quickly. And what we're seeing is this table here. I don't want it to show up. So I think I'll wrap that in a woe conditional, which I can say, hey, if there's no addresses available, then don't display the table. So right here, this question mark is our woe conditional. And let's go over and bind that to our count.

What that says is if there's no objects to be displayed, don't show that table. And I'm going to save that. And one great feature about WebObjects is that you don't have to always rebuild your app. If you're editing your WoE component, a lot of times you can just save your component and then refresh. So I'm just going to refresh this page. As you can see, I'm not going to compile the app at all. And boom, our table's not there by default.

If I search for sound, it's there. If I search for something that's not there, it disappears. So hopefully that gets across how easy it is to-- how fast it is to develop your applications. And you don't have to bother with your apps a lot of times. So back to Bob.

Thank you, Darrell. So we've built a model. We've actually generated a rapid prototype of an application. And you've seen how, with a completely visual environment, we can get in there and drag out the design. And it's a very rich tool. It's got images. It's got repeat loops. It's got conditionals. It's got tables. It's got all that kind of stuff in there. And you basically just drag it all out visually. And then if you need more complicated business logic stuff, this is when you start putting in the code. No messing with JSPs or any of that stuff. And this is where you can see the power starts coming in if you need to do incremental development. You pop this up, you add new features, save it, you go. The rapid turnaround where we didn't have to stop the app, build a war, redeploy, anything like that. Very seamless, very quick, very fluid. Keeps your mind going and focusing on moving the ball forward and getting the new features in.

Okay, so that's an example of kind of how you would go about building an HTML application. We also do web services. Now, web services have been getting a lot of buzz lately. And this is a good example. definitions of web services. One is anything that has something to do with the web and it might be a service. That's kind of like the big one that you hear a lot about and one that gets overhyped and everything like that.

Then there's the more narrow definition of web services. Really nothing more fancy than remote procedure we've been doing for 20 years, only we gave it a name. But one thing we do is we actually define a set of standards. So we do XML, we do SOAP, and we do WSDL. In a compatible way, we're everything from all the Java that Sun and IBM and everybody else is doing and even.NET. Now, this is actually a really good thing because the reason why this is a powerful concept and it's been taking off is that it's a real killer for application integration.

So you may have different departments that haven't been talking to each other, don't even care to, but if they both implemented web services and defined an API set, then both of them can hook these things together and it's out of operation. They don't even have to really bug each other. And that's why I think this is a low-hanging fruit where we're actually seeing truth in this, is a group and department level who have their own archive or store of data and they want to be able to share it. And that is really powerful and easy to do. And WebObjects is a great tool for that. And one of the things I'll mention is we do both the cloud side and the server side.

So the other thing that's kind of nice about web services is you don't really have to add a whole bunch. You know, you've got your application, you add a layer that's basically how to call it and how to figure out what the semantics are, and then you're done. And there's a lot of different ways to get at it.

So now all of a sudden, you can have a WebObjects Java server app, and you could vend web services that could be consumed by an Apple script somewhere, by Perl, by C++, by a Java app or a.NET app. So now you've basically expanded the scope but you can consume the services that you're building, which is always a good thing. And you empower a new class of programmers 'cause you don't have to get into the whole really heavy duty thing. If you can write a Perl script, can call a web service, then you're good to go and you're in the game.

So built web services, again, we use the model-driven approach here. And we have a tool for that as well. And so we can either consume web services, get a WSDL and a data point somewhere. We can actually get that XML, work with that, and aggregate that with other sources and do a presentation layer, like a web thing that may go and get like a currency of a website to do the calculation of the current conversion or something like that. We can do that. You've probably seen simple examples of going and getting the Fahrenheit or something like that.

OK, that's not terribly taxing to do that kind of thing. But taking data sources out of a database and actually doing the server side, there's not as many offerings out there for that. And what we can do is you have it in a data source, we can publish it and we can publish a web service interface for it. And any Java code that you have, you can also wrap that in a method and wrap that in a service as well.

And so you're the web service producer game, which is really exciting. And we do this without you having to worry about the XML, without having to worry about the SOAP, and without having to worry about the WSDL. view on services, XML, everybody's heard of that. It's just a markup language.

That's how you get the data represented. So in an envelope, and that's basically who it's coming from, where it's going to. And then WSDL is kind of like publishing it in a phone book and saying, here's my service, here's where it is, and here's how you call it. And so that's a nutshell. And so we have a tool.

which will let you basically go in and build a server and publish an interface for consuming web services. So what we're going to do is we're going to basically attach to a database, and we're going to show how we can actually generate complete web services producing application here with WebObject out of the box here. So we have, general for another demo here.

Okay, so let's go back to Xcode and create a new project. And what I'm going to do is create a direct-to-web-services project. We'll just call this test direct web services. I'll take the default options again. And here we go back to our real estate model. and build and launch. Now, while that's building, what I'm going to do is launch our web services assistant.

And what's going to happen is Safari is going to come up. It's going to give me a URL that I can use with the Web Services Assistant. And so what I'll do is I need to copy this URL to the Web Services Assistant and connect to it, and we'll get our app up here. So the first thing you want to do in your web service is create a new web service. So let's start that. and I see the Web Services button, and we'll just call this a listing service.

OK, so now that we have our listing service, I need to pick some that I want to publish. We'll just keep this really. And I'll select the listing address. So there we go. And now that I have my service, I need to tell it, OK, what operations or what can I interact with? So what I'll do is I'll create a new operation.

I'll just call this my list operation. And I need to tell it, OK, what entity or table do I want to display or query upon? And then I want to tell it what type of operation I want to do. So I can delete, or as an insert, or as an update. I'm just going to pick search.

So boom, we have our listing service, our listing operation. And the first thing I called is, OK, what parameters am I going to pass in to this operation? And I'll just-- similar to our last demo, I'm going to just take a city as a parameter, and I'm going to add that.

Notice down here there are different kinds of operators. Less than, greater than, equal, like, all the case insensitive like. Next thing we want to do, figure out what we're going to return after our operation is queried. So I want to return all the address attributes here. Okay, so now we've got our return values, and I think we're about ready to go.

Let's just save that really quick. And I want to test my server. So we have a nice little built-in testing assistant. And I can, without writing a piece of code, just start making queries on the application. So San Jose, but there is our are going to be returned. Now, if you do a query that has nothing there, or you can search on Cupertino-- oops.

Another great feature of our assistant is, once I've got my operations and all defined and stuff like that, we actually compose all the WSDL for you. So most people, they have to go out there and they have to hand code this, hand edit this, and figure all this stuff out, and how to bind this, and all the namespaces and stuff like that. What we do is we give you all the WSDL for you, and you don't have to do any of this. So-- Very good. So hopefully that demonstrates just how easy it is to build a web service. Are we having fun yet?

So then outside of WebObjects, Mac OS X and Mac OS X also just a great web services development environment because we bake it into the operating system. So you have all of the services from WebObjects, but then everywhere in Mac OS X, either client or server, Apple Events, there are OS-level features that will, OS-level services that basically turn that, can turn that into SOAP or XMLRPC and back and forth. And so you can actually, we have tools. There's one called WSDL Make Stubs. You'll find on your regular developer tool CD that if you give it a WSDL description file, it will generate AppleScript, Cocoa, or C++ bindings to actually consume that web service. So it makes it really easy to build an end-to-end application because you've already baked in a lot of the client stuff already into the operating system. the transport, the marshaling and unmarshaling of data types, all that's already in the OS. So it's really cool. So we've got it in Cocoa. We've got it in AppleScript. It's in Perl. It's in WebObjects. And so we're a great platform for all that. And then you can always take that client and put the web services side on another client as well.

Okay, and we also have the ability to build desktop applications or rich client applications. So the web services assistant that you saw there is actually a WebObjects application that was generated in Java Swing. So it's actually generating that application that we were using to actually configure the web service. When we hit the test button, it actually figured out on the fly what the test parameters and response types were going to be and generated the swing panel for that on the fly. We also have that technology baked into ability to build rich desktop applications also from a model-driven fashion. Again, Daryl, please. Okay.

Let me put all this stuff up here. So what I'd like to show you is a direct-to-Java client location and how we're taking the same real estate model and then just reusing it again to create a desktop Java application. So let's select that template. And we'll just name this JC.

Okay, and we'll take the defaults again, and then just add our real estate model. And these are some Java client specific things, whether you want to download your classes or you can optimize that for your efficiency. And here's some stuff for configuring Web Start. So let's just build and run that quickly.

As you can see, there's not much different in a direct-to-Java client project layout. I mean, we still have a certain amount of Java classes. There is one Java client component here that helps you configure some of the Java client parameters, but essentially, you know, a lot of the stuff is in the same place, and you have your model right there.

So it launched right here. And as you can see, we have a fully functional app out of the box. Let's just query on something really quick. We'll do our San Jose query again. And boom, this is a different entity. But as you can see, there's a bunch of addresses. If I double click on one of these rows, we have a lot of detail that we can configure. We can delete rows. We can add new information and make new relationships with that.

So it doesn't just end here. You can start configuring your interface. And what we have is an assistant that you can bring up and tell it how to present some of the data or what to present, what not to present. So what I'd like to do is just take away all of these entities that we were displaying earlier and just have it show our listing address.

The great thing about all our rapid turnaround tools is I don't have to recompile. I don't have to do anything. I just have to hit the Restart button in the Assistant. And boom, it updates the interface and everything. And boom, all I have is my listing address and exactly how I wanted it. And I can search on San Jose. And boom, there we go. And if you can notice, in all these demos, we've been using just one EO model, and we've published to web service, an HTML client, and a Java client. So hopefully that shows you the power of what our tools give you.

Thank you, Darrell. So this is often the way I'll work myself. I'll get in there, go up to some data source called reverse engineer it with the O model, and then I'll build a directed Java client. And that way I can go in there and start adding test data or going through and chaining and browsing through the sources and seeing what's there. It's just phenomenal. Just that aspect of it alone is phenomenal for exploratory programming where you're going to work with some existing data assets. It's also great for building a little database administration tool, just right out of the box. And with the box copy of WebObjects, if you buy the retail box, there's a couple manuals that come with it. One of them is a manual on building the HTML applications, and one of them is a manual on building the desktop Java applications. And I believe that'll get you the hard copy, but I believe all that same information is available in either HTML or PDF form on our website. There'll be a URL for that to our reference library later.

okay, that's building it. Now we need to deploy it because we want somebody else to use it except just ourselves, although I could sometimes sit on my laptop and just look at my beautiful application, but in the real world, somebody else should use them. So we have two different main ways of deploying WebObjects applications, and we have our own WebObjects deployment frameworks, and then we also have the ability of deploying it in a J2EE container, and you can take the same application, package slightly different, and you can deploy either with our application frameworks and a web application server, or you can put it on a standard J2E application server. In the case of the standard J2E application server, we just appear as a fat servlet.

So basically, the request response loop comes in, it comes in through the servlet handler, the URL gets transferred to us, WebObject stuff does what it would do, and then the results get passed stream. And then you have access to things like JDI variables and data sources. Some of the application servers that we support are Tomcat, JBoss, IBM, and BEA's application servers. So you can basically take a WebObjects application and you can actually have the developer tools that you want, but also live within any kind of a deployment infrastructure that you may need to live in. Now, the WebObjects deployment is a full-featured, cross-platform, pure Java application server. And this also comes in the box, comes along with everything that you've seen. And so it's got built-in clustering support. So it does load balancing. It does session management. And it does automatic application restart. So you get all of those services in there as well.

And then you also have some configuration and some monitoring tools that come with it. And this is not like tiered pricing or anything like that. This is just the way that the product comes. You get all these features. So what you can do is you can start very simply. You can get one box and... IT'S JUST A PURE JAVA APPLICATION. AND YOU CAN HAVE YOUR DATABASE, THE WEB OBJECTS APPLICATION, AND YOUR WEB BROWSER ALL RUNNING ON THE SAME BOX. AND THEN IF YOU NEED TO SCALE IT UP, WHAT YOU CAN DO IS YOU CAN ADD MORE WEB OBJECTS INSTANCES ON THE SAME BOX. SO YOU BASICALLY JUST RUN MORE PROCESSES, RUN MORE JVMs AND HANDLE MORE REQUESTS. MAYBE ADD ANOTHER DATA SOURCE.

Then you can also scale-- usually what people might do is they might separate it and have their web server on one machine, their database server on another machine, and then have their application server on another machine, right, so you might go with multiple boxes. And then you can actually stack them up and then keep going. So we support a full clustered environment of inexpensive units, you know, and do the scaling that way. And it's quite scalable, and we'll find out how later. So web objects in Apple, how do we use it?

just about any way that money can come into Apple, it comes in, Java is involved. And some of that is simple things like the point of sale systems. If you go to our retail stores, there are actually Java apps running on a Mac. They're actually Java applications. But a lot of revenue comes in through web objects.

We use it in dozens of internal applications, everything from finding our paycheck, I think vacation stuff. We have it on some process management or inventory management stuff. We've got bunches of different departments, bunches of different people using it. And it's also used in all of our internet offerings. So it is used if you have a.Mac account and you have the web mail. That is actually a WebObjects 5.2 application vending the HTML that's actually going into the mail. But a rather important application that is using WebObjects is the iTunes Music Store. The iTunes Music Store... Thank you. you may have heard of it, is entirely WebObjects 5.2. And it is running on Panther, and it is running on XSERVs. And the actual music data is on XRAID.

We actually have one of the people here who works on the software there. So maybe after the end of this session, you have some questions on it. He may be able to talk about proprietary stuff, but he could probably talk about some of it. It's a really interesting design because, in a way, it's kind of a web service application and an interesting approach. It's using WebObjects entirely on the back end. And then the client is, there's a Mac native client, and we just pass XML across the wire. So it's like an HTTP direct action, and then the response, instead of being HTTP, I mean HTML, is actually XML. So it's a nice example of being able to use Java on the back end of the server, where it's a natural fit, where people like to use Java. A way to have a very clean, responsive, well-integrated desktop application, use XML across the wire for the data interchange, and then we were able to support the Windows environment with a different native application but still talk to the same backend application. So it's a nice example of design, besides being just an outstanding store. It is the number one music store, online music store in the world, and there's a URL that should have an article talking just a little bit of kind of a high-level overview of just what's involved. I mean, the fact that it's XServe and X-Ray and web objects.

Now, how do you get WebObjects? There's a free trial version. So if you go to apple.com WebObjects, there's a button there, Getting Started, and it will basically tell you how to go find our ADC online site, and you need to get an ADC online membership, but that's free. And then you go to the Downloads section, and you can actually download a trial copy of WebObjects for Mac OS X. And it's a real full-running version. It's got every feature that you've seen here. and you need to download a 30-day license key.

But you can download it and try it. If you're running Panther, which we hope you are, the download that's there right now, we haven't updated it from the 5.2 version. So you'll want to hit the software update button and get current to WebObjects 5.2.3. So when you get the download, you also want to go through software update, and you also want to update to 5.2.3. That gives it basically the Panther integration. So the current version of WebObjects is 5.2.3. There was recently a software update, and that basically had some performance and stability fixes, and it also qualified WebObjects for Java 1.4.2.

Now, all of this, unit pricing, US anyway, is $699. We also have special education pricing at $99. And I don't recall the government pricing, but it's around $300, $400, somewhere in there. And I'm sure an Apple rep or somebody would be very happy to give you that information. And that includes both a developer license and a deployment license. So you get basically one developer seat and one deployment seat. And on that, on the box, again, that's also 5.2, so you'll want to update via software update. Then for more information, the main website to find out information on WebObjects is apple.com slash webobjects. you We also include the runtimes, the deployment side, on Mac OS X server.

I think if you get Mac OS X server right now, it's at 5.2.2 is the one that's built in, and so you need to get an upgrade there, and that brings you to 5.2.3, and then as a freebie, we throw in a later version of JBoss and a later version of Tomcat in there as well because it's in the same little application download. That's, I think, the application server's update on that. And with XServe or with Mac OS X Server, if you buy the retail box Mac OS X Server or if you buy an XServe, you get an unlimited WebObjects deployment license. So if you buy an application and your target deployment is going to be XServe or if you're owing an application for XServe, there's no runtime costs associated with that at all. So that's nice. That saves you right there.

I'm also very pleased to announce that the WebObjects training materials have been updated. So they've been brought current with WebObjects 5.2, and there are now classes scheduled. There have been a number of tutorials that have been, or many courses that have been offered here during this week. And the ones that were formerly known as P1 is Internet Application Development Using WebObjects. That's the introductory course. And then there's also the Advanced WebObjects Development course. So that's very good. And you can find out about that at train.apple.com.

Hey, WebObjects community. One of the really exciting things about WebObjects is there's a very vibrant community out there, very active, very involved community, and there are a lot of things beyond the WebObjects things that you get in the box that you have access to. So what I'd like to do is I'd like to highlight a few of those things that have come from the community that have actually enhanced, greatly enhanced, the WebObjects product and the WebObjects experience. Let me begin by saying, sorry if I exclude anybody, there's like a large list of people out there. And there's a large number of different places to find components for WebObjects and information about WebObjects. You could probably just go to-- let's see, you could probably just Google WebObjects and find a lot of those just right off the top of Google. But we're highlighting a few right here.

And one of the things that has been asked about a lot is the ability to do cross-platform development with web objects. So what I'm happy to introduce are the folks here for Woe Project. Woe Project is basically an ant build system. Now, one of the things that's really interesting about ant is it's pretty much the Java de facto standard now for building things. And one of the main reasons it's good is it gives you IDE independence. So let me say a couple things about IDEs. Just about any IDE you can want for Java development is available on the Mac.

And two, by now I'm hoping everybody is aware that some nice features have been added into Xcode, making it a better Java IDE, namely code completion and some ant integration in Xcode. And if you'd like to see more about using Xcode for just plain old Java development, there's a session tomorrow morning at 9 o'clock. I think it's Java development with Xcode. And you can see some of those features there, Java code completion and some of the ant integration there. So, what we're going to do is we're going to would be like one of the places where that could tie in is with the ant build system there. Another thing that you've been hearing about about at this conference is Eclipse and Eclipse, there is a plugin that is available that lets you do web objects application development, either on Windows or on the Mac, with Eclipse. And so now you've got a full Eclipse plugin that goes in there with that IDE. someone here from Project Wonder. And this is a collection of, it's a vast collection of a lot of frames and tools that kind of extend what you get with WebObject. So I would like to begin by introducing Andres Ljubic from ObjectStyle for WebObject.

things might go so now okay uh... is uh... and based uses As we all know, there's quite a few build systems that exist already. One is Make, which is a classic thing and everybody knows about it. Not everybody likes it, though. Another one is CodeBuild, which ships with Xcode. Actually, that's what people use on Mac now. And we're introducing another build system, which is on the end, which is a different standard now. It's called. So. There's plenty of reasons. One that Bob just mentioned is cross-platform development. Maybe it's not that, you know, audience but who develop all different platforms more important to all developers. You may want to deploy on Solara or deploy on.

One of the very important bits of the project and Ant in general platform is the And is designed to write something needs. And you do the same thing with feature needs with subclass. Another they can with please no one degraded with is that on your application. That's very maintain people if you multiple development group.

in those files in sync. You don't have to do it is all part of the test. Here is a simple and assemble and for repair we have a model and your end is up we enjoy your more it was loud break customer Then there is a task. This is just like Java C task.

that can actually support your frameworks looking for jar file inside the framework and like um it's either web framework was correspond and uh... use like a valid WAP application or the same thing you would expect from like Apple, and final little things that it's uh... called your mark environment database connection front test to it was it to your We got rid of project file. Some tools still in there is war builders that realize project file on Windows and information on Macintosh, you still need to make But this time, it's not just like you don't have to think about. And for the file based on some patterns. It's the same to compile your application. The same with the index file of the task project. all the before and just Code index It hasn't been and you can do the same And finally, project around the community. site is slash war project. Mail it. Please ask questions. Thank you.

Thank you very much, Anand. Now I'd like to thank Ulrich Koster, and he is going to talk about the Eclipse plug-in. Thank you. go. Thank you, Bob. Once again, I'm the project lead of the Volelabs team. I'm here to talk, to give you an overview of Volelabs. Um, text. YouTube. So.

things like debugging, It takes a It clips as a full feed This contains everything you need from a state of the art IDE like an is code navigation, debugging, and much more. The handful of plugins picture you over Jade up to see just the name of it's just another in for your applications Since we have already a whole clip, we can concentrate on volib. of volib.

We have wizards to create application, frameworks, components, and aero modality. We have also an incremental builder fast and for deployment and a model included As a double clicks the component awesome finding but Okay argument session hand and on That could break basement or change value very it's even possible multi-parking one different machine turnaround scenario find more information about eclipse and the home page covers installation of O-Lips and integration integration with the Eclipse Help System. To provide feedback about willips reading this link to the track and the page here for con so if you have any questions thank you for Thank you Ulrich. I'll make that one from you. This is really cool. myself, with the work we've been doing on Xcode, but the new thing and some of the so you'll find the Xcode experience will get better and better for making that forward.

IDE. And so some of the people programming get into the zen of with building these incremental components and re-components. And combination of these things here is pretty phenomenal. I'd also like to introduce Max Muller for Project Wonder, because there's a whole world of other events that can be added in as well. Thank you.

Hello. My name is Matt Miller. Currently I'm one of the lead engineers for the iTunes music store. But also one of the founders of... So, let's see. Project Wonder was born actually with the death of a. A number of engineers who actually now Apple. We built a number of frameworks specializing in rapid application development. folks. web as well as just a number of nice to EOF and foundation based frameworks.

defined in the actual frameworks themselves, because they're kind of special. that you don't really need often. But so we seeded the frameworks to Project Founder And since then, kind of embraced to also contribute and code. So here we are two minutes later with frameworks that are approaching have grown we started with like five projects 22 projects now so It's mainly just a nice collection point for a lot of source projects, everything from SVG generation, that Anjo just committed in, Excel generations, actually Wo components that represent a bunch of Excel sheets and tables, but it's still using WebAutoBuilder and you're still able to build Excel spreadsheets but integrate it in with all the EFF back-end. So it's just a bunch of nice frameworks written by-- developers who know a lot about the technology, and so it also serves as a very nice reference point for, well, how would I actually get in, say, a template parser if I wanted to change the of a WAD binding, or some arcane knowledge like that, and it serves as a good reference point. We hear a few highlights of some of the stuff that's found in some of the frameworks of Project Wonder. One of the nice things is we have a fairly international group on Project Wonder. They've added in automatic localization support, so all the Japanese encoding has taken place.

It kind of adds support for all the other encodings that you'd want and automatic localization on the way in and out. Often times you have to worry about making sure that you're parsing in the headers for the languages and getting that correct on the way in and the way out. There's been a lot of work done into that as well as localization down into the validation messages that pop up when you forgot to put this into your model.

Another focus has been the rapid application development process and taking that one step further. The configuration management tools have really helped in the sense that you can now reload all of your property files automatically. You can turn SQL debugging on and off. You can even change, we use log4j throughout the project, so you can even go in and actually change the log4j patterns that you're printing out on the log statements. And being one of the people who has to go in and track down a bunch of really strange behavior that goes on at the music store, being able to go in and get a backtrace in all of a sudden on some very strange occurring log, and then being able to look in the log files and see that start to come up and exactly what's triggering it, as well as, say, the entire request with all the request values is incredibly helpful. So it's definitely saved me some time.

Examples of building custom qualifiers, the database independence is nice, but sometimes you really need to use who's an end statement, or a subselect statement, or one of some of the more advanced EU, some of the more advanced SQL qualifiers. So there's a number of custom qualifiers there that if you're interested in learning how to write one of those, then they offer support for that. What else? So within the direct-to-web stuff, There's probably about two years of very advanced development that's gone on around kind of an overhaul of a lot of the rule caching systems. There's over 200 more components that are useful for doing all sorts of crazy direct web things in the context of the rapid application development. So there's a whole wealth of things there. And yeah, I mean, just really, it's just a lot of-- within the base frameworks, there's just a lot of really nice reusable components that shows how to do fun stuff with the HTML, fun stuff with JavaScript. Pretty much all the things that you think of when you're developing. But these are, again, specialty components that you don't run into every day or need every day. So actually announcing today is the Wonder 2.0. It's been a long time coming. Yeah.

I have been stuck in the 1.0 branch forever, and getting sick of maintaining that branch, so now we are jumping to the 2.0 branch. Wonder has Eclipse support using WoeLips, thank you very much, and WoeProject. The whole thing builds with Ant and works out of the box with Eclipse. We are finally getting Xcode support in. We have been dragging our feet on that one, but most of the projects should have Xcode projects now as well. So we're at wonder.sourceforge.net. We have a fairly active CVS list as well as an active discussion list. So check us out. All right.

take that too. Thanks. Thank you. Thank you very much, Max. So that gives you some highlights of all the different things that are out there that are beyond just what Apple does with WebObjects. So to send feedback or contact us, there's WebObjects at Apple.com. And that goes to more than just me. There's other people who see that as well. That's a good way to give feedback. Another thing that's very important, if you find reproducible bugs, then definitely file bugs. and hopefully can provide detailed information or test cases or something like that, that's always really helpful.

And for more information, there's the apple.com webobjects site. There's also the webobjects reference library, which is available. You can either just go through developer.apple.com and just hit reference library and look for webobjects, or here's the specific URL. And the reference library has been updated and contains a wealth of stuff. Now it's got an easy way to find everything from reference APIs to documentation to tech notes to Q&As. It's all easily navigable from one place.