I am in Las Vegas for the IBM Gold Consultant Briefing 2009 that is being held in conjunction with the IBM Information On Demand (IOD) 2009 conference. I am well into the Gold Briefing (4th day), and am suffering a wee bit from information overload as part of the IBM Information Led Transformation (ILT) initiative! Today IBM announced its impressive ILT initiative which I see as another evolutionary step in the Information On Demand journey that was kicked off 4 years back. IBM certainly has made huge investments in this space over this period – $12B with $8B in some major acquisitions and $4B in organic R&D. And the IM portfolio certainly looks quite comprehensive with a broad range of capabilities.

The Information Stack in IBM’s words has the following pieces -

• An Information Infrastructure comprised of software, servers, and storage that provides a foundation for your information.
• Trusted Information gives you a single view of data through offerings that enable you to transform silos of information into a trusted, strategic asset that is shared across your organization.
• Business Analytics and Performance Management enables you apply analytics to optimize your business through better decisions by providing planning, budgeting, forecasting, measuring, monitoring, reporting and analysis capabilities.

With IBM, you can never have enough brand names and enough churn in product names, to make staying on top of things a challenge! IBM has it all – the newer Optim, FileNet, InfoSphere, Cognos, SPSS, ILog solutions; the more traditional Db2, Informix, CMOD products; and the cloud and mashup buzzwords. I think technically very impressive but I sure do wish that it was easier to stay connected with all the brand/product names!

I am really excited about this new offering from our business unit – the official press release went out today and I could not resist blogging about it even though I am getting a bit salesy here! As Dennis said in the press release – we have been providing remote WebSphere administration and development services for various client installations that included WebSphere Application Server Network Deployment, WebSphere Portal, and IBM Web Content Management. These services ranged from complete outsourcing of all WebSphere administration and maintenance needs, to on-demand consulting and mentoring. So, in essence, we have now codified these services that we have been offering for years, into pre-packaged offerings that make it simpler for prospects and customers to understand the value proposition of Xtivia’s remote WebSphere services.

An excerpt from the news release -

Virtual-WebSphereAdmin provides a cost-effective solution for organizations seeking to optimize the availability and performance of their critical WebSphere-based business information systems. This is accomplished through a comprehensive remote WebSphere Administration service designed specifically to meet the WebSphere administration, maintenance, management and consulting needs of our clients. Xtivia’s Virtual-WebSphereAdmin service combines a sophisticated suite of monitoring and reporting tools with expert consulting services to deliver complete WebSphere performance management.

You can find more details about this service at http://www.xtivia.com/remote-services/virtual-websphereadmin or you can go directly to http://www.xtivia.com/request-information to get in touch with the Xtivia sales team about this service. I am confident that you will find it worth your time to do so!

We recently switched one of our client’s WebSphere Application Server and WebSphere Portal based infrastructure to a new physical environment. During our testing we found that we were getting stale connection exceptions in SystemOut.log and in the application logs. On digging a little deeper, our team tracked it down to the fact that the Cisco firewall was dropping our Oracle database connections after they had been inactive for a certain amount of time. When our team discussed the issue with the network team, they were essentially told that all was good with the network infrastructure. The application team tweaked some of the connection pool settings but that only helped alleviate the issue slightly and we started encountering performance issues. Eventually, we figured out a solution that works!

The solution that we ended up with was to work around this issue on the Oracle end. We modified the sqlnet.expire_time parameter in sqlnet.ora on the Oracle 10g server down from the default “30″ (30 minutes) to “1″ (1 minute).

The explanation on why this worked

The parameter SQLNET.EXPIRE_TIME is used to specify the time interval, in minutes, to send a probe to verify that client/server connections are active. If the probe finds a terminated connection, or a connection that is no longer in use, it returns an error, causing the server process to exit. This parameter is primarily intended for the database server so that it can free up server-side resources that are not in use.

A side-effect of the probe is that there is TCP-IP activity between the client and the server each time the probe is executed, and the firewall designates the link as an active one. By lowering the probe interval down to a minute, we managed to fool the firewall into leaving the database connections in the connection pool alone, and not terminate them even though the client may not execute a query using the connection for an extended period of time.

