What’s Happening With JBoss?

UPDATE (Aug 2012) – The officially supported JBoss EAP 6.0 is finally released.  People using the supported EAP version will have much less confusion and one of the goals of this article was to clear up confusion about what is happening with the open source and EAP versions and how they relate.

If you are going to be using the latest versions of JBoss training is really a requirement because there are LOTS of changes (for the better) and you might need to reinvent somewhat how you approach management of JBoss in various job roles.  Training will help get you there faster and spend less time trying to figure out the new platform.

 

One thing that I’ve found to be true for enterprise clients is people don’t always have time to keep up with what is going on in the cutting edge of technology because they are busy just trying to keep up with their own responsibilities.  Since we have a lot of clients that use JBoss I figure I would help bring everybody “up to speed” with what is happening with JBoss on the Java EE front.  There have been several developments recently and there will be more over the next several months.

The first thing to determine is what “edition” of JBoss you are talking about.  Ultimately this comes down to if you are paying RedHat/JBoss for a support subscription to access the “officially supported” version of JBoss.  This “officially supported” version of JBoss is the JBoss Enterprise Application Platform (JBoss EAP).  If you are not paying for a support subscription you are likely using the “free, open-source” version of JBoss Application Server (JBoss AS).

So what is the difference between the two?  Although these are both “JBoss” editions there are some important differences:

  • The JBoss EAP contains some version of JBoss AS.  You can find the relationship between the released versions here.
  • These editions are released at different times with JBoss EAP released sometime after the version of JBoss AS it contains.
  • The versions of these two JBoss “editions” do not often match.  They did match somewhat with JBoss 5.x but they do not match now.  More on this in a second.
  • The JBoss EAP is the only version that will often have bug fixes back-ported to older versions.  JBoss AS “may” have bug fix releases but it is often only applying bug fixes to the “next” version of JBoss AS.  If it is important to have bugs fixed in JBoss without moving to a new JBoss version or you compiling JBoss source code updates yourself the JBoss EAP is a great investment.
  • A JBoss EAP subscription includes access to the JBoss Operations Network which is a great product for managing and monitoring several JBoss servers.
  • The JBoss EAP includes and is verified against specific versions of other popular libraries like Hibernate and JBoss Seam.  Often fixes released to the JBoss EAP will include critical fixes for these included libraries also.  What versions of particular libraries are included is listed here.
  • The different versions of JBoss EAP and JBoss AS will be compliant and “certified” against different versions of Java Enterprise (Java EE).  This will be especially important for Java EE 6 as discussed next.

Current/Upcoming JBoss Versions

  • JBoss AS 5.1
  • JBoss EAP 5.1 – includes JBoss AS 5.1 internally
  • JBoss AS 6.0/6.1 – Not major internal changes although some changes in web service stack and JMS stack.  Good summary here. Will never be released as part of a supported JBoss EAP version.
  • JBoss AS 7.0 – Final/GA release available. Significant internal and administrative changes compared to JBoss AS 6.x.
  • JBoss AS 7.1 – Beta release available, not yet GA/Final. Significant internal and administrative changes compared to JBoss AS 6.x.
  • JBoss EAP 6.0 – not yet released (early 2012?). Will include JBoss AS 7.1 internally

JBoss AS Downloads

JBoss EAP Information

Java EE 6 Certification

The other thing that causes some issues right now is what it means to be “Java EE Certified” for Java EE 6.  Java EE 6 introduced the concept of “profiles” so that Java EE servers could be certified against a subset of the Java EE specifications but not against the “full profile” of all specifications.  This is important because some Java EE technologies like EJB 2.x Entity EJBs are on their way out anyway now that we have modern replacements like Java Persistence (JPA).  The only profile that Java EE 6 defined besides the “full profile” is the “Java EE 6 Web Profile”.

The following are some of the highlights of the Java EE 6 Web Profile (not a complete list but the major things):

  • Servlet 3.0
  • JSP 2.2
  • JSF 2.0
  • JPA 2.0
  • Contexts and Dependency Injection for the Java EE Platform 1.0 (CDI)
  • EJB 3.1 “Lite” (This includes basically only non-remote Session EJBs)

