Red Hat Certificate of Expertise in Seam Exam (EX311)

On this page:

Exam overview

The Red Hat Certificate of Expertise in Seam Exam (EX311) tests whether exam candidates are ready for the real-world responsibilities of creating and maintaining Java™ applications that use the Seam 2 framework. Those who pass the exam earn the Red Hat Certificate of Expertise in ESB credential. This document provides guidance on the exam format and objectives.

The exam is 100% performance-based. Candidates demonstrate their knowledge and skills by doing tasks rather than regurgitating facts. Most IT certification exams ask a series of questions for which you will choose A, B, C, or D—or the ever unpopular Choose all that apply. You will not see questions like that on the Red Hat Certificate of Expertise in ESB exam. In fact, you will not see any questions at all. Instead, you will be provided with a real environment in which you will perform a list of real-world tasks. For example, we might ask you to promote a conversation to long running rather than asking a series of questions about the APIs and annotations that manage conversation lifecycle. Consequently, candidates are advised to view any online “brain dumps” and the like with skepticism. The single best source of information about what is on this exam is this document.

The Red Hat Certificate of Expertise in ESB exam is 4 timed hours. Some time is required in advance of the start time in order to check identification and gather information.

Exam preparation: documentation and training

Red Hat's performance-based approach to testing means that experience is the best preparation for the exam. Even experienced people sometimes have gaps in their knowledge, and training and self-study are effective supplements to experience. Training in particular can accelerate experience. Red Hat® offers the JB311 JBoss Seam Development course, which covers most of what is in the exam. To help you prepare, this document lists the task areas you can expect to see covered in the exam.

Access to documentation during the exam will be limited to the official JBoss Enterprise Application Platform documentation for the version being tested plus any sample files or additional documentation included with the product. We will not strip anything out that is normally included.

Please note that you will not have access to the seamframework.org website or the jboss.org wiki. While these are useful resources and may include content that is relevant to the exam, the format makes it inappropriate for access during an exam. We want to test you, not the people reading and updating the wiki.

You will not be permitted to bring any hard copy or electronic documentation into the exam. This prohibition includes personal notes/notepaper, course notes, books, or any other materials. Internet access is also strictly controlled. Keep these restrictions in mind as you study.

Exam preparation: environment

You will be working on a Red Hat Enterprise Linux® 5.4 system during the exam, so prior experience using Linux or UNIX will be helpful. The purpose of this exam is not to test operating system-specific skills, and extensive Linux experience is not required. You will have a full desktop environment in which to work and we will provide a list of basic commands for your reference in addition to the man pages and other documentation that come with Red Hat Enterprise Linux.

Fedora provides a freely available alternative for you to practice your Linux skills. A Live CD version is available that allows you to work on Fedora without needing to install it on your computer. While it is not an exact match for the environment in Red Hat Enterprise Linux, it is definitely close enough for the level of familiarity required.

Exam environment: development tools

In addition to the desktop environment, we will provide an installed and configured copy of JBoss Developer Studio (JBDS). You are not expected to know or use JBDS to complete the exam tasks. However, JBDS is an excellent tool for developing and maintaining Seam applications, and some JBDS experience and skills will certainly be helpful in the exam. If you do not have access to a supported copy of JBDS, you can download a free version. If you are not already registered with Red Hat, you will need to create a free account. If you don't want to sign up with Red Hat for the free download, a standard Eclipse distribution with the JBoss Tools plug-in will be adequate for practicing for the exam.

Exam environment: working directory

When you start the exam, the default JBDS workspace will contain 1 or more project directories that must be used for the exam. You do not have to use JBDS for your development, but you must use the default workspace directory and the provided project directories for all tasks. In other words, all code and resources must be developed in, and consistent with, the structure of the provided directories.

Exam environment: coding standards

This is a practical, hands-on exam and you will have to write code in order to complete the tasks. Different companies have different coding standards and, like any real-world environment, you will be expected to follow the local coding standards. Listed below is some information on the exam coding standards, which may help you in your preparations. This information is also provided during the exam.

For the purposes of the exam, it will be easiest if you imagine that you are a newly hired Seam 2 developer who has been called in to complete a project. Unfortunately the original developer has had to drop the project part way through and is no longer contactable. You need to pick up where he or she left the code and complete as much of it as you can in the time available. The code is reasonably well documented and there are many TODOs throughout the code to give you an indication of what needs to be done. Please note however that the Javadoc and TODOs are not sufficient. You need to read the task descriptions and understand what is required before acting on a TODO. If you feel that there is a conflict between the task text, the UML/PDM diagrams, and the Javadoc/TODO, always do what the task description says.