I am sure you can tweak the value of this parameter to determine the optimal value for your firewall and situation; dropping down the sqlnet.expire_time to a minute is probably too radical and redundant in reality. Even though the probe generated by this setting is small, it still does generate network traffic that may be meaningful in some situations.

Sometime back, I wrote on Bad Smells in Code that were defined as – “A code smell identifies classic mistakes made in developing code. These mistakes typically result in code that is difficult to understand, maintain, debug, and extend.” In my previous blog entry, I captured some code smells that are commonly found in code written by new (and some experienced) programmers. Sample smells include “duplicated code”, “long method”, “inappropriate intimacy”, “large classes”, “inconsistent names”, and others. I had promised to be back later with my “code smelling exercise” that I used during my presentation to make my points about code smells. Well here it is …

The exercise has 3 Java classes – “Order”, “lineitemlist”, and “lineItem”. They were written by me ~8 years back with the express intent of embedding as many smells as possible. Attendees in the presentation were given ten minutes to mark up all the poor coding practices (in other words – smells) that they could find. Feel free to try your skills to identify the smells!

##########################################################################
Order.java
##########################################################################

package com.nq.util;

import java.io.*;
import java.util.*;
import java.lang.*;
import java.sql.*;

public class Order {

	private lineitemlist lineItemList;

	public Order(lineitemlist lis) {
		lineItemList = lis;
	}

	public boolean equals(Object aThat) {
    		if ( this == aThat ) return true;
		if ( !(aThat instanceof Order) ) return false;
    		Order that = (Order)aThat;
		return this.lineItemList.equals(that.lineItemList);
	}

	// writes this order object to the specified print writer
	public void writeOrder(Order order, PrintWriter pw) {
		// get a vector of line items
		Vector lineItems = order.getLineItemList().getLineItems();

		// ------------------------------------------------------
		// calculate total
		// ------------------------------------------------------
		// create an iterator for the vector
		Iterator iter = lineItems.iterator();
		lineItem item;
		// set total to zero
		int total = 0;
        	while (iter.hasNext()) {
	        	item = (lineItem)iter.next();

	        	// calculate total for line item
	        	int unitPrice = item.getUnitPrice();
	        	int qty = item.getQuantity();
	        	int lineitemtotal = unitPrice * qty;

	        	total += lineitemtotal;
	        }
		// ------------------------------------------------------
		// END calculate total
		// ------------------------------------------------------

		// ------------------------------------------------------
		// write order
		// ------------------------------------------------------
		// create an iterator for the vector
		iter = lineItems.iterator();
        	while (iter.hasNext()) {
	        	item = (lineItem)iter.next();

	        	// calculate total for line item
	        	int unitPrice = item.getUnitPrice();
	        	int qty = item.getQuantity();
	        	int productID = item.getProductID();
	        	int imageID = item.getImageId();
	        	int lineitemtotal = unitPrice * qty;

	        	pw.println("Begin Line Item");
	        	pw.println("Product = " + productID);
	        	pw.println("Image = " + imageID);
	        	pw.println("Quantity = " + qty);
	        	pw.println("Total = " + lineitemtotal);
	        	pw.println("End Line Item");
	        }
		pw.println("Order total = " + total);
	}

	public int getTotal() {
		// get a vector of line items
		Vector lineItems = lineItemList.getLineItems();
		// create an iterator for the vector
		Iterator iter = lineItems.iterator();
		lineItem item;
		// set total to zero
		int total = 0;
        	while (iter.hasNext()) {
	        	item = (lineItem)iterator.next();

	        	// calculate total for line item
	        	int unitPrice = item.getUnitPrice();
	        	int qty = item.getQuantity();
	        	int lineitemtotal = unitPrice * qty;

	        	total += lineitemtotal;
	        }
	        return total;
	}