There are some significant technologies that are in the “full profile” but NOT required in the “Web Profile” (not a complete list but the major differences):

  • JMS
  • Web Services (JAX-WS, JAX-RS “RESTful”, and JAX-RPC)
  • All of EJB 3.1 (including 2.x Entity EJBs, Message Driven EJBs, EJB Timer)
  • JavaMail

So servers that are certified against the “Java EE 6 Web Profile” are only “required” to have a subset of Java EE 6 technologies.  Now most of the JBoss AS versions offer technologies above and beyond the Web Profile but JBoss AS 7.1 (which will be included in JBoss EAP 6.0) is the only version that will target certifying against the “Full” Java EE 6 profile.  There is a good discussion here about exactly what it means (for JBoss AS 6.x anyway) to have been tested against the Java EE 6 web profile but also offer additional technologies.  It is also interesting to note that in the downloads of JBoss AS there is a download for JBoss AS 7.0.x which is “Web Profile Only” and has been officially certified for Java EE 6 by Oracle and there is an “Everything” download which has additional technologies but is specifically advertised as not being officially certified.

JBoss Versions and Java EE Certification

  • JBoss AS 5.1 – Java EE 5 Certified
  • JBoss EAP 5.1 – Java EE 5 Certified
  • JBoss AS 6.0/6.1 – Not officially certified for Java EE 6 Web Profile but tested internally by JBoss against the web profile test suite
  • JBoss AS 7.0.x – Officially certified for Java EE 6 Web Profile. An “Everything” download available with more
  • JBoss AS 7.1.x – Will be certified against “Full Java EE 6 profile”. Good description of the strategy here.
  • JBoss EAP 6.0 – Will be certified against “Full Java EE 6 profile”. Good description of the strategy here.

JBoss Versions and Support/Bug Fixes

Finally, I think the other consideration that will be important to people when switching will be consideration of how they will deal with the inevitable problems/questions that come up and how confident they might be about the software being fixed with bugs.  For those that this issue is mission critical, I would again highly suggest looking into a subscription to the JBoss Enterprise Application Platform.  This is the only form of JBoss that will have a support service level agreement and where bugs will be backported to previous versions for several years according to the JBoss Enterprise Middleware support policy.

When using one of the JBoss AS releases the only “support” that is available is from the JBoss Community and any available JBoss AS Documentation.  For users of JBoss AS I think it is important to consider the level of support from the JBoss community since that support comes primarily from three sources:

  • Other JBoss users that may have similar issues/questions
  • JBoss AS developers working on the open source project
  • JBoss EAP staff working on support of JBoss EAP specifically

Of course this community support would also apply to clients of the JBoss EAP since it is based on a version of JBoss AS and would be useful above and beyond the normal “official” support available for JBoss EAP.

The other thing to consider is if there have been bug fix releases of the JBoss AS versions or not.

Thoughts on Level of Community Support/Bug Fix Releases for JBoss AS Versions

  • JBoss AS 5.1 – No bug fix releases.  Still lots of users using this version, JBoss AS developers not as active, JBoss EAP staff active as it is part of a supported JBoss EAP version.
  • JBoss AS 6.x – 6.1 is a bug fix release of 6.0 but is the only one.  Lots of users on this one based on downloads, JBoss AS developers and JBoss EAP staff not as active since this version is very different than JBoss AS 7.x and JBoss AS 6.x will never be part of a supported JBoss EAP release.
  • JBoss AS 7.x – This has already had two 7.0.x bug fix releases in only two months which is better than previous JBoss AS versions.  Lots of community activity from users and JBoss AS developers.  JBoss EAP staff also likely active getting ready to include JBoss AS 7.1 in JBoss EAP 6.0.

Conclusions

So where does this leave you as a JBoss user?  What version should you be using now or planning to move to?  Every situation is different based on different factors like:

  • Are you migrating existing applications or developing new applications?
  • Do you use technologies that are not required by the Java EE 6 Web Profile?
  • Do you have applications that depend only on the Java EE specifications or do they utilize internal JBoss infrastructure (like custom “JBoss SAR” or “Service Archives”)?
  • How much do you need to configure administratively outside of your deployed applications (EAR, WAR, etc) and how hard would it be to determine how to configure those in a new version?
  • How important is “Full Java EE 6” certification compared to “Java EE 6 Web Profile” certification for you?
  • How important is the support offered by JBoss EAP?
  • Is there some kind of deadline you are working under that might prevent you from waiting for JBoss AS 7.1 or JBoss EAP 6 and the certification of the full Java EE 6 profile that would bring?

