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. 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? Okay, 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 is 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, it 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 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.

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 X code or Windows, and you can 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 let you do code free prototyping. But then these are extensible and 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 now an outstanding package of web services, both as a consumer and a provider. And 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 great 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 I'm not complaining.

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 life cycle 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 like 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. 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 GNDi 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. 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.

So step one is building the model. Now what EOModeler 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 ESQL 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.

So, 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. And 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 plug-ins 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. 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. 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. Okay. Sorry about that.

Okay. 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 GNDi 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 features. Cheers. And with that, I would like to invite Darrell Lee up to give a demonstration of EOModeler.

Hi, everybody. So I just want to show you a modeler. Can we bring up the demo machine? Okay, 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 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 of 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 -- 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 file. And then you can see that we have a 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, Darrell. Okay, 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, you know, the aerospace industry where you're going to go with a six months design requirements and then you get a bunch of programs working on it and then six months later you decide, that isn't quite what I wanted. All right. This is a much more fluid, interactive way of working. Prototype is generated. is the founder of WebObjects.

He's been running the WebObjects platform for over a decade.

is the founder of WebObjects. He's been working with Apple for over a decade. He's been is the founder and CEO of Apple. He's been working with Apple since the beginning of ...the application. Each of these steps along the way, it's... ...the application. And so what happens along the way is continuous integration. And so... ...the... So I feel this gives you actually a better way to develop an application.

So with WebObjects, you get a tool, a web builder. WebObjects 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.

is the first person to be on the panel.

He will be presenting his presentation at the picture of the and at the bottom we've got some of the keys and some of the

is the founder and founder of WebObjects. He's the founder and founder of WebObjects. Then at runtime, what we do is we take an HTML template, we take data coming from is the founder of Apple. He's been working with Apple for over a decade. He's been working

Another demonstration here of building a simple application and how you can finally modify it. Thank you, Bob. What I'd like to show you is a real simple design. Hi, everyone.

I'm Bob Fraser. I'm the CEO of Apple. I'm the CEO of Apple. Hi, everyone. I'm Bob Fraser. I'm the CEO of Apple. I'm the CEO of Apple. Hi, everyone. I'm Bob Fraser. I'm the CEO of Apple. I'm the CEO of Apple. So the next thing it'll ask me is what is the main idea 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. The first thing we're going to do 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.

and Bob Fraser: And boom, we have our results really quickly. If we search for something that wouldn't be there, then we have this table showing. 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 WebObjects Builder.

Hello, everyone. I'm Bob Fraser, CEO of WebObjects. I'm going to talk about the WebObjects and the Web Component. I'm going to talk about the Web Component and the Web Component. I'm going to talk about the Web Component and the Web Component. I'm going to talk about the Web Component and the Web Component.

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 WoW 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

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. So we have two definitions of web services. One is anything that has something to do with the web and it might be a service. And 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.

And the more narrow definition of web services is really nothing more fancy than remote procedure code that 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 getting 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 lights out operation and don't even have to really bug each other.

And that's why I think this is really taking off. The low hanging fruit where we're actually seeing in this is people at group and department level who have like their own archive or store of data and they want to be able to share it. And that is really important. And that is really important. 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 that 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 .NET app.

So now you've basically expanded the scope of how you can consume the services that you're building, which is always a good thing. And you empower a new class of programmers because you don't have to get into the whole really heavy-duty thing. If you can write a Perl script and 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. 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. Bob Fraser You've probably seen, you know, simple examples of going and getting like Fahrenheit or something like that.

Okay, 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.

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 WebObjects out of the box here. And so we have Daryl 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. will just call this test direct web services. And 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.

So far, Safari is going to come up and give me a URL that I can use with the Web Services Assistant. 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.

Okay, so now that we have our listing service, I need to pick some ideas that I want to publish. We'll just keep this really simple.

I'll just call this my list operation. And I need to tell it, okay, 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, okay, 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.

Next thing we want to do is 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. : I can, without writing a piece of code, just start making queries on the application. So, San Jose, there is our are going to be returned.

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 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, So, we have 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 services that basically can turn that into SOAP or XML RPC and back and forth. And so, you can actually, we have tools.

There's one called Make Stubs. You'll find on your regular developer tool CD that if you give it a WSDL description file, it will generate AppleScript, Java, it will generate AppleScript, Cocoa, or C++ bindings to actually consume and produce, to consume that web service. So, it makes it really easy to build an end-to-end application because we'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, 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 of 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 build the, to actually configure the web service.

When we hit the test button, it actually figured out on the fly what the test button was. So we figured out 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.

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, 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 WebStart. 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.

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 old 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 deploy it in a J2EE container. And you can deploy either with our application frameworks and web application server or you can put it on a standard J2EE application server. In the case of the standard J2EE 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. WebObjects stuff does what it would do. And then the results get passed up back upstream. 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. Okay. So the WebObjects deployment is a full-featured cross-platform pure Java application server.

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 the product comes.