	/** This method saves the order to the database */
	public void saveOrder()  throws SQLException
	{
		//create connection
		Connection conn = null;

		java.sql.Date date = new java.sql.Date((new java.util.Date())
		.getTime());
		PreparedStatement orderStatement = null;
		PreparedStatement getStatement = null;
		String sql = null;
		sql = new StringBuffer().append("INSERT INTO T_ORDER " )
			.append("(AUTHORIZATION_CODE, " )
			.append("SHIPMETHOD_ID, USER_ID, ADDRESS_ID) " )
			.append("VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
			?)" ).toString();
		conn = setConnection();
		orderStatement = conn.prepareStatement(sql);
		//set all parameters
		...
		//execute statement
		orderStatement.executeUpdate();
	}
}

##########################################################################
lineitemlist.java
##########################################################################

package com.nq.util;

import java.io.*;
import java.util.*;
import java.lang.*;

class lineitemlist {
	private Vector LIList;

	public void setLineItems(Vector lineItems) {
		LIList = lineItems;
	}

	Vector getLineItems() {
		return LIList;
	}
}

##########################################################################
lineItem.java
##########################################################################

package com.nq.util;

import java.io.*;
import java.util.*;
import java.lang.*;

class lineItem {
	protected int productId;
	private int ImageID;
	private int qty;
	private int Unitprice;

	public lineItem(int prodID, int ImageID, int inQty) {
		productId = prodID;
		this.ImageID = ImageID;
		qty = inQty;
	}

	public void setLineItems(Vector lineItems) {
		LineItems = lineItems;
	}

	Vector getLineItems() {
		return LineItems;
	}

	int getProductID() {
		return productId;
	}

	int getImageID() {
		return imageID;
	}

	int getQuantity() {
		return qty;
	}

	int getUnitPrice() {
		return Unitprice;
	}

	public void setProductID(int id) {
		productId = id;
	}

	public void setImageID(int ID) {
		imageID = ID;
	}

	public void setQty(int qty) {
		this.qty = qty;
	}

	public void setUnitPrice(int i) {
		Unitprice = i;
	}
}

Hope you had a fun time with identifying the smells! There are quite a few in here. I will look into writing another entry on another day that explains the smells that permeate this code sample.

Any comments on how reasonable this would be as an interview question for mid-to-senior level developers?

Today one of the portal administrators in my team was trying to reconfigure the LDAP server being used by an existing WebSphere Portal v6 install. The specific reconfiguration that he was doing was extremely simple – he was replacing one LDAP server with another identically configured LDAP server – so the only change was the name of the LDAP server. We were able to perform this change without disabling/re-enabling security in WebSphere Portal.

You end up changing two files to change the LDAP server name -

• security.xml: This file reconfigures the LDAP server being used by WebSphere Application Server. You can find this file in ${WP_PROFILE_ROOT}\config\cells\<cell_name>. You change the LDAP server name (highlighted in red) in the following lines -

<userRegistries xmi:type=”security:LDAPUserRegistry” xmi:id=”LDAPUserRegistry_1″ serverId=”wasadmin_dn” serverPassword=”{xor}wasadmin_pwd” realm=”ldap_server_name:389″ limit=”0″ ignoreCase=”true” type=”CUSTOM” sslEnabled=”true” sslConfig=”test/DefaultSSLSettings” baseDN=”dc=com” bindDN=”wpsbind_dn” bindPassword=”{xor}wpsbind_pwd” searchTimeout=”120″ reuseConnection=”true”>
<searchFilter xmi:id=”LDAPSearchFilter_1″ userFilter=”(&(uid=%v)(objectclass=inetOrgPerson))” groupFilter=”(&(cn=%v)(objectclass=groupOfUniqueNames))” userIdMap=”*:uid” groupIdMap=”*:cn” groupMemberIdMap=”groupOfUniqueNames:uniqueMember” certificateMapMode=”EXACT_DN” certificateFilter=”"/>
<hosts xmi:id=”EndPoint_1173225214609″ host=”ldap_server_name” port=”389″/>
</userRegistries>

• wmm.xml: This file reconfigures the LDAP server being used by WebSphere Portal WMM component. You can find this file in ${WP_SERVER_ROOT}\wmm. You change the LDAP server name (highlighted in red) in the following XML snippet -