Certainly without knowledge of your particular situation it would be unwise for me to offer any kind of direct suggestion here.  In general though I might be hesitant to use JBoss AS 6, at least for very long, as this is not getting the attention of as many from the JBoss AS developer or JBoss EAP support staff groups and JBoss has decided that they will not release it as part of any supported platform.  There is also some question about using anything like JBoss AS 6.0 or JBoss AS 7.0 which is not certified against the full profile but offers varying degrees of additional features between the two Java EE 6 profiles.

For those that might value stability and Java EE certification above all else, and who do not have to start using new Java EE 6 features on some tight deadline, I might hold out for JBoss AS 7.1 or JBoss EAP 6.0.  You could even start investigating that migration now with the release of JBoss AS 7.1.0.Beta1!

, ,

4 Comments

Orientation Change in Android

By default, when the device orientation changes, Android destroys the active activity and creates a new one. This lets you load a different layout for the new orientation. Unfortunately, this also means, you will need to reload any data from the server or database. Prior to Android 3.0 (Honeycomb), Android provided a way to pass data from the old activity to the new one through the onRetainNonConfigurationInstance()/getLastNonConfigurationInstance() methods. This approach has since been deprecated. The Fragment API provides a better option. The process is still fraught with danger, if your fragment does any advanced work like background tasks and progress dialog.

In this article, we will explore options to deal with orientation change. For majority of the application, the choices can be surprisingly simple.

Option 0 – Do Nothing

As I said, if you do nothing, the activity will be destroyed after an orientation change. A new one will be created. This option is only valid if the initialization process for the activity (from onCreate()) is trivial and very quick. If onCreate() is time consuming or you start asynchronous tasks from there, things can become very slow and buggy when orientation changes. In those situations, consider the following options.

Option 1 – Fix Orientation

Many activities work best in one orientation. Other orientations may be harmful to user experience. Sample scenarios are:

  • A movie player should use the landscape orientation. Portrait orientation is just too narrow.
  • An activity showing a list of customers work best in portrait mode. Landscape mode shows fewer customers.

In situations like these, you should fix the orientation of the activity. You do that by setting the screenOrientation attribute in the manifest file.

<activity
android:label="Customer List"
android:name="CustomerListActivity"
android:screenOrientation="portrait">

</activity>

Option 2 – Recycle the Activity

For majority of applications, simply resizing the views to fit into the new orientation is sufficient. The layout managers are pretty good at resizing views. All you need to do is find a way to not destroy the activity after an orientation change and simply have the views resized. This can be easily done by setting the configChanges attribute. For example:

<activity
android:label="Address Book"
android:name=".MainActivity"
android:configChanges="orientation|screenSize">

</activity>

Note: As of Android 3.0, you will need to add the screenSize flag. This wasn’t necessary prior to that.

This option is most preferred if you have a complicated initialization process for an activity or fragment within an activity. For example, they can run an asynchronous task and show a progress dialog when the orientation changes. Everything will continue to function normally and uninterrupted.

Option 3 – Retain Fragment

This option is appropriate when these conditions exist:

  1. The application must show an orientation specific layout. To do this, the old activity has to be destroyed. The new activity will load a different layout. And,
  2. The initialization process is time consuming or does asynchronous work and should not be redone for the new activity.

This is the most complex scenario. Very few applications will fall into this category. So, choose this option carefully and if you must.

Starting from Android 3.0, the correct approach to handle this problem is through fragment. Instead of managing the views and initializing them directly from the activity, do those things from a fragment. When orientation changes, the activity instance is destroyed, but, the fragment object can be recycled. This is a two step process:

  1. Flag the fragment object as retainable (recyclable). After that, when orientation changes, the fragment is detached from the old activity and attached to the new one. Note: The views managed by the fragment get destroyed and the fragment must reload the layout from onCreateView.
  2. Save all state data in the member variables of the fragment object. Since, the fragment object survives an orientation change, all state data survives with it. State data includes and data loaded from web service or database, AsyncTask and ListAdapter. This gives you a lot of flexibility. For example, an AsyncTask started by the fragment can continue after an orientation change.