It's just a pure Java application and you can have your database, the WebObjects 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 WebObjects 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 WebObjects 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 WebObjects.

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. You may have heard of it. It's 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 client.

So it's a nice example of design, well, 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 WebObjects.

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 Download 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.

Bob Fraser 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. Bob Fraser Then for more information, the main website to find out information on WebObjects is apple.com slash webobjects.

We also include the run times, 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 the, I think the application servers 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 run time cost 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 the 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 I'll highlight 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 WebObjects. So what I'm happy to introduce are the folks here for Woe Project. Bob Fraser 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 Bob Fraser: 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:00. 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 "The WebObject 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 at this conference is Eclipse.

And With Eclipse, there is a plugin that is available that lets you do WebObjects 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. is someone here from Project Wonder. And this is a collection of, it's a vast collection of a lot of frameworks and tools that kind of extend what you get with WebObjects. So I would like to begin by introducing Andrzej Malczyk from ObjectStyle for WebObjects.

I think the mic is off. OK. Our project is an app-based build system for WebObjects. As we all know, there are 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. The other one is CodeBuild, which ships with Xcode. Actually, that's what people use on Mac right now.

We're introducing another build system, which is a different standard now. It's called WAP. There's plenty of reasons. One that Bob just mentioned is cross-platform development. Maybe it's not that, you know,

and more employees are coming to the event. You may want to employ on salary or in less than a year or more.

One of the very important benefits of WebObjects and Ant in general platform is the freedom to

WebObjects is a new platform for web-based software development. It is a platform for

is the founder of WebObjects. He is the founder of WebObjects. He is the founder of WebObjects.

is a member of the WebObjects team. He will be sharing his experience with us. and finally there's a little thing that you can do to update your app called EOMoral.

We got rid of Project File. Some tools still in use. There is Warbuilder that relies on Project File on Windows.

is the founder of WebObjects. He is the founder of WebObjects. He is the founder of WebObjects.

and finally, our project around the community. The website is www.op.com.au. Please ask questions. Thank you.

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 the WebObjects.

is the head of the WebObjects team. takes it. Eclipse is a full feature of the Eclipse. The feature contains everything you need to know about the state of the art IDE.

Like an is the head of the WebObjects team at Apple. He will be talking about the new features of the WebObjects app.

Since we have already a whole clip, we can concentrate on Volip.

and Emma Dollar included. As an example, just double-click the component and you'll find the WebObjects.

will talk about session handling and on. Set conditions for breakpoints, replacement or change of values, and variables. Steve Imposible, Mutibar Communications, running on a different machine. Turnaround is the next episode. and find more information about Eclipse and web-based software for your home page. covers installation of VOLIPS and integration integration with the Eclipse Help System. To provide feedback

I'd also like to introduce Max Muller for Project Wonder, because there's a whole world of other things that can be added in as well.

Hello. My name is Matt Mueller. 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 .NET, a number of engineers who actually now work at Apple. We built a number of frameworks specializing in rapid application development. ... as well as just a number of nice ... to EOF and Foundation ... frameworks and a lot of ...

: We've seeded the frameworks to Project Founder 2.0.

It's mainly just a nice collection point for a lot of open source projects. Everything from SVG generation, that Anjo just committed in, Excel generations. I have actually WoE components that represent a bunch of Excel sheets and tables. But it's still using WebObjects Builder and you're just able to kind of build Excel spreadsheets, but integrate it in with all the EF backend.

So, it's just a bunch of kind of nice frameworks written by... : I'm a developer who knows a lot about the technology, so it also serves as a very nice reference point for 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. Let's see.

We're here to give you a few highlights of some of the stuff that's found in some of the frameworks of Project Wonder. So one of the nice things is we have a fairly international group on Project Wonder. So they've added in kind of automatic localization support, so all the Japanese encoding has taken place. And it kind of adds support for all the other encodings that you'd want and automatic localization on the way in and out.

Oftentimes you have to worry about making sure that you're parsing in the headers for the languages and kind of getting that correct on the way in and the way out. So 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 kind of thing.

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.

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-to-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 kind of all the things that you think of when you're developing, but these are, again, kind of 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.

I have been stuck in the 1.0 branch forever and getting sick of maintaining that branch. Now we are jumping to the 2.0 branch. Wonder has Eclipse support using WoeLips 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. Most of the projects should have Xcode projects now as well. We are at wonder.sourceforge.net. We have a fairly active CVS list as well as an active discussion list. Check us out.

So that gives you some highlights of the, you know, 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 this, the reference library has been updated and contains a wealth of stuff. It's got, now it's got an easy way to find everything from reference APIs to documentation to tech notes to Q&As. It's all like easily navigable from one place.