<ldapRepository name=”wmmLDAP”
UUID=”LDAP1″
adapterClassName=”com.ibm.ws.wmm.ldap.ibmdir.IBMDirectoryAdapterImpl”
supportDynamicAttributes=”false”
configurationFile=”wmmLDAPServerAttributes.xml”
wmmGenerateExtId=”false”
supportGetPersonByAccountName=”true”
profileRepositoryForGroups=”LDAP1″
supportTransactions=”false”
adminId=”admin_dn”
adminPassword=”admin_pwd”
ldapHost=”ldap_server_name“
ldapPort=”389″
ldapTimeOut=”6000″
ldapAuthentication=”SIMPLE”
ldapType=”0″
sslEnabled=”true”
sslTrustStore=”C:\WebSphere\AppServer\etc\DummyServerTrustFile.jks”
dirContextsMaxSize=”20″
dirContextsMinSize=”5″
dirContextTimeToLive=”-1″
cacheGroups=”false”
groupsCacheTimeOut=”600″
cacheAttributes=”true”
attributesCacheSize=”2000″
attributesCacheTimeOut=”600″
cacheNames=”true”
namesCacheSize=”2000″
namesCacheTimeOut=”600″>

Once you have changed the LDAP server name in these two files to match the new server name, restart WebSphere Portal and you should be set to go.

Open up SystemOut.log in ${WP_SERVER_ROOT}\log and look for the following line during server startup to verify that you are using the new LDAP server -

[6/18/08 12:10:34:690 CDT] 0000000a LdapRegistryI A SECJ0419I: The user registry is currently connected to the LDAP server ldap://wpsldap:389.

In our case, the LDAP server name is “wpsldap”.

My Tip: In our test environments, we usually follow the practice of using virtual host names for the LDAP and database server. Rather than configuring the actual host names of the LDAP and database server being used by a given WebSphere Portal server, we use hosts file entries on Windows that configure wpsldap and wpsdb to point to the IP addresses of the relevant LDAP and database servers. Whenever we need to reconfigure a test WP server to use a different LDAP/database server, all we need to do is change the IP address in the hosts file to point to the new server. Simple, huh! And not exactly rocket science!

Recently, I dusted off a presentation (i.e. re-skinned and reused) that I had done back in year 2000 about “Bad Smells in Code” that was derived from Martin Fowler’s book Refactoring: Improving the Design of Existing Code. While the Refactoring book itself was a little too prescription oriented for my liking, the chapter about code smells was very good in my opinion. I look upon code smells as fairly common classic mistakes made in developing code that you are best advised to avoid – they are usually indications that something is not right in paradise and needs a closer look, and possibly some refactoring (i.e. clean-up) is in order. This blog entry focuses on object-oriented code smells.

What is a code smell?

A code smell identifies classic mistakes made in developing code. These mistakes typically result in code that is difficult to understand, maintain, debug, and extend.

What are some common code smells in object-oriented code?

Duplicated code

• The worst stinker of all!

Long method

• Difficult to reuse and difficult to understand.
• The object programs that live best and longest are those with short methods.
• The best object programs are endless sequences of delegation. Their payoffs are explanation and sharing.

Long parameter list

• Hard to understand, methods become inconsistent and difficult to use and more likely to require change.

Uncommunicative name

• Does the name of the method succinctly describe what that method does?
• Could you read the method’s name to another developer and have them explain to you what it does? If not, rename it or rewrite it.

Inconsistent names

• Pick a set of standard terminology and stick to it throughout your methods.
• If you use “add”, then use “add” in all relevant situations – not “create”. Another example is “delete”/”remove”.

Inappropriate intimacy

• Classes delving into each other’s private parts.
• Excessive use of class A’s accessors from class B.
• Over intimate classes need to be broken up as lovers were in ancient days! 

Indecent exposure

• Beware of classes that unnecessarily expose their internals. You should have a compelling reason for every item you make public. If you don’t, hide it.

Large Classes

• Too much code
• Too many instance variables
• Use layering and decomposition to avoid this problem.

Classes with too little code 

• Often data classes that can become domain classes
• Or candidates for downsizing!

Divergent change

• A class is commonly changed in different ways for different reasons
• Example – database + functionality

A large number of function classes

