Portals enable users, employees, customers, and suppliers to expand beyond their traditional boundaries by providing a single common interface to access globally dispersed content and applications. Most important, portals also allow users to communicate with other enterprise applications, content factories, and processes. Dynamic portal capabilities also provide personalization that enables users to create tailored views of information or receive customized content. In addition to personalization capabilities, portals allow users to publish, share, and subscribe to various documents in an enterprise, regardless of original format.

Portal technologies, such as WebSphere Portal, support important back-end operations that provide the flexibility, scalability, and security required for any robust Web-based environment. Advanced portals include capabilities such as single sign-on (SSO), authentication and authorization services, directory services, content management, collaboration, mobile device support, search and taxonomy services, accessibility support, and internationalization.

Effective portal implementations require careful planning and execution. At the core of successful portals are personalization policies that help ensure user privacy and data security. This article explores the potential of portal personalization capabilities, security, and privacy considerations when designing portals and portlets, and outlines portlet design best practices that support benchmarks for flexibility, scalability, extensibility, and performance.

Portlets: Building Blocks for Portals
From a technical standpoint, the portlet architecture is an extension of the Java servlet architecture. It is a small piece of an application that is plugged into a Web page or assembled in a portal to create a single enterprise application. Portlets are also assembled into portal pages, which form a portal implementation.

Portlets, in simple terms, can be viewed as reusable sets of Java code that render HTML code. Similar to other Java technologies, the role and benefits of portlets vary based on IT staff and user perspectives. Application server administrators manage portlets as J2EE applications. Similarly, Java developers categorize portlets as configurable servlets that have additional attributes and include the potential to communicate with external content providers.

Personalization Policy
Dynamic and flexible portal capabilities enable users to receive targeted information based on their personal interests and preferences, as well as business requirements. Users must first provide personal information to establish a user profile.

Policies and processes associated with the portal owner's use and protection of site visitor information is a key consideration. Personalization policy guidelines determine how portal user information is handled. This policy applies to the entire portal and affects the design and usage of all portal features.

Portal personalization is a data-intensive process. It requires the use of personal data in a context that provides maximum value to portal users and portal owners. Successful personalization requires a continuous cycle of data collection, user profiling, and tailored content delivery. Most importantly, content delivery must adhere to user requests for information, including the types of content requested and the content delivery mechanism.

Personalization technology inherently gathers user data through explicit and implicit methods, making it crucial for portal privacy policies to encompass all means of personal information collected via multiple portal channels. Trust between users and portal providers is integral to the success of a portal environment. Users must be reassured that their personal information is safeguarded and that their privacy is protected in order to establish the level of trust required for a successful portal environment.

Because security and privacy considerations provide a foundation for successful portals, J2EE architects and developers must establish the following parameters before designing new portals.

• Determine the level of personalization the portal will provide.
• Clarify the amount of information users will be required to share.
• Determine how the portal will profile users based on portal usage patterns and other implicit methods.

An established personalization policy will help answer these questions and provide a framework for building sophisticated personalization capabilities. Moreover, it will deliver an architectural base for the design of individual portlets. IBM, for example, is establishing a Personalization Value Space (PVS) methodology to evaluate how levels of personalization affect users and portal providers. PVS examines personalization across four parameters:

• Personalization policies (e.g., user control of personal data)
• Feature categories (e.g., click-stream analysis)
• User context (e.g., level of interest or interaction with the portal content)
• Business context (e.g., how portal content supports organizational objectives)

Portlet Application Design Principles
In addition to addressing the personalization policy issues, there are a number of portlet design best practices that will support overall portal benchmarks for flexibility, scalability, extensibility, and performance. There are six key portlet application design principles.

Principle 1: Design Your User Interface (UI), Model Your Portlet
Good portlet design does not equal good portlet UI design. An effective design supports portlet reuse and enables multipage rendering without modifications. Organizations must first evaluate page and site design to eliminate any roadblocks to reuse or rendering problems before building portlets. A sitewide UI policy that identifies and removes these roadblocks will serve as a cornerstone to sound portlet development.

Principle 2: Unleash the Power of Simplicity
The ideal portlet is narrow in its focus, reusable in its entirety, and crystal clear in its message. Developers should limit the information displayed to include only content required for task completion. If a portlet is part of a use-case model that requires the display of large amounts of Web-page information, developers should break the model into standalone "atomic" use cases. Each use case then translates into a single portlet. A group of related portlets can be connected via parameterized URLs, an approach that minimizes the initial amount of content users receive to maintain a high level of performance. Users have the option to access additional personalized information as needed.

Although displaying all of the Web pages as URLs is permissible, the size and amount of information should be manageable. Many Web developers believe the initial splash page should be as low as 30K, which is typically the equivalent of one or two graphics and text on a page.

Principle 3: Remember, in the End, It's Just HTML
Although portlets are written in Java, the browser renders them through HTML. It is paramount to employ HTML coding best practices because the simpler the HTML, the faster the page load time. While more forgiving than its successor- - Extensible Markup Language (XML), it is important to disallow mismatched HTML tags and discourage the use of browser-specific features during portlet development.

Principle 4: Familiarize Portlets Into One Family
Cascading style sheets (CSS) support a browser-independent method for establishing a uniform portlet look and feel. A portal can then use predefined CSS for text formatting directly or through application program interfaces (APIs). However, it is important to ensure that there are no absolute CSS positions and that formatting options, such as fonts and colors, are not hard-coded.

Principle 5: Model Your Data, Control Your View
The importance of separating development and object-oriented design cannot be understated. A Model/View/Controller (MVC) architecture is preferred when rendering content at the UI level through Java Server Pages (JSPs), Extensible Style Language (XSL), and related technologies. MVC enables developers to segment the application into the following three sections to simplify development and design issues.

• The controller level oversees the addition of new user data and determines which data should be displayed (imputing, as well as marshalling/demarshalling of data parameters).
• The model level stores the data.
• The model layer abstracts the complexity of data retrieval and information gathering.
• The view level displays the information.

The portlet API provides many features for an MVC-based design, including tag libraries for JSPs. Portlet APIs also support Java Community Process standard JSR 168 features, such as coordination of user action and action sequences.

Principle 6: Promote Diversity Through Integration
A portal typically integrates diverse sets of information into a single user-friendly view. Depending on the data source, integration can become a complex multiphase exercise. (One example is a portal that screen-scrapes CICS applications to provide read-only access to legacy applications.) It is important to note that model-level integration simplifies portlet design. However, if model-level integration is not feasible due to needs for real-time information or other business requirements, organizations should consider adopting a service-oriented architecture (SOA) integration strategy. The SOA model shields integration complexities from portlets. The tradeoff, however, is delayed UI response times.

Conclusion
Noted fashion designer Issey Miyake once said, "Design is not for philosophy - it's for life." A good portal design can be used for the life of the application and extends the life of the application. The principles discussed throughout this article can help organizations create effective designs that translate into scalable applications.

Resources