Some key points to keep in mind when you are working:

  • Code format is not important. Whether you use tabs or spaces and how you place your curly brackets will not impact the exam.
  • Unlike the real world, comments and exception messages are not important. The exam is machine-marked so comments and messages are completely ignored.
  • Some of the classes are unusually organized; fields and related methods are grouped together. This is very unusual and it is not a recommended practice. It is done to make it easier for you to work on a single item without having to search back and forth through the code for the fields and related methods. Feel free to sort the class members if you would rather use a more normal code structure. (Hint: In JBDS, the blue TODO marker blobs on the right of the editor window and the property list in the Outline view are both very helpful for quickly navigating these classes.)
  • Code quality and best practices are important. You should use best practices at all times and always work under the assumption that poor or inefficient practices will be marked down. For example, it is considered a Java best practice to never publicly expose field members, so you should always use standard JavaBeans getters and setters for your object properties.
  • The project has been designed together with other applications in other departments.
  • Unless explicitly instructed by a task description or a TODO in the code, you must not change the signature of any existing method. The only exception to this rule is that you can, and should, make the signature more specific (that is, use a subclass and/or specific generic) if that is appropriate. For example, you should replace Collection with List where that makes sense.
  • You may add fields, properties, or methods as required.
  • If a method needs to throw an exception because of some internal problem, always use a RuntimeException; do not create a business-specific exception. For example:
    • You could use IllegalStateException if the problem is an inconsistency in the state of the object model or persistence store.
    • Or you could use IllegalArgumentException if the problem is an invalid argument to a method.
    • And, of course, you can always use NullPointerException when that is appropriate.

A final warning: We can't mark your work if it doesn't compile or fails to run properly. In particular, a broken declaration could cause the Seam runtime or Seam components to fail, meaning that nothing can be marked. Always check that Seam is able to start when deploying the applications (check server logs). To avoid this worst scenario, we have provided a very simple unit test based on SeamTest. Run it regularly to avoid any fatal Seam issue.

Exam tasks

Red Hat Certificate of Expertise in ESB candidates should be able to perform the following tasks using Seam 2.

Create, configure, and extend a Seam 2 Project

  • Implications of choosing WAR vs EAR deployment
  • Development and runtime configuration including:
    • Seam package structures and configuration file locations
    • Configuring database connection details
    • Configuring classpaths and included jars
  • Application generation including:
    • Generation of an application scaffold
    • Generation of Entities from an existing DB
    • Generation of views and actions from Entities
  • Extending an existing, possibly generated application including:
    • Adding new entities
    • Adding new components and actions
    • Importing and using existing components and entities
  • Application deployment issues, tools, and options including:
    • Hot deployment via JBoss Tools
    • Hot deployment via build.xml integration
    • Source path-based stereotypes (hot deployed or not)
  • Debugging a seam application

Work with Seam Contexts

  • XML configuration of component lifecycles and contexts
  • Conversations:
    • Understand temporary versus long-running
    • Understand conversation promotion
  • Conversation demarcation/propagation:
    • Using @Begin, @End
    • Using pages.xml
    • From inside views
  • Relation between conversations, transactions, and persistence context (flushmode)
  • Understand concurrent access in Seam
  • Selecting an appropriate context for work being done
  • Context order for resolution of injected components/context variables
  • Update use case to handle wizard-typed view flow and code-backed bean conversational Manager
  • Choosing start/end/propagate lifecycle for a long-running conversation
  • Configure the persistence context to be supported by a long-running conversation; specifically know when to flush the persistence context
  • Improve readability with natural conversation Ids
  • Manage conversation-related errors

Work with Seam POJO/Java EE components

  • Differences between EJB3-based components and POJO-based components
  • Component definition:
    • @Name
    • XML Configuration
    • fined grained configuration files
  • Seam application framework:
    • Understand and create Seam Home and Query objects
  • Component lifecycle
  • Component/contexts interaction:
    • @In, @Out
    • Understand disinjection
    • Understand pass by value
    • Understand interception including adding seam interception for EJB3 components
    • Understand implication of use of proxies
    • Understand implication of recursive/inner call
    • XML Config
  • @Factory
  • @Unwrap
  • Setting component/context variable in particular context using Seam APIs
  • Understand Event interception, @Observer
  • Built-in components/features:
    • i18n
    • @Log
    • Authenticator component
    • Asynchronous call
  • Know in detail the differences between a persistence context annotated with @In and @PersistenceContext (in case of use in EE)
  • Relation between conversations, transactions and persistence context flushmode
  • XML Configuration related to conversation
  • Security-related features, including (list not exhaustive):
    • Authentication
    • Restriction
    • Security events
    • Bind authentication methods
    • Access and manage identity information through API
  • Debugging a Seam application
  • Detecting and handling performance issues
  • Select appropriate context for work being done
  • Update existing Home and Query, including adding a search criteria
  • Choose between @Out, @Factory, @Unwrap to place component(s)/context variable(s) in desired context
  • Choose between serial or pooling approach to handle component call concurrency (typically from Ajax requests)
  • Tuning performance avoiding interceptor @ByPassInterceptor
  • When to use @DataModel and @DataModelSelection

Work with Seam Web/JSF components

  • Understand and use pages.xml including all navigation featues
  • Postback lifecycle
  • Initial request with preparing action
  • Understand and use the RESTFul approach with Seam
  • Interaction with @DataModel and @DataModelSelection
  • Richfaces:
    • Ajax for JSF
    • Commonly used Richfaces components (those used in seam examples)
  • Configure navigation based on application state
  • Understand use of Seam JSF components
  • Exception handling
  • JBoss Expression Language
  • Appropriate use of Ajax:
    • Partial re-rendering, validation, ...
    • Traffic patterns and overheads, included Ajax concurrency issues
  • Choosing appropriate RichFaces and JSF components
  • Generating and interpreting success and error messages
  • Security event handling
  • Configured security using XML and programmatic methods
  • Securing pages
  • Conditional rendering based on authorization and/or authentication