Two chapters of Enlighment

I have always been intrigued with business process automation. Having a software engineering background, I learn the power of business software that we can harnessed to reduce/eliminate business waste by automating and simplifying manual processes. With several emerging technologies spurred by the maturing internet adoption, managing and integrating business software have becoming more feasible and inexpensive to achieve. Adopting advance technology to support business operations now has become an affordable luxury nowadays; however, one has to adopt and use them carefully to avoid unnecessary technology overuse that could potentially hamper business activities.

Recently I start reading Paul Hamon’s masterpiece, titled “Business Process Change – A Manager’s Guide to Improving, Redesigning, and Automating Processes”. Just by completing the first two chapters, Paul has successfully persuaded me to step back from my point of views in business process automation that are much polluted with fancy emerging technologies. Paul reintroduced me with Porters’ model of competition and perspectives that one can use to redefine business strategy. One of Porters’ perspectives that really hit me hard is the importance of achieving competitive advantage by balancing the company’s strategic positioning and operational effectiveness. Just like a coin that always have two sides, so far I have only been looking one side of the coin – the operational effectiveness. Porters explains that without clearly understanding its strategic positioning, a company will overdue its operational effectiveness. When competing companies in the same industry overdue the operational effectiveness to maintain its competitive advantage, it will cause condition that Porters called “hypercompetition”. When this situation occurs, competing companies are struggling to make profit and favor to relieve the condition through merger/acquisition. It amazes me how I can use this to analyze the current domestic aviation industry, for example. Porters’ perspective seems fit very well with the situation (eg. airlines claimed to lose money & merger between Delta & Northwest Airlines) . Please note, however, that I am not implying those executives do not understand Porters’ model, but it is definitely very challenging for them to define a compelling strategic position that differs from the competitors in this saturated market.

Though I am still far from completing the book, I have decided to give thumbs up for this book for successfully influencing me with its first first two chapters. I am going to march ahead with the rest of chapters and will write more review about this book in my later posts.

Web2Spreadsheet

I like Google Spreadsheet the most out of the other Google Docs, primarily because of the web form feature. With Google Spreadsheet, you can create a web form that store data automatically in your spreadsheet in 6 simple steps (please see my slideshare).

Can you imagine how powerful it is? Even a flower lady can build an online survey for her little store. Yes, it's not a perfect web form. For example, there's no form validation and no page look-and-feel customization. But it's good enough for some simple scenarios.

Below you can find the instruction to create your own web form with step by step explanation. To try this sample web form, please click here. Please don't go crazy because data will be stored in my Google Spreadsheet account :-)

Google Docs is another example of Software as a Services (SaaS).

| View | Upload your own

Managing Information from Customer Facing Activities with CRM

Many small and medium businesses currently still have not leveraged Customer Relationship Management (CRM) system to manage information collected from every customer facing activities. The slow adoption of the system can be attributed to unawareness about the benefits of the implementing the system or the perception that it’s difficult and expensive to implement CRM system. However, this article should help readers understand better about how comapanies can leverage CRM features to help manage prospects and customers’ information better. Finally, the article discusses SaaS – the latest trend in software industry.

Customer Facing Activities
From a high-level perspective, customer facing activities can be divided into three basic categories: marketing, sales, and service and support. In marketing category, marketers typically post advertisements or conduct events to promote products/services. In sales category, sales representatives try to sale products/services by contacting prospective buyers. In service & support category, company ensures customers are satisfied by providing the promised services or product supports.

Business Challanges
In a small size company, it’s not uncommon that one or two employees play a role in each category. Typically when business is operating on a low number of customers, these employees can manage information through spreadsheet and share them via email. The challenges appear when number of customers grows tremendously because the process is not scalable, and these can be identified through the several symptoms, such as lost of sale opportunities, decreasing customers’ satisfaction rate, and eventually loosing loyal customers to competitors. Internally, the employees are suffering fatigues from the difficulties to mange and share the growing customer information.