Flag the fragment instance as retainable from onCreate() of the fragment class.

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true);
}

From the onCreate() view method, load a layout and recreate the view hierarchy as usual.

public View onCreateView(LayoutInflater inflater, ViewGroup container,
    Bundle savedInstanceState) {

    super.onCreateView(inflater, container, savedInstanceState);
    View v = inflater.inflate(R.layout.addressbook, container);
    return v;
}

The onActivityCreated() is the complex one. It needs to load data only if it hasn’t been already loaded. It needs to populate the views in all cases. That’s because, the views are recreated after orientation change.

In the example below, the fragment uses a background task to load data. We start the task only if hasn’t been started yet. If the task has already finished, we simply populate the views.

public class CustomerListFragment extends Fragment {
CustomerListTask mTask;
ArrayList<Customer> mCustomerList;

public View onCreateView(…){…}

public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);

    if (mTask != null) {
        if (mTask.getStatus() == Status.FINISHED) {
        //Data is already loaded. Show it
        showCustomerList(mCustomerList);
    }

    //Task still running
    return;
    }

    //Start work in background
    mTask = new CustomerListTask();
    mTask.execute();
}

class CustomerListTask extends AsyncTask<Void, Void, ArrayList<Customer>> {

    protected ArrayList<Customer> doInBackground(Void... params) {
        mCustomerList = fetchCustomerList();
        return mCustomerList;
    }

    protected void onPostExecute(ArrayList<Customer> list) {
        showCustomerList(list);
    }
}

}

4 Comments

New Spring 3.0 Migration Class

The Spring Framework is a very popular Java framework that simplifies Java application programming.  Since it has been so popular for many years there are a number of Java developers that are already familiar with it.  For these types of developers the “normal” Spring training class may not be as useful since it would cover things that are not new to them, a waste of time and money.

We have posted a new Spring 3.0 course outline designed with this group in mind.  Our WA1981 Spring 3.0 Migration and New Features course, which is 3 days long, only covers topics that are new in Spring 3.0.  This course would let developers already familiar with Spring focus only on the new features or how Spring integrates with newer Java technologies that they may not be familiar with.

Some of the things included in this class are:

  • Summary of new features in Spring 3.0.  This provides an easy reference of what may impact existing applications.
  • Defining Spring components and dependency injection with Java annotations.  Spring 3.0 requires a Java SE 5 environment or greater so every Spring 3.0 application can take advantage of the code simplification and reduction of configuration that comes from using annotations.  Spring 3.0 also expands the range of annotations, some of which had been first introduced in previous versions.  This course shows the best ways to take advantage of this new ability.
  • New ability to drive Spring configuration with Java code or the new Spring Expression Language.
  • Automating the testing of Spring applications with some of the testing support built into the Spring Framework.
  • Integrating Spring with JPA or Hibernate.  Although Hibernate has been historically popular with Spring applications, the JPA Java standard is the preferred way to persist data from modern Spring applications.  This course will explain both alternatives.
  • Using Spring with the JSF Java web framework.  JSF is rapidly becoming the most popular Java web framework and this course will show how Spring and JSF can work together.
  • Spring MVC is a web framework unique to Spring applications.  Spring 3.0 introduced major changes to Spring MVC and this course will highlight those changes.
  • Along with the updates to Spring MVC, Spring 3.0 includes the ability to define REST services.  This type of service has become a popular alternative to “regular” XML web services and this course will show how REST services can be implemented with Spring 3.0.
  • Spring Security 3.0 was a major release that requires the Spring 3.0 framework to run.  This course will highlight the features of Spring Security.
  • Spring Web Flow is another web framework that can be used with Spring applications.  Spring Web Flow has more built-in support for “typical” web application use cases and makes it easier to define web applications that might be implemented as a series of web pages collecting data.  This course will highlight the features of Spring Web Flow.

As you can see, even though this class is a “short” 3 days it highlights a number of Spring 3.0 features.  We feel this course will help experienced Spring developers quickly “catch up” to all of the features available with the Spring Framework 3.0.  Contact us today to discuss how this training class might help your development teams.

No Comments

New WebSphere 7.0 “Administration Fundamentals” Course Released

We have found that often there are groups of people at WebSphere clients that need some level of knowledge with WebSphere administration beyond the “Overview” type of class but not to the same level of knowledge needed by those managing WebSphere systems day-to-day.  This is particularly true with application developers, testing staff, and other support roles that are not full WebSphere System Administrators.

