Learn what is D2W, a description of the D2W technologies and where they fit into the WebObjects frameworks. David will also show you how to change the look of an application so that it doesn't look like D2W and how you can create your own D2W template components.

Show full session description

Hide full session description

In this two-parts session you will learn:

Part 1

• Introduction
• What is D2W - A description of the D2W technologies and where they fit into the WebObjects frameworks
• D2W Overview - Understanding the D2W components
  • Rule Engine
  • Rules
  • Common Rule Keys and Assignment Types
  • Role of the D2WContext
  • The Look and templates
• Building a D2W Application
• Modifying D2W behaviour with Rules

Part 2

• Exploring the role of the Look
• Making D2W not look like "D2W"
• Why MVC is mandatory
• Using Custom Components
• Controlling flow with the next page delegate
• Creating your own D2W Template Components

Learn how to use Capistrano (tips and tricks included) to deploy your applications, monitor your servers and backup your data.

Show full session description

Hide full session description

Deployment is one of the crucial steps of the development process. It must be automated - especially for web apps - and a lot of different tools emerged in recent years to automate deployments in various ways. One of such tools is Capistrano - a popular instrument in Rails community, built and used internally by Rail's creators - 37signals.

Capistrano (as anything from 37signals) is implemented in Ruby - but it doesn't require in-depth Ruby knowledge in most cases. The key feature of Capistrano is the ability to easily execute shell commands and upload files on any number of remote hosts. It allows you to react on the output from these commands, supports transactions and rollbacks. While very simple for non-Ruby users Capistrano becomes even more powerful for developers with some Ruby knowledge. While doing this session, we will start with small real-life deployment recipe example (deployment scripts are called "recipes" in Capistrano) and will continuously extend it demonstrating Capistrano features along the way.

In this session you will learn:

• The extreme minimum of Ruby that is needed to use Capistrano
• The most number of Capistrano features (tasks, roles, variables, transactions, triggers, etc...)
• How to execute remote commands with Capistrano and react on their output
• How to use Capistrano to monitor your servers
• How to use Capistrano to deploy your applications
• How to use Capistrano to restart WO applications
• How to use Capistrano to backup your data
• How to integrate Capistrano with Hudson
• Best practices of designing Capistrano recipes for a set of projects

The result of the session will also be a release of Wondercap - a set of Capistrano extensions that:

• Tremendously simplify Capistrano usage in multi-project environment
• Contain extensible and flexible set of build and deployment recipes for such common tasks as: deployment itself, servers monitoring, db backups, wo apps restart, selenium testing and more.

In this session, you will learn :

• Introduction to Test Driven Development.
• Levels of testing.
• Meet the tools - ERSelenium, JUnit, JMock.
• Demo of creating a meaningful WebObjects application from scratch, guided by tests.
• Testing best practices (Selenium tests organization, creating test data, Selenium setup methods, etc).

Learn the deep down details of how validation works in EOF and in WOComponents and how to extend and customize validation. Participate in the development of Open Source next generation validation frameworks for WebObjects.

Show full session description

Hide full session description

Validation is one of the least satisfactory parts of WebObjects. It shows signs of promise and of abandonment, like a prototype left uncompleted. We will start with a survey of the state of validation in WebObjects and the extensions found in Wonder's core ERExtensions frameworks; the seldom used Validity framework; and in the GVC EOFValidation framework. We will then dive in to take a look at EOF validation "deep under the covers" focusing on the mechanics of how it can be extended. We will then define the functionality that will make the next generation of validation for WebObjects and examine an implementation.

With a validation roadmap in place and a highly functional validation base available, we will turn our attention to the WOComponent presentation layer. Here, too, validation handling leaves much to be desired and the functionality is not clear. We will look at the often ignored validation handling in WOComponent and how it quickly breaks down. We separate WOComponents into two categories, Pages and PageComponents, and get them to co-operate in handling validation. The result will be a page that can orchestrate validation handling, including handling optimistic locking exceptions equally whether they occur within one EOF stack or across instances. This will allow us to create drop-in components that can handle their own validation in a co-operative fashion with the page. As with validation, a functional, documented foundation will be supplied.

In this session you will learn:

• how WebObjects validation is implemented
• how WebObjects validation can be extended
• how to make working with validation easier
• how validation handling was intended to work with WOComponent
• how to bring working validation handling to WOComponent
• how to detect optimistic locking exceptions within one EOF stack
• how to handle all optimistic locking exceptions
• how to use inheritance and composition to make validation handling and presentation painless
• how to contribute to the future of EOF validation

The result of this session will be the release of two new frameworks for WebObjects validation (one for the EOF layer and one for the WOComponent presentation layer). These frameworks will be written to be independent of other frameworks (including Project Wonder) so everyone will be able to use and benefit from them. These frameworks will be functional, but there will be areas where additional functionality can be added (such as support for additional databases). The intention is that these will get completed by others in the community.