ShowTable of Contents
Unsure where to go next as you learn Web Experience Factory (formerly known as WebSphere Portlet Factory)? This document provides a roadmap that lists some key resources and suggestions for building Web Experience Factory skills, from your first installation to advanced topics. The learning roadmap provides a number of resources, including demonstrations, product documentation, and education offerings, to help developers get started with IBM Web Experience Factory.
Note: Some of the articles linked to below may continue to refer to WebSphere Portlet Factory. These topics are also relevant to getting started with Web Experience Factory.
Installing and getting started
- Install Web Experience Factory, create projects, and run sample models
- Make changes to models and test your changes
- Deploy and update models running in WebSphere Portal
- Understand Web Experience Factory concepts and the designer environment
- Find key resources
|View introductory videos
||There are several short videos here that introduce key concepts and show how to get started: Video Gallery
|Install development environment
||Available as free download or as part of WebSphere Portal installation. For the easiest initial experience, install with a new Eclipse and with the WAS CE runtime.
Web Experience Factory 8.0 trial download on Web Experience Factory 8.0 trial download.
|Learn to edit, run, and test models on WAS CE
||Using WebSphere Application Server Community Edition (WAS CE) can be the easiest way to start with Web Experience Factory, and you can easily change to using Portal server later (see "Set up a WebSphere Portal test environment" below). Quick Start for using IBM Web Experience Factory with IBM WebSphere Application Server
View a short demo of creating a new project using WebSphere Application Server CE
|Learn key concepts
||Become familiar with WebSphere Portlet Factory and learn what it can do for your portal development team. Get a conceptual overview of Web Experience Factory and high-level explanation of how the tool is used.
|Explore product samples
||Product samples are available from the Tutorials and Samples / Applications feature when you create a project. See the OrdersServiceConsumer model for a simple model that uses a service provider/consumer architecture.
|Set up a WebSphere Portal test environment
||For developing and testing with complete Portal functionality, we recommend a local Portal server on the developer workstation. To set up a test environment with local Portal, see the following link.
Creating your first application
|Take advantage of the Getting Started forum
||This forum is for developer discussions about installation, use, and deployment of Web Experience Factory and related products. This includes setting up your deployment environment, and configuring related products including Tomcat, the JDK, WebSphere, Notes/Domino, RAD 6, and Eclipse.
IBM Web Experience Factory: Getting Started (Installation, Configuration and Deployment)
|Become familiar with other Web resources
||This section provides a collection of links to helpful WebSphere Experience Factory resources
Getting started with developing applications
- Build applications with a service provider/consumer architecture
- Use presentation builders such as View & Form, Data Service User Interface, and Data Field Settings
- Control application execution with Action Lists
- Add builders for page elements and to customize the look and layout of pages
Downloading and running samples
|Take advantage of samples on the wiki
||The Web Experience Factory wiki includes a large selection of sample applications which you can download and run. The sample packages (.zip or .pkg) should be installed with the Designer's Import / Web Experience Factory Archive command from a project. The UI-related samples do not in general have external dependencies, but some of the data access samples involve access and configuration for back-end systems.
Web Experience Factory Samples Directory
Accessing data and services
- Create service provider models with testing support
- Access data from back end systems such as relational database, SAP, or Domino
- Call WSDL and REST services
- Implement paging so that large result sets are retrieved in small chunks
|Take advantage of data access samples on the wiki
||The samples in the wiki cover a variety of data sources. The most generic is probably the SQL sample, and there is a Cloudscape sample data base for use with the sample. If you will be working with another data source such as Domino, SAP, or external web services, there are samples you can use for those data sources also.
Data Access samples from the Samples Directory
|Complete the tutorial for creating a database application
||This tutorial lets you create a complete application using a database table created with the SQL Table Create builder:
Tutorials - Creating a database application: WEF8.0
|Install and explore SQL sample
||This SQL sample can be used with a Cloudscape database, which is available as a free download as documented with the sample.
Creating a SQL service
Creating an SOA based application using a relational database in WebSphere Portlet Factory
|Install and explore Domino samples and articles
||The Domino sample and article includes a sample database, and shows how to implement full create, read, update, delete (CRUD) functionality using a service provider/consumer architecture.
Creating a Domino Service
Also see this presentation about integrating Domino data.
Integrating IBM Lotus Domino into Your Portlets with IBM WebSphere Portlet Factory
This tutorial shows a number of techniques for accessing Domino, but it doesn't utilize a "best practices" service provider/consumer architecture, using the Domino Collaboration builders.
Using Domino collaboration builders
|Install and explore SAP sample
||This SAP sample works with most SAP systems, since it uses "flights" data that ships as a sample with SAP.
Creating an SAP service
This tutorial shows how to create an application that uses a new database table:http://www-10.lotus.com/ldd/pfwiki.nsf/dx/Tutorial_Creating_a_database_application_wef8
|Install and explore web service sample
||This sample includes a web service provider and a consumer.
Using and creating WSDL-based web services
|Install and explore REST service samples and articles
||This sample uses a publicly-available REST service from IBM.
Using the REST Service Call builder
This sample shows how to access Lotus Connections using REST services.
Lotus Connections Integration Samples
These samples and articles show how to access Lotus Quickr content using REST services.
Creating a Lotus Quickr Service Using the REST Service Call builder
Accessing IBM Lotus Quickr REST services using IBM WebSphere Portlet Factory
Integrating IBM Lotus Quickr with IBM WebSphere Portal using IBM WebSphere Portlet Factory
|Learn key concepts and interface definitions for the Data Services layer
||Chapter 4 of the Portal Application Development Using WebSphere Portlet Factory Redbook provides an overview of the Data Services capabilities of WebSphere Portlet Factory, and continues with the definition of the service interface as the first step in the creation of the Data Services layer. Chapter 5 continues the discussion and provides implementation details for a custom data service, SQL Data service, Domino data service, and a data service to access an external web service.
4. Data Services: Overview and interface definition
Chapter 5. Creating data services: Access to back-end systems
|PeopleSoft and Siebel samples
||The PeopleSoft or Siebel feature set, which you can optionally install in Web Experience Factory, includes samples. The samples utilize an approach that combines user interface and data access functions in a single builder. We would recommend using a service provider/consumer model architecture rather than the single-model approach used in the samples. Note also that the interfaces used in the samples may not be available on all servers.|
This Siebel sample shows how to access information from Siebel using a provider/consumer architecture, which is the best practice approach for data integration: IBM - Creating a Siebel Service
|BPM and Process Server builders
||Use builders to integrate human tasks from IBM BPM and WebSphere Process Server.
The Unified Task List Developer Pack includes builders for access human tasks that are defined with WebSphere Integration Developer and deployed on WebSphere Process Server. These builders can be used to create custom task lists and task processing forms that work with WebSphere Process Server tasks. For more information:
Unified Task List Developer Pack
Unified Task List
The following article is part of a 3-part series and talks about using those human task builders http://www.ibm.com/developerworks/bpm/bpmjournal/1209_richter/1209_richter.html
Enhancing and customizing the user interface
- Build a user interface for list and details, create/read/update/delete (CRUD)
- Control formatting and validation
- Add builders to customize page elements
- Create custom page layouts
|Learn about the various techniques for customizing the application user interface
See Customizing your generated UI.
|Learn about the different approaches to controlling page layout and design
||See Creating Your Applications UI.
|See OrdersServiceConsumer model in product
||Included with the product install, add the Samples & Tutorials / Applications feature to your project. This model includes full CRUD capability using a sample service provider model.
|Review chapter 7 of the Redbook
||Chapter 7 of the Portal Application Development Using WebSphere Portlet Factory Redbook provides techniques for designing a user interface.
Chapter 7. Creating portlets: Designing the UI
|Learn to use "theme" support
||Web Experience Factory includes powerful new capabilities for controlling the look and style of an application in a very centralized way.
Themes and user interface control
Working with themes
|Explore using a custom layout page
||This article help you create a custom layout for an entire page of data, or for part of a page.
Custom Page Layout with IBM WebSphere Portlet Factory
|Learn to use other page builders
||To learn about the rich set of builders available for adding and controlling page elements, explore the Selecting builders for common tasks section of the Getting Started Guide. The builders discussed in this section of the guide handle tasks from adding buttons and links to implementing Ajax and Dojo functionality.
Getting started with Web Experience Factory V8.0.0
|Explore sample showing multi-language support
||This sample and article shows how to build a portlet for localization, using profiling and the Localized Resource builder:
|See sample and article on validation and formatting
||Page Automation, Formatting, Translation and Validation
NOTE: this article predates the formatting functionality introduced in version 7.0, in particular the Data Field Settings builder
Developing mobile and multi-channel applications
- Develop applications for smartphone devices that have a native-looking UI and access phone features such as geolocation
- Build multi-channel applications that leverage Portlet Factory's dynamic profiling to render to multiple devices from a single source model.
Ajax and Rich UI Techniques
- Add drag and drop capability
- Use popup tooltips
- Support partial page refreshes
- Build great-looking interactive applications that leverage Dojo, Ajax, and rich UI.
|Install and explore the latest sample of using Dojo, Ajax, and rich UI techniques
||See how to use IBM WebSphere Portlet Factory to create applications with interesting and colorful, customized User Interfaces.
Rich Web User Interface Sample
|Learn to use AJAX with Web Experience Factory
||This article and accompanying sample shows you how to use the Ajax-related features.
Using Ajax techniques
|Explore Ajax/Dojo samples
||See how to use the Dojo-related features.
Dojo Extension sample
See how to use the Ajax Type-Ahead builder in conjunction with a data service (such as a SQL Call builder) to obtain a limited set of type ahead suggestions.
Ajax Type-Ahead sample using database filtering
See how to use Dojo to implement drag-and-drop, inline editing, and tooltips in your applications.
Dojo Extension sample
See how to manually apply the Dojo rich text editor to a field on a page and how to create a custom builder that automates the use of a Dojo widget. (Note that the Dojo rich text editor is relevant for versions prior to 6.1.5, since 6.1.5 has an out-of-the-box rich text editor builder.)
Dojo Rich Text Editor sample
Working with profiling and portlet customization
- Enable portlet customization by business users and administrators
- Use Edit and Configure modes in Portal, with automatic or customized user interface
- Create different application variations for different user groups or roles
|Profiling portlets tutorial
||This tutorial shows how to implement Edit and Configure modes in Portal, and it shows how to have different variations associated with different Portal groups.
Profiling portlets tutorial
|Learn more about profiling
||Chapter 9 of the Portal Application Development Using WebSphere Portlet Factory Redbook provides a definition of profiling, conceptual information, a sample, and best practices.
Chapter 9. Customizing the application using profiling
|Download and run sample of profiling to groups
||This tutorial show you how to implement the WebSphere Portlet Factory's profile selection handler WPS Group Segment Handler on an IBM WebSphere Portal 6.0.1 or higher.
Using the WPS Group Segment Handler
|Explore samples for profiling and portlet customization
||In the WebSphere Portlet Factory wiki contains samples and articles about techniques that you can adapt for your applications.
Profiling and runtime customization
Enabling portlet communication
- Use Property Broker and WebSphere Portlet Factory events
- Use shared variables
- Use client-side events
|Learn about inter-portlet communication
||This article with the accompanying sample shows you how to use WebSphere Portlet Factory to implement inter-portlet communication including Click-to-Action, Property Broker, Portlet Factory events, and shared variables.
Using inter-portlet communication
|Learn about the different types of portlet communication
||Chapter 8 of the Portal Application Development Using WebSphere Portlet Factory Redbook provides an overview of the different types of inter-portlet communication and best practices.
Chapter 8. Enabling portlet communication
|Download and run samples of client-side-events
||The Ajax sample pack includes client-side-events samples.
|See the Dynamic Portal Page Processing builder to launch dynamic portal pages
||The Dynamic Portal Page Processing builder generates operations to launch dynamic portal pages, pass properties to the launched page and receive properties in portlets running on these pages. It is included as part of the Unified Task List (UTL) Developer Pack, but it can be used independently of the UTL itself. For more information about the UTL Developer Pack: Unified Task List Developer Pack
Working with XML and Java
- Create schemas
- Transform data
- Incorporate hand-edited Java classes and libraries
- Build and deploy WAR files for test and production
|Review product documentation about automating the generation of WAR files
||This section of the documentation describes how to generate a WAR from source files using an ANT script.
Automatic generation of WAR files
|Review chapter 11 of the Redbook
||Chapter 11 of the Portal Application Development Using WebSphere Portlet Factory Redbook describes the production deployment of the portlet WAR generated either from the WebSphere Portlet Factory Designer or using ANT scripts.
Chapter 11. Production deployment
Understanding application architecture
- Understanding Web Experience Factory architecture
- Building portlets from multiple models
Debugging your Web Experience Factory application
- Basic understanding of Web Experience Factory development
- Basic understanding of logging and Java
|Learn how to debug your Web Experience Factory application
||This is an article that goes over general debugging techniques within Web Experience Factory. There are also links to further information provided within the content.
Debugging your Web Experience Factory application
Working with advanced features
- Control application variation through a properties file
- Create a custom profile handler
|Explore sample profile handler that gets values from a properties file
||This sample includes a profile values handler that reads values from a properties file. This can let you control any builder inputs for a project from a properties file. For example, you could use it to configure environment-specific values such as server names or data source names.
Profile management via properties file
|Explore the profile selection handlers provided in the Portlet Factory product
||This section of the product documentation talks about the sample profile handlers provided in the product.
Profile selection handlers
Working in a team development environment
- Use a source code control system (CVS) with Web Experience Factory
- Create builds from automated or command line tools
Creating custom builders
- Create builders to implement new design patterns
- Create builders that integrate new data sources
- Control a builder's design time interface
Designing for performance
- Build applications with optimized performance and scalability
- Diagnose performance issues and hot spots
- Monitoring system performance
|Read performance tips
||Learn more about best practices to improve performance and memory usage. This page collects some best practices for Portlet Factory related to performance and memory. This is not a comprehensive list, and most of the best practices for the underlying platforms – WebSphere Portal, J2EE and WebSphere Application Server, and Java – are also applicable for Portlet Factory applications.
Performance best practices
|Explore system tracing and model action tracing
||Model action tracing provides a very quick and valuable way of looking at your application performance. Often you can use this feature to quickly determine which parts of an application are the slowest.
There are two ways to enable and view model action traces: (1) you can enable tracing via a property as described in the link below;
or (2) you can enable tracing from the Run Configuration dialog in Designer, which will then write traces to the system.out file.
This feature lets you see all the actions that take place during server requests to a model. It shows the sequence of operations, such as calls to methods and page display, with elapsed time for each. This is most useful for looking at application behavior for a single user during testing. See the link below for information on interpreting the traces.
Techniques to enhance WebSphere Portlet Factory application performance
|Review key server statistics
||Learn how to analyze the performance of your Web Experience Factory application.
Server statistics and performance analysis
|Getting started with Web Experience Factory
|| This document gives an introduction and overview to building applications with Web Experience Factory.
|Web Experience Factory wiki
||This wiki is a rich and up-to-date resource for all things related to working with Web Experience Factory. It includes samples, articles, best practice documents, FAQs, and links to other resources.
|Forums on developerWorks
||These forums are a great place to ask a question if you get stuck, or to search for solutions. They are closely monitored by the Web Experience Factory team, so you will usually get a prompt reply.
||There are a few Portlet Factory training classes offered by IBM, such as the popular "WebSphere Portlet Factory Top Gun Application Development" class.
|Factory 8.0 Information Center
||The product help includes a complete reference for builders and other product features.
|Best practices for model development
||Provides best practices, tips, and suggestions from the Web Experience Factory development team for developers who are either currently using or are expecting to use Web Experience Factory.
|Portal Application Development Using WebSphere Portlet Factory
||This Redbook provides an in-depth look at all aspects of WebSphere Portlet Factory development, using a comprehensive example based on a fictitious company.
|Rapid Portlet Development with WebSphere Portlet Factory
||This book provides an introduction to using WebSphere Portlet Factory, with a step-by-step guide and numerous tips.
Buy it on Amazon
Read it on Safari Books Online