To help better support the knowledge level these types of people need we have released a new 3 day course, WA1976 WebSphere Application Server 7.0 Administration Fundamentals.  This course covers topics like application deployment, management of database and messaging resources, troubleshooting, security, and web services.  Also, although it does not cover the configuration of a WebSphere cluster in depth it does introduce the architecture and terminology that is involved in a WebSphere cluster.

Certainly this course is not appropriate for every audience.  In particular, those that are managing a production WebSphere clustered environment would be better suited to our “full” 5 day WebSphere administration classes, WA1700 for Windows and WA1840 for Linux.  But by offering several different courses on WebSphere 7.0 Administration we feel clients will be able to better select the course that is appropriate for their audience.

No Comments

JBoss 5.1 Web Services Class Released

Although JBoss 5.1 has been available for a while, I was surprised that we had not had requests for our JBoss 5.1 Web Service development class, WA1719 Programming Advanced JAX-WS Web Services on JBoss 5.1.  We have just released this class and looking back I think it was a good thing that it was not released right after the JBoss 5.1 server was available.

One thing that has happened with JBoss Web Services (JBossWS) is the fact that they will be slowly moving away from providing the three web service “stacks” that they had provided previously, which were “Native”, JBossWS-CXF based on Apache CXF, and JBossWS-Metro based on Glassfish Metro.  This effort to integrate with three different web service environments was obviously difficult to maintain and update so the announcement was made that JBoss would eventually begin moving to supporting just one JBoss Web Service stack, JBossWS-CXF based on Apache CXF.  Although not released yet, apparently the only supported version of web services in the supported JBoss Enterprise Application Platform 6.0 will be JBossWS-CXF.  Also, even though it is not the “default”, JBossWS-CXF is fully supported on the JBoss EAP 5.1.  The JBossWS-CXF stack is also the only one available on the latest version of the open-source version of JBoss, JBoss Application Server 7.0.

So this brings me to the main reason I’m glad we waited until now to release the JBoss 5.1 web service class, we have released the class showing how to develop JBoss web services with the web service “stack of the future” JBossWS-CXF.  Although “basic” web services only use standard JAX-WS web service code with all of the stacks there is some difference between the stacks, especially in configuration, when you get to advanced topics like WS-Security, WS-RM (Reliable Messaging), etc.  So by showing students how to use Apache-CXF to develop JBoss web services they will be learning how to write more “future proof” web services.  Clients using JBoss for web services will have to go through a migration process to CXF at some point so our new JBoss 5.1 web service course, WA1719, allows that to happen now.

Besides focusing on developing Apache CXF web services for JBoss, our new course also expands the focus on advanced web service topics.  The differentiation between web service platforms, and the area that is often server-specific, is how to implement some of the more advanced “WS-*” specifications.  These are things like WS-Security for web service security, WS-Addressing for asynchronous web service invocation, WS-RM for reliable web service messages, and MTOM, or Message Transmission Optimization, for sending more efficient web service messages that include binary data.  We have spent time researching the “best” way to implement these advanced web service features using JBoss and Apache CXF in a way that is as close to possible to “standard” code and enables these features purely with CXF configuration where possible so that what is JBoss/CXF-specific is isolated and would be easy to modify if moving to a different platform.  Many times this research and experimentation revealed gaps in the current JBoss/CXF documentation and our course, especially the extensive hands-on labs, fills in these gaps with information students will find immensely valuable.

All in all, I believe our new JBoss 5.1 web services course, WA1719, is second to none.  We have spent time assembling information that developers of JBoss web services will need to know when working with web services in a JBoss environment.  Even the official JBoss training courses from RedHat do not offer the depth of coverage on web services our new course does.  Since implementing advanced web service features is what would take the most time and research from developers this is where we have concentrated our efforts in expanding the course to provide a “fast track” to the most useful information.  Web services have quickly become an integral part of any Java Enterprise applications so if you want to stay ahead of this fast changing area of the JBoss platform contact us to learn more about taking our new JBoss 5.1 web service development course.

No Comments

JavaScript Equality Operators

We use equality operators like == and != all the time. They appear to be same as Java or C++ on the surface. But, in reality, things are a lot more complicated and confusing. I will try to explain a few things that may not be obvious.

