Thursday, August 27, 2009

Global smartphone market shares

From the data findings by analyst company Canalys, while Nokia and Microsoft shares are decreasing, RIM and Apple are growing:

The above stats are based on the number of units shipped during Q2 of 2009. The iPhone 3G was not yet out when the data was gathered. Android-based smartphones where not available in the second quarter of 2008. By this time next year, Android will be much closer to Microsoft's share. Nokia just came out with its Maemo-based smartphone, the N900. Moving more towards Maemo rather than hanging on to Symbian might actually work out pretty well for Nokia in the end.

Satisfiability Problems Online Game

There's an article in the IEEE Spectrum regarding Crowdsourcing the Complexities of Electronic Design Automation, which talks about a game called FunSAT that could benefit chip makers in improving their designs. Humans can help at this stage because these kind of problems are difficult for computers to solve. The game simulates satisfiability problems (SATs), and presents the user with a set of buttons and bubbles, where the buttons can have a value of true, false, or unassigned, and the bubbles, which represent clauses, can be satisfied, unsatisfied, or undetermined. The goal is to turn all bubbles green. For a bubble to turn green, at least one of the literals in the corresponding clause must be true. If all of the literals are false, the bubble will turn red; otherwise, it will be gray.

Why are satisfiability problems important? Because they aid in the design verification stage of chip design. "For example, they are used to find out what input combinations result in exposing a potential bug in the design. If no such combination exists, then the designers don’t have to worry about that particular bug."

"Modern satisfiability solvers tend to prioritize and limit their searches to a few paths that look promising. By using this method, however, they don’t always find the best configuration. What humans lack in brute-force speed, they tend to make up for with pattern recognition and intuition—the ability to know a good move without being able to explain why it’s good. And, most important, they like to play games."

Friday, August 21, 2009

Invoke a Web Service from JSP

This tutorial is a small example on how to call a SOAP-based Web Service from a browser-based client (using HTML and JSP). As an application server, we will use GlassFish. When you download GlassFish, make sure you use the preview version for this tutorial.

The example takes a number as its input and computes the corresponding Fibonacci number. We will start with the Web Service:
package blog.webservice;

import javax.jws.WebMethod;
import javax.jws.WebService;

public class FibonacciNumber {

public int fibNum(int n) {
int first = 1, fib = 1;
for (int i = 3; i <= n; i++) {
int temp = first + fib;         
first = fib;         
fib = temp;         
return fib;     

After compilation of the above code, you take the resulting class file and copy it to the blog/WEB-INF/classes/blog/webservice directory. Next step is to package the WEB-INF directory into a WAR file for deployment by executing the following command:
% jar cvf fib.war WEB-INF

The WAR is then copied to GLASSFISH_HOME/domains/domain1/autodeploy, where GLASSFISH_HOME points to the GlassFish install directory. If the deployment succeeds, a second file named fib.war_deployed appears in a few seconds in the autodeploy directory.
The good part about GlassFish is that you do not need to manually (using wsgen) generate the JAX-B artifacts that the service requires, because the current Metro web services stack release ships with GlassFish, automatically generating these artifacts. The WSDL file is also automatically generated and will be used on the client side as described in one of the sections below.

To generate the client-side artifacts (client.FibonacciNumber, client.FibonacciNumberService, etc), we will use wsimport on the wsdl file generated aytomatically by GlassFish:

wsimport -keep -p client http://localhost:8080/fib/FibonacciNumberService?wsdl

Next step is writing the client-side code, namely the HTML page, two JSP pages, and one xml configuration file.

The HTML page is simple and straightforward:
<form method = 'POST' action = 'fib.jsp'>
Input number for Fibonacci: <input type = 'text' name = 'inputNumber'><br/><hr/>
<input type = 'submit' value = ' Get Fibonacci '/>

The actual JSP that will invoke the FibonacciNumber web service is below:
<%@ page errorPage = 'errors.jsp' %>
<%@ page import = "client.FibonacciNumber" %>
<%@ page import = "client.FibonacciNumberService" %>
<%! private int fibNo, temp; %>
String inputString = request.getParameter("inputNumber");
if (inputString != null) {
temp = Integer.parseInt(inputString.trim());

FibonacciNumberService service =  new FibonacciNumberService();
FibonacciNumber port = service.getFibonacciNumberPort();
fibNo = port.fibNum(temp);

<p>fib(<%= temp %>) = <%= fibNo %></p>
<a href = 'index.html'>Try another number</a>

Of course, clients should not see such messages displayed in the browser. Consider this error page more for the developer.

The web.xml deployment document is:
<?xml version = '1.0' encoding = 'UTF-8'?>
<web-app xmlns = ''
xmlns:xsi = ''
xsi:schemaLocation = ''
version = '2.5'>

Any input to the HTML that is not a number will be caught and an error message will be displayed through the errors.jsp page.

Once we have all the files, we package them into a WAR:
jar cvf fibClient.war *.html *.jsp WEB-INF

and deploy it the same way as we did with fib.war.

For testing, open the http://localhost:8080/fibClient/ URL in your favorite browser.