Customer Relationship Management (CRM)
Every company that sells products/services typically has a set of processes used to manage customer facing activities. These processes should be planned, designed, and executed carefully to entice prospective consumers and to maintain customers’ satisfaction level. Most importantly, these processes must be supported by a system that allow each stakeholders to scale while executing the process. With CRM software, a company can structure and centralize prospect and customer data, automate processes, and take proactive and reactive actions towards certain business conditions.

Structured and Centralized Data
CRM typically comes with a set of standardized business objects (similar to database tables) that relates to the marketing, sales, and service & support business data. For example, Account, Contact and Opportunity object are used to manage sales related information. Campaign and Lead objects are commonly used to manage marketing related information. Product, Case, Solution are used to manage service & support information. These standardized objects structure data universally across the organization. The more employees start utilizing the system, the more data continuously stored into the system, creating a centralized repository for the the company. Structured and centralized data enabled company to mine the data and to create better reports to analyze the state of business and make better decisions. Compared with the spreadsheet documents & emails, this has definitely provided a significant improvement for the company.

Automated Processes
In addition to the standardized business objects, CRM usually comes with built-in automated processes. These built-in automated processes promote universal understanding about the process in the company. For example, when a lead meets its qualification, it can be converted into account, contact, and opportunity objects. Built-in automated processes also serve as the one of key primary differentiator between CRM and databases system.

Proactive and reactive actions towards business condition
CRM may come with feature for users to create and manage dashboards, reports and workflows. Reports are suitable to trigger reactive actions, while dashboards and worfklows can be used to initiate proactive actions. For example, a marketer can create an ROI report of multiple campaigns. After reviewing the report, she can decide to eliminate several under-performing campaigns. A support dashboard can inform the supervisor about his team performance by observing number of open cases. When the dashboard indicate high number of open cases, he can contact his team, investigate the causes and solve them preventing the situation to become a source of crisis. A workflow can send an email to the key executive when a new high value opportunity is created alerting him that there's important deal and he may to take further actions to secure this deal.

SaaS - Software as a Service
The ‘Software as a Service (SaaS)’ term does not really provide new meaning to software industry. But it’s a new term that represent the ‘Application Services Provider (ASP)’ and later commonly known as ‘OnDemand’ concept. This concept promotes an easy software consumption while avoiding common on-premise software installation and configurations pitfalls. SaaS application typically allows fast and easy software provisioning through the internet and web browser, as fast and easy as renting movie online. SaaS application vendor also use a subscription pricing model that allows company to consume the software in affordable subscription price. This model allows small and medium companies to enjoy the benefits of using "elite" enterprise software that previously was only affordable for larger companies.

Small and medium businesses should definitely consider moving away from the non scalable practices and should not shy away from adopting CRM. It will help companies to manage the full cycle of customer facing activities from marketing, sales, and service & support. It stores the activity data in structured, centralized allowing for easy reporting. Dashboards, reports, and worklows allows companies to be more responsive to prospects and customers. And with SaaS model, even a small company can enjoy the luxury of running its business activities as professional as enterprise companies.

| View | Upload your own

Contextual Design and User Interface Design/Testing

I recently completed two projects required by the Master degree that I am pursuing. These two projects thought me valuable lessons in how to design a good interface by conducting a contextual design and eliciting the usability problems in the user interface design.

Contextual Design
When building a system’s user interface, we want to ensure that we build it to accommodate the existing work processes. Performing a Contextual Design (CD) helped our team collect data and model the existing work processes. The data collection process is called the Contextual Inquire (CI). When performing CI, our team visited the actual work place and observed the daily working processes. We later created a transcript of the activities that is used as the base information for the modeling for the CD. There are three models that our team generated:

• Sequence model – captures the motivation of a user to complete a task (goal/intent), a sequence of actions to accomplish the task, and the trigger that causes the sequence of actions to start.
• Flow model – captures the communication and coordination occurs between individuals or between system and individual in the work place.
• Cultural model – captures the cultural influences (policies, tone, and organization influence) that affect the individual while completing the task.

In the sequence and flow models, we can also identify problems that slow down/jeopardize the task completion) by noting them as breakdowns into the models.