The Equals Operator (==)

var result = (expr1 == expr2);

When expr1 and expr2 are numbers, a simple number comparison is done. If either of the numbers is a NaN then false is returned.

When expr1 and expr2 are string values, then a string equality is done. If both strings are of equal length and have the same sequence of characters then true is returned.

If one expression is a string and the other a number, then the string is converted to a number before comparison.

var s1 = "10";
var s2 = 10;

var result = (s1 == s2); //result is true

When an object is compared with a number or string, then the system converts the object into number or string prior to comparison.

var s1 = 10;
var s2 = new String("10");

var result = (s1 ==s2);  //result is true

This is same as:

var result = (s1 == Number(s2)); //result is true

When expr1 and expr2 are objects then true is returned if both expressions point to the same exact object. This is where things can get interesting. Consider this example:

var s1 = new String("abc123");
var s2 = new String("abc123");

var result = (s1 == s2); //result is false

Here, result will be false. Variables s1 and s2 are of type object and not string. Since they point to two separate object instances, the equality test fails.

Boolean expressions are converted to number before comparison. There, true converts to 1 and false converts to 0.

var result = (true == 1); //result is true

The null and undefined values are different things in JavaScript. But, they are treated as equals by the operator.

var s1 = null;
var s2; //undefined

var result = (s1 == s2);  //result is true

The Does-not-equals Operator ( != )

This is a reverse of the equals operator. Nothing new to discuss.

The Strict Equals Operator ( === )

This operator tests for type equality in addition to value. If expressions are of different types, then false is returned. It does not do any type conversion like the regular equals operator.

var s1 = "10";
var s2 = 10;

var result = (s1 === s2);  //result is false
result = (s1 == s2); //result is true

Hence, to see if a variable is truly undefined, use the strict test:

var s1 = null;

alert(s1 == undefined); //Wrong! Shows true
alert(s1 === undefined); //Correct. Shows false

The Strict Does-not-equal Operator ( !== )

This is a reverse of the strict equals operator.

No Comments

Understanding IBM Process Manager 7.5 Advanced Edition

IBM has merged WebSphere Lombardi Edition (WLE) and Lombardi TeamWorks with WebSphere Process Server. The new combined product is now called IBM Process Manager 7.5. Understanding the various pieces within it can be very confusing. I spent a whole week playing with the server and development products. Below is a summary of what I found. This by no means will answer all questions. But, it’s a start.

All my experiments have been with the Advanced editions. In places, I try to make note of other editions.

The Server Runtime

IBM Process Manager Advanced edition gives you two types of profiles that you can create.

image

  1. Process Server – This is basically the same runtime as the old WebSphere Process Server. It can run BPEL processes as well as BPMN processes. Support for BPMN is obviously new. This comes from the Lombardi side of the family. (Note: In Standard and Express editions, only BPMN support is available).
  2. Process Center – This profile has all the features of Process Server mentioned above. In addition, you get the Process Center piece. Process Center is a central repository for BPEL and BPMN business processes. Development tools can publish and retrieve model elements from this repository. Since the process server runtime is included, you can run BPMN and BPEL process applications. You can also promote process applications from the repository to a production or test server.

The key thing to note here is that a Process Center profile contains a Process Server. Generally speaking, for test and production environments, you will create a Process Server profile. Process Center profile should be used in development only.

The installer for Process Manager gives you an option to create a Process Server or Process Center profile. These are standalone profiles, meaning, the nodes do not belong to any pre-existing cell and the servers are not clustered. Generally speaking, you should use this option to quickly setup  a server runtime suitable for development and testing. In a production environment, it is recommended that you manually create a profile using the Profile Management Tool (PMT).

In passing, I should mention that Derby (Cloudscape) is no longer supported as a database. You must use DB2 or Oracle. IBM ships DB2 along with the Process Manager media.

Development Tools

To develop BPEL processes and SCA modules, you will need to use IBM Integration Designer (IID) 7.5. This is essentially an upgrade of WebSphere Integration Developer (WID).