• Indicate that the designers are thinking upside-down, i.e.. thinking of that which can be done to an object rather than that which can done by the object.

Feature envy

• A method that seems more interested in a class other than the one it actually is in.
• Many messages to the same object from the same method

Data clumps

• Data items often hang around in groups together.
• Extracting them into a class of their own will help reduce field lists and parameter lists.

Switch statements

• Leads to duplication which leads to shotgun surgery
• Consider polymorphism instead.

Speculative generality

• Planning for change that never occurs
• Increased complexity

Too many casts

• Over generalization

Comments

• Often used as a deodorant for stinkers
• Superfluous comments

There are other smells too but these are the most important ones in my opinion.

Summary

To summarize, code smells give you an indication that there is trouble in paradise. They are only a guideline and cannot be used as absolute directives. When you realize that you are writing code that reeks of one of these smells, then STOP and ask yourself if you proceeding down the right path. If not, REFACTOR.

If you have the time, take a look at How to Design a Good API & Why it Matters – this presentation by Joshua Bloch is relevant even if you are not into designing APIs and all you do is design/code!

It was good to write about OOD – a topic that is near and dear to my heart, but one that I look into much too rarely with all the things on my plate. And presenting on this topic to some new team members was good too – wanted to emphasize some of my key coding philosophy points to them, and code smells act as a good introduction. I will be back later with my “code smelling exercise” that I used during this presentation to make my points about code smells.

This is an issue that flummoxes Quickr newbies, and I had a couple of new team members run into it today. Figured that others run into this issue as well. Essentially, the natural expectation for most people is that as a Quickr administrator, they would be able to add portlets/components to any place irrespective of whether they created it themselves or whether somebody else created it. While you don’t have to be the owner of a team place, you do need to be member of the team “managers” role. If you are not in the manager role and you are not the team place owner, then you cannot add a portlet!

IBM does have a technote about this – Error displays when the Administrator tries to add a portlet to a new page. Essentially, when you run into this issue as a Quickr administrator, you can resolve it by simply following these steps -

• Access the Quickr place you want to modify
• Click on “Customize Place”
• Click on “Users” in the div that appears
• Click on the “Managers” tab
• Add the Quickr administrators user group to the “Managers” role
• Add the portlet/page that you were attempting to add earlier. IT SHOULD WORK NOW!

Yes, I am back with a blog entry after quite a gap here! I have been knocked out sick for 5 weeks now and I am sick of being sick! Better now and hoping to be back at a 100% soon. Enough excuses – onto the subject of this blog entry. We use Log4j’s DailyRollingFileAppender in a WebSphere Portal environment to generate daily log files for various custom portlets that we have deployed. This worked just fine on some WPE v6 test servers with multiple portlets logging to the same log file, and the daily rollover occurring every midnight. However, on some other WPE v6 test servers running the exact same applications, while logging did work the daily rollover did not. Instead of us having multiple log files with date timestamps in their names, we would only have today’s log file – the previous log files would simply disappear! This issue results from the fact that the DailyRollingFileAppender (DRFA) tries to rename the log file during rollover. However, when the rename fails, it ends up overwriting the log file, hence losing information. On checking the application server’s SystemErr.log, we found an error each midnight similar to -

log4j:ERROR Failed to rename [logfilename] to logfilename.2008.01.11].

This appears to be a fairly common issue with log4j 1.2.x in Java application servers running on Windows. While there is no good resolution for this issue there is a workaround that works pretty well.

We ended up getting the DatedFileAppender which is a log4j extension that is publicly available at http://minaret.biz/tips/datedFileAppender.html. DatedFileAppender avoids the need for renaming the log file by simply creating the log file initially with the date in the file name – this is a simple workaround for the problem that we were experiencing. Switching from the DailyRollingFileAppender to DatedFileAppender was fairly seamless.  In addition to installing the jar in WebSphere Portal, we had to switch a few lines of our log4j configuration. We changed the following lines -

log4j.appender.logFileAppender=org.apache.log4j.DailyRollingFileAppender
log4j.appender.logFileAppender.DatePattern=’.'yyyy-MM-dd
log4j.appender.logFileAppender.File=MyApps.log

to