After having these three models ready, we were able to learn and observe more about the work processes in the organization and the culture of the organization. With these in mind, we were ready to build a user interface prototype that suites or improve the existing work processes.

User Interface Design and Testing
The second project is to continue where we left off from the Contextual Design task. Based on the previous models and the system requirements, we built a web user interface prototype for the organization that we observed.

When building the user interface prototype, we built three artifacts (sitemap, flow diagram, and storyboard) that helped us categorize the information and visualize the layout of the user interface components.

Most importantly, after the prototype was completed, we conducted feedback session by performing usability heuristic evaluation and user test.

Heuristic evaluation is a method to find usability problems in user interface design. This evaluation process involves a set of evaluators to examine the interface and judge its compliance with recognized usability principle (Jakob Nielsen’s Ten Usability Heuristics).

User Testing, on the other hand, is a process where an evaluator (a person that conducts the test) interprets observer’s (a person who takes the test) actions and relates these actions into usability issues in the design of user interface.

After conducting these different feedback sessions, we received a set of difference feedbacks from the heuristic evaluation and user test. We noticed that feedbacks from the heuristic evaluation consist of finer grain information about mistakes we made from the prototype (incorrect color, hard to understand labels, inconsistencies, etc). The user test feedbacks gave us coarse grain information that relates more with the ease of use of the prototype.

Summary
From the first project, I learned a great deal of capturing user’s work processes and translate them into guidelines in building a user-centered user interface design. A design that is built on-top of the contextual design activity will fit better for the user by increasing the usability of the system. From the second project, I learned that the results of heuristic evaluation and user test compliment each others. These methods will definitely be great tools that I can use on my future professional endeavor.

Flaw in IE's getElementsByName() Method Implementation

I recently discovered a JavaScript implementation flaw in Microsoft IE while trying to build dynamic form. I realize that Microsoft IE v 6.0.29 does not implement the getElementsByName(param) properly according to the W3C standard.

As a web delovoper, my intuition expects the getElementsByName(param) to return a list of elements that fulfill the following criteria: 1) it needs to have the "name" attribute as its element; 2) the name attribute must have a value that is equal with value of the param passed by the method caller.

To illustrate the issue better, let's use the following example:

01 <html>
02 <script>
03 function validateFormFields(aForm) {
04  var elems = document.getElementsByName("field1");
05   alert("There are " + elems.length + " elements");
06   return false;
07 }
08 </script>
09 <body>
10 <form name="myForm" action="addData.do" method="post"
11    onsubmit="return validateFormFields(this)">
12    <div id="field1">
13       <input name="field1" type="text" value="cool"/>
14    </div>
15    <input type="submit" value="Submit"/>
16 </form>
17
18 </body>
19 </html>
20

From the codes sample above, I expect the browser to render the page by displaying an input field and a submit button. When submit button is clicked, it will invoke the validateFormFields() function, and this function is responsible to alert the number of elements that is returned by the document.getElementByName(“field1”).

The codes sample only has 1 element that has a “name” attribute where its value is equal to “field1” (line 12). Therefore, I expected the method to alert me only 1 element is found when the submit button is clicked. When tested with Firefox v 1.5.04, the browser met my expectation. However when running the same codes with IE v6.0.29, the alert informed me that there are 2 elements are found.

"Retrieves a collection of objects based on the value of the NAME attribute"

Ok, it is something that I want. But then when I read further, I also found the following sentences:

"When you use the getElementsByName method, all elements in the document that have the specified NAME or ID attribute value are returned."

There the main issue is documented. Not only that IE returned elements that have a "name" attribute that matches the value of the param, but it aslo retuned elements that have an "id" attribute that matches the value of the param. That's why the browser returned 2 elements where the first element comes from line 12 and the second element is from line 13.

I found the following explanation of the method from the W3C website:

"With [HTML 4.01] documents, this method returns the (possibly empty) collection of elements whose name value is given by elementName. In [XHTML 1.0] documents, this methods only return the (possibly empty) collection of form controls with matching name. This method is case sensitive"