To develop BPMN processes, you will need IBM Process Designer (IPD). This tool will eventually replace WebSphere Business Modeler (WBM). Just like in WBM, you can model a process using BPMN notation. You can assign KPI metrics and run simulations. A key difference is that, in IBM Process Manager 7.5, a BPMN process is not just a modeling artifact. You can actually execute it in a server runtime. Consequently, IBM Process Designer lets you test and debug BPMN processes. BPMN exists in a parallel universe from BPEL. The BPMN runtime supports its own idea of adapters, human workflow and business objects. The technology does not use SCA. Adapters do not use JCA.

While IID and IPD have very different intents, they can exchange artifacts through the Process Center repository. For example, BPEL and BPMN processes can invoke each other.

IID install media contains a cut down version of the IBM Process Manager Advanced server runtime. This runtime can create a Process Server profile only. There is no way to create a Process Center profile. This seems rather odd, since, Process Center is something that is used mainly in the development world. If you must use Process Center from IID, take these steps:

  1. Install IID without any test environment.
  2. Install IBM Process Manager and choose to create a Process Center profile at the time of installation. This is the quickest way to create a fully functional server runtime.
  3. From IID, create a server of type IBM Process Server v7.5. Point to the directory where IBM Process Manager was installed (C:\IBM\BPM\v7.5 by default).

image

Now, the same server can be used by IID and IPD. You can use it as a repository as well as the runtime to execute BPEL and BPMN processes.

References

For more information, please inquire about our courses:

  1. WA1973 IBM Process Manager Advanced 7.5 Programming Using Integration Designer
  2. WA1974 Modeling Business Process Using IBM Process Designer 7.5

5 Comments

Who Was First to Java EE 6?

I was doing some research on JBoss the other day and found an interesting press release from JBoss.  They claim they were the first to release “Java EE 6 via Platform-as-a-Service” with “OpenShift”.  While this is certainly true the announcement could cause some confusion about JBoss “support” and “certification” of Java EE 6.

Although I won’t get into the cloud aspects of this product I thought it was interesting to actually dive into the details of the Java EE 6 side.  I guess it really depends on how you define “first to release Java EE 6”.

For those of you that are JBoss clients you might be thinking “Great!  JBoss now has support for Java EE 6”, and you’d be wrong!  The only thing “JBoss” that is certified for Java EE 6 is the recently released OPEN SOURCE and UNSUPPORTED JBoss Application Server 7.   They do not have a version of the JBoss Enterprise Application Platform (JBoss EAP), which is the product you actually pay to receive support for, that is certified for Java EE 6.

It also depends on how you define “certified”.  As you can see on the Oracle Java EE certification page, JBoss Application Server 7 is only certified for the “Web Profile”.  This is a new concept in Java EE 6 that allows servers to be certified for a subset of the Java EE technologies (mostly the newest stuff) but not certified against all of the technologies.  In particular the “Web profile” doesn’t require JMS, web services, MDBs and a few other technologies.  JBoss Application Server 7 supposedly supports some of these even though they don’t “have to” but they are not certified for the “Full profile” which would verify the compatibility tests of all Java EE technologies.  You can find an interesting discussion some of us in the JBoss community had with those in JBoss about this approach here.

Now the good thing is that JBoss does plan to release support for the “Full profile” Java EE 6 with the release of the JBoss Enterprise Application Platform 6 (the version numbers between EAP and open source server are going to be out of sync).  This isn’t expected until early 2012 though.   Luckily those of us in the JBoss community were able to convince those driving JBoss development that there was value in the full Java EE 6 profile and not to release the JBoss EAP until that full profile support was provided.  We all felt it would be more confusing to have a version of the EAP providing only Web profile certification and then later to have full profile certification.  After all, having different versions between the open source JBoss Application Server 7 and the JBoss Enterprise Application Platform is going to be bad enough.

So if you look at the Oracle Java EE certification page, there is a popular production supported server that provides support for the full profile of Java EE 6.  That server is WebSphere Application Server 8.0.  That’s right, WebSphere BEAT JBoss (again)!  Certainly WebSphere was not the very first application server to support Java EE 6, that distinction goes to Glassfish 3.0 released as the Java EE 6 “reference implementation”.  But if you look at the “Big 3” Java application servers of WebSphere, WebLogic, and JBoss, WebSphere was first.

So about the only way you could claim that “JBoss was the first to release Java EE 6” is if:

  • You accept an unsupported, open source product (which most clients don’t want to use in production anymore)
  • You accept a “Web profile”-only version and don’t need ALL of Java EE 6
  • You use some other qualifier like “via Platform-as-a-Service”