log4j.appender.logFileAppender=biz.minaret.log4j.DatedFileAppender
log4j.appender.logFileAppender.Directory=.
log4j.appender.logFileAppender.Prefix=MyApps_
log4j.appender.logFileAppender.Suffix=.log
log4j.appender.sametimeSyncAppender.Period=month # this line is only needed if the period is not a day

I am looking for competent WebSphere Portal developers and a Portal administrator to join the Xtivia team in Austin. It certainly is not easy to find people that can pass our technical screens. So do apply if you think you have strong skills with WebSphere Portal and you are looking for a challenging position in a growing Portal practice where you can make a difference. Team members take on responsibility for architecture, design, and development of portal and business applications built using various commercial/open-source Java technologies. The work environment is informal and requires flexibility, self-motivation, quick ramp-up, and desire to excel. As you can tell from some of my blog entries, you will be continually challenged and will require you to use your strong troubleshooting and problem-solving skills.

To apply send an email to our recruiter with your resume! Or email if you want more information about the job openings.

Today was a fun day getting the base JSR 168 polls portlet created – I actually got involved doing pair programming with a team member who is new to the Portal world. We chose to create this portlet as a basic JSR168 portlet without Struts or Faces support – the rationale being that we may want to target this portlet at platforms other than WebSphere Portal as well that may not provide the required support for anything other than a basic JSR168 portlet. We did the development in Rational Application Developer (RAD) on my Vista laptop and today pushed me over the edge with Vista. I had RAD crash on me a few times, and now I am convinced that I need to make the time over my winter holidays to just go ahead and downgrade to XP – yes, I am ready to admit defeat on the Vista front and move on with life! Anyway I digress – back to the topic at hand. We got the portlet skeleton coded up and the war file built, and attempted to deploy the portlet on WebSphere Portal v6.0.1.1. And WebSphere Portal rejected the portlet war file with this message -

EJPAQ1316E: Could not process the selected file from the browse button as a WAR file. Make sure it is a WAR file and try again.

The underlying error was -

java.lang.ClassNotFoundException: DeploymentClassLoader.findClass: java.lang.UnsupportedClassVersionError: com/xtivia/poll/portlet/display/PollsDisplayPortlet (Unsupported major.minor version 49.0)
at com.ibm.wps.pe.mgr.deployment.util.DeploymentClassLoader.findClass(DeploymentClassLoader.java:73)
at com.ibm.wps.pe.mgr.deployment.util.DeploymentClassLoader.loadClass(DeploymentClassLoader.java:133)
at java.lang.ClassLoader.loadClass(ClassLoader.java(Compiled Code))
at com.ibm.wps.pe.mgr.deployment.std.DeploymentManagerStandardImpl.checkForResources(DeploymentManagerStandardImpl.java:1434)
at com.ibm.wps.pe.mgr.deployment.std.DeploymentManagerStandardImpl.getPortletApplicationInfo(DeploymentManagerStandardImpl.java:1315)
at com.ibm.wps.pe.mgr.deployment.AbstractPortletDeploymentManagerImpl.getApplicationInfo(AbstractPortletDeploymentManagerImpl.java:790)
at com.ibm.wps.pe.mgr.deployment.AbstractDeploymentManagerImpl.getApplicationInfo(AbstractDeploymentManagerImpl.java:1586)
at com.ibm.wps.pe.mgr.AbstractApplicationManagerImpl.getApplicationInfo(AbstractApplicationManagerImpl.java:356)
at com.ibm.wps.pe.mgr.AbstractApplicationManagerImpl.getApplicationInfo(AbstractApplicationManagerImpl.java:332)

This is the first time that I had seen this error message. However, it was relatively easy to see from the top Google hits that this error is usually related to incompatible versions between the compiler used to build a jar/war file and the one used by WebSphere Portal. And that certainly was the root cause for my error as well. WebSphere Portal v6.0.1.x uses JDK v1.4 while I was running RAD using JDK v1.5 and RAD had used v1.5 for the compile. Switching the RAD setting for JDK Compliance->Compiler compliance level to v1.4, compiling, building the new war file and redeploying the portlet resolved the issue!