It does not mention anything about returning an element that has an "id" attribute with matching value. Therefore, I think the proper implementation has been executed by Firefox browser, where as IE method implementation does not follow the W3C DOM specification, and as a web developer, I found it to be confusing and annoying.

Doodling around with Spring Framework and Hibernate ORM

I am implementing a small project with Spring Framework and Hibernate ORM. During the environment set up, I encountered several major problems which took several days to investigate and resolve. Here is the list of servers and frameworks that I am using:

• Apache Tomcat {5.5.17}
• SpringFramework {1.2.8}
• Hibernate ORM {3.0}
• MySQL {5.0}

First Issue
When integrating the Spring Framework and the Hibernate ORM, my Tomcat server complained during start up that it could no find the Hibernate hbm.xml files. I attempted to use Spring's HibernateTemplate for the integration. When registering the LocalSessionFactoryBean into the Spring XML configuration files, I listed the Hibernate hbm.xml files as the "mappingResources" parameter, along with other parameters. Here is the error message that is spit out by the Tomcat server:

Caused by:
org.springframework.beans.factory.BeanCreationException:
Error creating bean with name 'sessionFactory' defined in ServletContext resource [/WEB-INF/jnfintl-data.xml]:
Invocation of init method failed; nested exception is java.lang.NoClassDefFoundError
Caused by:
java.lang.NoClassDefFoundError
at org.hibernate.tuple.EntityMetamodel.class$(EntityMetamodel.java:41)
at org.hibernate.tuple.EntityMetamodel.(EntityMetamodel.java:122)
....

As some suggested, this error may occurr because the container cannot find the hbm.xml files in its classpath, and therefore they suggest to add "classpath:/package.java.class" into the Spring XML configuration file. I tried this approach, but it did not solve my problem. After further investigation, I realized that there I miss one jar file on my web application that caused this issue, the cglib-2.1.3.jar. After putting back the jar file into the application lib folder, I did not see the error message anymore when I started up my Tomcat server, and the web application works just fine now.


Second Issue
When using Spring WebMVC to map a URL request that contains a directory structure, the framework failed to map the relevant physical directory, causing the browser to displays HTTP 404 error msg reporting that the requested resource is not available. I attempted to use a combination of UrlFileNameViewController and SimpleUrlHandlerMapping in my Spring XML configuration file to map a URL request with its corresponding JSP file. However, the UrlFilenameViewController failed to find and display the JSP files that are organized within a directory structure. For example:

...
<bean id="urlFilenameViewController" class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>

<bean id="simpleUrlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
 <prop key="/test/testDbConnectionPool.html">
   urlFilenameViewController
 </prop>
</props>
</property>
</bean>
...

When the browser requested http://localhost:8080/somewebapp/test/testDbConnectionPool.html, the server complained that it could not find the requested resources.

This turned out to be a bug (or an enhancement?) within the version of Spring Framework that I was using. After updating the Spring Framework jar files with the version 2.0 M5 development release, the isssue is solved.


Third Issue
I kept encountering the Lazy Initialization error when trying to access an associated/joined objects from another object that is returned by the hibernateTemplate's load method. I think this was due to my lack of understanding of Hibernate lazy initialization concept. It is a new concept that is introduced in Hibernate 3.0.

I found Mr. Baum's blog that discussed the problem and provided alternative solutions to my problem. Please visit Mr. Baum's discussion about the ORM Lazy Initialization With DAO to read more about it. It's very well written and easy to understand. I tried Mr. Baum suggestion, and it worked very well with my case. The only catch that I encountered was caused by a Spring Framework's hibernate template version difference. The sample codes provided by Mr. Baum is using the older version of the Spring Framework. If you are using the newer framework, make sure that you are using the hibernate3 template.

While investigating on my problems on the Internet, I also stumbled into a good article about Spring Controller, written by Mr. Mike Raible. You can find this article at Mr. Raible's Wiki: SpringControllers.

WSDL2Java & TCPMON Tutorial