So anyway, back to the press release.  Why would JBoss want to offer something like this if there are so many ways to pick it apart?  I think the date of the press release is telling.  The press release is from August.  WebSphere Application Server 8.0 was released in June.  I think JBoss knew they were running out of time to put their “We were first” argument out there.

Also, a closer reading of the press release does make it clear that OpenShift is targeting developers right now so the issue of production support is not meant to be provided with this current release.  The first sentence of the second paragraph of the release, “OpenShift is a free PaaS for developers who leverage open source” certainly puts this offering in the correct context.

Ah the spin of product press releases…

EDIT:  I’ve made some minor changes to be more clear that this post is not meant as a hack job on JBoss “OpenShift” but as a comment on the press release concerning OpenShift which could be read in confusing ways.  In particular phrases like “supports Java Enterprise Edition 6” can be read in confusing ways that would imply things that are not currently true about JBoss Application Server.  For those of our clients that might not follow developments in JBoss quite as closely as I do hopefully this information is useful.

, ,

4 Comments

Mobile Ramblings

iOS 5 update is around the corner. It borrows quite a few ideas from Android and closes the capability gap with that platform. Specifically, the notification center. Competition is good.

Google may be working on many cool new things. But if the updates are forever late to get rolled out to average users, then, what is the point? When I write this, Android 3.1 is out. But, bulk of the devices are running either 2.2 or 2.1.

Chart

Should the device manufacturers customize Android look and feel? My vote will be – No. That just delays further upgrade. HTC’s Sense layer has been applauded by the customers. Not so for Motorola’s MOTOBLUR. If anyone has any cool idea for improving the look and feel, please drive it into Android, folks.

No Comments

Running a Local SMTP Server

When developing applications that send out e-mails, it helps to run a local e-mail server. Java Email Server is a simple SMTP server perfect for unit testing.

Install

Download and extract the ZIP file somewhere, say C:\Program Files\JES.

Open the file bin/ntservice.bat using Notepad. Set the JES_HOME_DIR variable to the root of the install folder.

set JES_HOME_DIR=c:\Progra~1\JES

Set JDK_HOME_DIR to the root of Java. Note: You must point to a JDK directory and not a JRE.

set JDK_HOME_DIR=C:\Progra~1\IBM\SDP\runtimes\base_v7\java

If you are using IBM JDK, set the JDK_MODE to classic.

set JDK_MODE=classic

Save changes.

From the bin directory of JES, run this command to install the service:

ntservice.bat -install

image

Open Services control panel applet. Start JavaMailServer service to start the SMTP server.

Configure

Open mail.conf from the root folder. Set the local domain name:

domains=webagesolutions.com

Any e-mail sent to the local domain will be saved by this e-mail server (and will not be forwarded to the actual SMTP server of the domain). For example, if we set this to webagesolutions.com then e-mails sent to any address with @webagesolutions.com domain will be considered local to this server and it will be saved right there. This is great because, you don’t want to send test e-mails to actual users. That will only confuse the recipients.

Set the default user’s e-mail:

defaultuser=admin@webagesolutions.com

This comes very handy during development. You can send e-mails to any user with @webagesolutions.com domain. All e-mails will be deposited to the default user’s box. This way, you can configure only one POP3 account in your mail program for the default user and pull out all e-mails using that.

Save and close mail.conf.

Open users.conf. Here, add the default user. The format is user.<username@domain>=<plain text password>. So, to add a user called "admin" with password "pass", do:

user.admin@webagesolutions.com=pass

Save changes.

Restart the service.

Note: E-mails sent to non-local domain will be relayed by JES. Many ISPs block SMTP protocol to prevent spamming. For example, I can’t send e-mail to Gmail’s SMTP server without using my ISP’s SMTP server. Relaying might be hard to achieve. But, mails to local domain is guaranteed to work.

Configure Mail Reader

In your mail reader, configure POP3 as follows:

Hostname: localhost.
User ID: admin@webagesolutions.com. You must enter the full domain name.
Password: pass

For SMTP server, enter localhost as the hostname.

Now, you will be to send e-mail to any user of the local domain. You can pick up all of those e-mails from the single POP3 user account.

No Comments