Generating Java Proxies from the WSDL
Sometimes when working with web services integration, it's easier for Java developers to utilize Java proxies and use them to interact with the service provider because learning the Java API might be faster and easier than learning about the structure of SOAP Envelope through WSDL. Creating the proxies is very easy with WSDL2Java tool. Once you finish creating the proxies, you can start writing a simple client to interact with the service provider, and you can use the TCPMON tool to intercept the SOAP messages that are exchanged between the service provider and consumer.

To create the Java proxies, there's a WSDL2Java plugin for Eclipse endorsed by SalesForce.com (com.myspotter.wsdl2java_1.2.0.zip). Once you unzip the file into your eclipse/plugins directory, restart your Eclipse. To generate the stubs, all you have to do is to locate the WSDL file with Eclipse package explorer, right click, and choose "Generate". This will generate the Java proxies on your project root folder. You can move these proxies to your Java source folder.


Setting up TPCMON
To intercept the messages, you can use the TCPMON (tcpmon.jar). Double click on the JAR file, you will see the Swing console to appear on your screen. To set up this TCPMON will be a little bit tricky but not too difficult. You will see the following input fields:

• Local Port: Use any unused local port number (such as 8181).
• Server Name: Put the IP address of the services provider (the url/IP address of the service endpoint. For example, Salesforce's service endpoint is "na1-api.salesforce.com")
• Server Port: Usually just use "80" as default service endpoint unless they specify something else.

Writing Simple Web Services Client
Having the proxies generated from WSDL to Java and the TCPMON set up, you are ready to write simple web services client in Java. The following is a simple tutorial of how to write Java web services client code using the generated proxies to connect to SalesForce CRM OnDemand. You need to have an active account (free to register for developer account at SalesForce website).

You can also download the wsdl2java_tcpmon.zip that contains:

• com.myspotter.wsdl2java_1.2.0.zip (Eclipse plugin for WSDL2Java)
• tcpmon.jar (TCPMON to intercept SOAP Message)
• createPriceBook.jsp (Simple example to create PriceBook at SalesForce.com)
• jaxrpc_client.ppt (Slides I used to use for my past lecture).

Let's start writing the codes

// don't forget to import the generated proxies
// Get the instantiate the ServiceLocator object
SforceService service = new SforceServiceLocator();

To intercept the SOAP message using the TCPMON, we need to modify the service endpoint by using method available from SoapBindingStub.

// get SoapBindingStub
SoapBindingStub binding = (SoapBindingStub) service.getSoap();

With the binding object, now we can change the service endpoint to point to our TCPMON. Previously, the stub is trying to send the SOAP message directly to SalesForce with the following URL:

https://na1-api.salesforce.com/services/Soap/c/6.0

Replace the service endpoint above with our TCPMON by using the following URL (assuming you pick port 8181 for the TCPMON local port):

http://localhost:8181/services/Soap/c/6.0

Now, using the local service endpoint, you can set it to the binding object.

//To set the local endpoint to the binding object
binding._setProperty(SoapBindingStub.ENDPOINT_ADDRESS_PROPERTY,
"http://localhost:8181/services/Soap/c/6.0");

Now, before we start calling the web services API, we need to login first. To login:

// Login
LoginResult loginResult =
binding.login("username@company.com", "password");

We need to get the session ID from the loginResult object and set it into the SOAP Header.

// Instantiate a SessionHeader object
SessionHeader sh = new SessionHeader();

// set the session id into the SessionHeader object
sh.setSessionId(loginResult.getSessionId());

// set the SessionHeader object into the binding object
binding.setHeader(
new SforceServiceLocator().getServiceName().getNamespaceURI(),
"SessionHeader", sh);

Now, the rest will be easy. For example, to store a new record at SalesForce, we just need to use the SalesForce object (such as Pricebook2 or Product2).

// Instantiate Pricebook2 object and give a name.
Pricebook2 pb = new Pricebook2();
pb.setName("The Price Book - " + System.currentTimeMillis());

// call the Create API from the binding object
SaveResult[] saveResults = binding.create(new SObject[] { pb });

The steps above will let you create a new price book, and you can see how the SOAP Request and Response are being structured on the TCPMON tool.