Not yet!!! But according to their webcast they want to make NetBeans the best Java IDE. This is a statement not to be taken lightly. Oracle are now investing in three IDEs which are all established in different ways. JDeveloper is Oracle's IDE of choice, I am currently using it in my current project as I am developing for Oracle WebCenter. Oracle is also a strategic developer and board member of the Eclipse foundation. I do not understand what exactly is a strategic developer but I know that JDeveloper is their strategic IDE. Now, introducing NetBeans, Oracle has inherited NetBeans as part of Sun acquisitions (and a ton of products and services). Until now, Oracle has never made any plug-ins for the NetBeans platform but now they promise to make it the best IDE for Java, how will they make that happen?

I am a NetBeans evangelist and as the rest of the community, it was good news to actually know where it stands in the "Oracle" vision. So Oracle will never drop JDeveloper therefore the real fight is between Eclipse and NetBeans (as it always has been). In the first step of making NetBeans the best IDE, Oracle shold immediately start porting all their Eclipse plug-ins to NetBeans. Eclipse has strength in its alliance which also includes IBM (fierce rival to Oracle). Something has to give and Eclipse will not never close shop because Oracle has left them which is not as worse as lack of investment in the NetBeans community. It would also be a foolish decision to give NetBeans to the Apache Foundation (no disrespect here but it seems that public funds do not grow on trees).

There is something funny about Oracle "choice" statement. Did anybody tried to develop for WebCenter using NetBeans or Eclipse? That's a nightmare!!! There is no choice given, they literally forced us to use JDeveloper (Do you require any Oracle support?) in our company which is the largest in its field in Europe (I am avoiding to mention the company name but you should get it from my twitter stream).

Eclipse and NetBeans are direct competitors with Eclipse being the de facto IDE for Java, dropping Eclipse support would close doors to millions of developers and dropping NetBeans will disaster for many paying customers (Sun's partners).  I am not sure what is going to happen in the NetBeans/ Eclipse and JDeveloper saga but something has to give.

Let me know what you think.

As you can see by reading my blog that I am not the type to compare and endorse products as I think the products owners surely must have a marketing department for that. Anyway, as a blogger, I like to be aware about how well my entries are doing. For awhile, I have been using Google Analytics (so as the top 100+ websites) as it is free and provides me with enough information on the state of my blog, corporate and client's sites. The problem with Google Analytics is that it gives me late news (same as BBC, CNN, TF1 and Sky News and every other news @ 10 channels). I have been working in Business Intelligence for past three years and let me tell you that old news is what caused the current economy downturn. You should not based future goals on outdated data (information), you need to have information at your fingertips on demand and this is where Woopra fits in.

Woopra is not free but they do provide a free version (basic) which is enough for most website. I believe if you need more than what they provide, I am sure that you could afford the fee. Anyway, what I really like with this software is its real-time ability and I think that it is something that the folks at Google can easily implement. So I decided to give it a try (last night) and see what was the "big" deal:

• This is what we call real-time data, the fact that I could see where my visitors (to my blog) where coming from, what they were currently looking at (which article) and then where they went next in real-time. This is not a breathrough but the fact that it was available for free made it even better.
• Visitors tagging; they are so many sites which is used to tag content on the internet (Digg, Delicious, DZone, Reddit and etc...) so that you can share and easily found what you were looking at before. Ok, Woopra tagging cannot be shared but you can tag a visitor so that you can "spy" on his activity: how many times did it visit the site, which articles is he more interested in, track the comments and more. This is an important feature in profiling your audiences.
• Real-time chat; this is a good feature and I think that is indispensable for those running an E-Commerce site. Users are not forced to install any software, no plugins, nothing in order to chat with the site's owner (Any security concern, contact Woopra). I tried it on my blog and to be frank, I haven't been successful initiating a chat with visitors on my blog (they all refused the request :( ) but I can see it being successful on E-commerce site. Another aspect of this feature is the ability for the site owner to start the chat. So you can see what the user doing and which page he's currently looking at and therefore offer your help. I call it the virtual shop assistant. Users can also start a conversation so it's two-way.

I know I did not go into details about Google Analytics but you can register for free and see for yourself. Google Analytics seems out of date, Twitter is real-time, Google and Bing are implementing real-time features; don't you think that you need to be able to track your website performance in realtime too.

Another thing, how come Woopra shows some countries as EU when UK, France, Italy, Greece, Germany, Ireland, Spain, Belgium and Poland are shown as their respective countries. What does the European Union means in that case? Also, it is a shame that Woopra is not a web based application (the current web version is so weak you might aswell use Google Analytics ;).

Anyway, if you have use it before or have a different view, feel free to leave your comments.

N265Q9AKMDFZ

I just wanted to say happy new year to the community, without you guys, we would still be living in the dark ages. Here are a few that I am looking forward to in the new year:

1. Oracle Sun merger:- The untold future of NetBeans, MySQL, Swing and every open source that Sun has been working on in the past. What would happen to Sun Open Source (SOS!!!) Movement.
2. Looking forward to JavaFX1.3 release, Authoring tool and improved Composer plugin.
3. Android uprise against iPhone (not because I can easily write Android based application) and hopefully with Visual XML builder to build Android UI. JavaFX running on Android, anybody????
   
4.  Looking forward to seeing real-world JavaFX application and possibly a showcase linked to the JavaFX.com site.
5. Java EE 6 support in Google App Engine
6. Google Wave open to the public and how well it does against Twitter and Facebook
7. Java Store open to Europe (well this is where I am based and want to sell applications not just provide free).
8. My new video blog ( well that's me trying to be more Armel 2.0 - the sequel) to better engage with the community.
9. looking forward to networking with fellow developers and techies.
10. looking forward to the new buzzwords (old technology, new name)

Well, 2009 is was good year for Java and tech scene. I hope that you all enjoyed the year as much as I did. Why not share what wish list with me (comment box). Subscribe to follow my blog as I will try to bring more interesting articles in the new year.

Happy 2010 New Year, wish you all; success, properity, fame (yup) and fortune. Don't forget, if you need a server-side, UI, Android or JavaFx developer, just mail me.

Once (?) in awhile, we developers browse the web for some quick and dirty solutions to some of our coding problems (sometimes not even problems, right?). This is another of those days, everything was going fine on this project I am currently working on. This is not a social networking sites but a site for sharing and comunicating (how I missed the days of the chatrooms) similar in many aspect to Digg and DZone but which also allows users to communicate in realtime and leave comments. So the back-end was sort of completed but so now time to focus on the user registration.

The sites needed to be open and avoid repeatitive tasks such registering users. The way forward was to implement some authentication to allow users to register with some sort of universally accessible ID (or sort of). Facebook Connect, OpenSocial and Google Accounts have their advantages but to me personally; the disadvantages outweight the pros. These are some of the disadvantages of those platform:

1. Facebook is a popular site hence is its platform, Facebook Connect, in mostly Europe and America but not everybody in Europe and America have a Facebook account.
2. OpenSocial, when it comes to single logon, has more advantages than Facebook. I supposed that if we do take into consideration all the OpenSocial sites, we might have apossible larger user based than supporting Facebook alone. Even that was too limited.
3. Google Accounts, one thing Google does not advertise its user base. I could be wrong but do anybody actually knows how many people uses the various Google services (excluding search). Google has the same disadvantages as Facebook.

Enter OpenID. OpenID has been around longer than most Internet-based decentralised authentication platform. The beauty of this platform is that it also supported by most (if not all) large site on the Internet. From AOL, BBC, CNN to YAHOO and ZIMBRA, as I said most sites (based on the alphabet) support OpenID, check the OpenID Directory. It was recently announced that OpenID has reached 1Billion enabled accounts (read here). Based on those figures, I decided that OpenID for now was the authentication choice for this application. I will not be discussing any security issues in this entry, there are plenty of resources available on the Internet for that.

OK, so I am a Java developer and I am developing the front-end using GWT and Java on the server-side. I searched on the Internet for solutions on how to implement the authentication as GWT RPC are different to normal servlet call. I spent more time reading about the OpenID specification and implementations examples on the Internet. I have to admit that some of tutorials that I found on the Internet were somehow confusing and not helpful at all. Therefore I decided to write my own Dummies Guide to GWT and OpenID.

Dummies Guide to GWT and OpenID

First of all, it is important to know how OpenID works (please check the OpenID site for more info).

In a nutshell, OpenID allows you to authenticate with website (supporting the standard) with just an URL and voila. Your URL has to be hosted by an OpenID provider in order for it to work. For example, my blog is hosted by Google on blogspot.com. Google supports OpenID authentication therefore if a reader wanted to leave a comment on my blog, he does not have to have a Google Account as he can log-in with his Yahoo or AOL or Facebook or Wordpress or any other OpenID provider sites, and then leave a comment, that simple.

GWT to OpenID and back

There are two ways to authenticate a user with an OpenID provider and GWT supports both. When authenticating a user, the relaying site (the site the user is trying to access) redirects to user to the OpenID provider (i.e. Google) login page.


The problem will be with the GWT RPC mechanism. GWT RPC calls are asynchronous and you cannot make any redirections. Therefore we need a way to execute the redirection from the client side, here is the code (I use OpenID for Java to handle the openID discovery from the RPC servlet), I then used USER object (just a simple POJO which only stores the redirection URL and the parameters) to be sent back and forth between the front-end and back-end.

#######################################################
public User authenticateOpenId(String provider_url) {
    try {
        ConsumerManager manager = new ConsumerManager();
        // This is the URL where the OpenID provider will redirect the user
        // once logged in.
        String returnToUrl = "http://localhost:8084/GwtOpenId";
       
        // the provider URL will be used to identify the user OpenID provider
        List discoveries = manager.discover(provider_url);
        DiscoveryInformation discovered = manager.associate(discoveries);
        // OpenID 4 Java needs to  have an HttpServletRequest object, GWT sevlet 
have
        // convenient methods to retrieve the HttpServletRequest object 
and manipulate its
        // parameters
        this.getThreadLocalRequest().setAttribute("openid-disc", discovered);
        this.getThreadLocalRequest().setAttribute("openid.mode", "popup");
       
        AuthRequest authReq = manager.authenticate(discovered, returnToUrl);
        FetchRequest fetch = FetchRequest.createFetchRequest();
        // I want to exchange the following attributes from the OpenID provider
        // remember that teh attribute will be returned only if it exits
        fetch.addAttribute("email","http://schema.openid.net/contact/email",true);
        authReq.addExtension(fetch);
        // Simple POJO to persist the data
        User user = new User();
        // In a normal servlet development, the following statement would make
        // a redirect call but this would not work when using GWT RPC
        if(!discovered.isVersion2()){
            user.setRedirect(authReq.getDestinationUrl(true));
            // fakes the redirect by sending the POJO with the required parameters
            // to make a client-side redirect
            return user;
            } else{
            user.setParams(authReq.getParameterMap());
            user.setRedirect(authReq.getDestinationUrl(false));
            // fakes the redirect by sending the POJO with the required parameters
            // to make a client-side redirect
            return user;
        }
        } catch (MessageException ex) {
        Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
        return null;
        } catch (DiscoveryException ex) {
        Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
        return null;
        } catch (ConsumerException ex) {
        Logger.getLogger(GWTServiceImpl.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    }
}
#############################################################

The above codes will format the request in order for the front-end to execute a redirect and allow the user to authenticate with his OpenID provider. Now here is the front-end code which executes the authentication and reads the data back.


#################################################################
// This is an extract from the openidEntryPoint.java

// This is where the magic happens - This code is only usefull when the OpenID 
provider
// redirects the user back to your site - please visit openid.net for valid 
parameters.
// The "if" statement checks to make sure that it is a valid response from 
the OpenID
// provider - You can do anything you want with the results here such 
as verifying the
// response with the server-side code
if(Window.Location.getParameter("openid.rpnonce") != null){
    String s = Window.Location.getParameter("openid.mode");
    // executes this if the user cancels the authentication process and the OpenID
    // providers returns to the your site
    if(s.equals("cancel")){
        sign.setText("Server returned openid.mode=cancel");
        openIdUrl.setText("You need to Accept not Cancel");
    }
    // Here, I am assuming that everything is fine and that the user has 
been sucessfully logged in
    else{
        sign.setText("You have successfully signed in");
        vp.setVisible(false);
    }
   
}
RootPanel.get().add(contentPanel);

}

private class UserAsyncCallback implements AsyncCallback<User> {
   
    public void onFailure(Throwable caught) {
        Window.alert(caught.getLocalizedMessage());
    }
   
    public void onSuccess(User result) {
        if (result != null) {
            //                    Window.open(result.getRedirect(), "_blank",
 "height=200,width=400,left=100," +
            //                            "top=100,resizable=no,scrollbars=no,
toolbar=no,status=yes");
            // this the most important line in order to make the authentication.
 Here, I am redirecting the user
            // from the client side to the OpenID provider URL with the discovery
 data generated from the
            // RPC call to the servlet.
            Window.Location.assign(result.getRedirect());
            } else {
            Window.alert("Ooops!!! Couldn't find your provider");
        }
    }
}
#######################################################################################################

I have attached the full NetBeans project with dependencies. The code is provided as-is and use at your own risk ;). Here is a screenshot of the working application:

Step1: Authenticate on the site (enter the URL)


Step2: Redirect to OpenID provider (Google is my provider :) ), authenticate with your provider


Step3: Allow the application to access your OpenID details and redirect back to the original site



Step4: final step, check the parameters from the provider and proceeds accordingly



Take a look at the URL in each of the above step to see the OpenID data. OK, so my code actually works (yuppie), now you know that it is possible form GWT to OpenID and it's not as complicated as many other sites are trying to show. The code is just for authentication but once authenticated, you can retrieve any parameters that you need. In this example, the query is sent through the browser URL (GET) but you can change it to be encoded in a form submit action. Iwrote some of the code to allow the user to authenticate via a popup window, the code is not complete and maybe someone else might want to have a go. My only problem is getting the redirect back to the original window but apart from that it works.

Download the source code

I hope you guys enjoyed it and Happy Coding.

Initially, I was not going to write up about browsers until I had to download all the known web browsers to test a project front-end. I already had Firefox, IE8 and Chrome installed therefore all I had to do was to download and install Opera and Safari. There might be other browsers outthere but this what I am working with for the moment. So what's the problem? You might ask. Well, I decided to see how simple it would be for a normal user without much computer experience to view a Java-enabled application embedded in a web app or simple HTML page.

Before I go on about what I think, first let me give you an idea of the PC I am currently using:

• Dell PC with a dual 22" screen (customised version of Inspiron 530)
  
• 4Gb of RAM
• Intel Pentium Dual 1.80GHz (looking to upgrade this after xmas)
• Windows Vista Ultimate (how rubbish is that?)
• Java RE version 1.6.0_17
• and a few other hardware and software.
  

So as you can see, my personal PC is quite simple in settings. Ok, for some reasons, I decided to launch all the browsers at once and load the JavaFx homepage (http://www.javafx.com) and all I wanted to do was to compare which one loaded the fastest. Here are my findings, in brief:

Firefox
This is probably the best browser outthere but lately it has been crashing on me. And btw, it does not cope well with Google Wave. Anyway, here is what Firefox gave (see screenshot):


As you can see on the above screenshot, the JavaFx homepage loads in its entirety. To be quite honest, the page was loaded without any fuss but bear in mind, I already had Java installed. The "Demos & Samples" box in blue requires Java to be installed as it a JavaFx applet. As I already have the JRE installed, the browser did not ask me for any plug-ins ( I could be wrong feel free to share your experience).

Internet Explorer 8


I am not a great fan of IE in general, but for this simple test; IE8 loaded the page faster than Firefox. Also, it did not ask me to install a specific plugin in order to load the JavaFx portion of the page. IE handles Google Wave much better than Firefox, so this is the browser I use to interact on the Wave.

Google Chrome


Google Chrome, like Firefox and IE, did not cause any problem and it was the fastest at loading the JavaFx page including the Java applet. So far, it is the best performing browser but it is not my personal choice so I rarely use it. Also, I like the fact that Chrome scales the page to fit nicely in its window.

Opera


As you can see in the above screenshot, it seems as if the applet was not fully loaded. Indeed, Opera has loaded some portions of the JavaFx applet but I do not know what is happening here now. This page has been the same since I loaded the browser until now. Again, Opera did not ask me for any plugins to be installed nor did it ask for anything else. I suppose this is not an issue from Sun ;) but something that the Opera team should look at. I know Opera can find the JRE on my system (see screenshot below) but it seems not to be a big fan of Java. In the screenshot below, you can see the JavaFx splash screen but this is all you will see and nothing else. Off-subject, I really like the user interface and I might start using it for a bit longer just to see if it can convert me.


Safari


Ha! what the hell happened here. I have my JRE installed, the previous four browsers did not ask me to install Java (again!!!). The demo applet did not even load, this is Safari running on Windows machine not Mac. So I did what it has asked me for the thousandth time. I clicked on the provided link, takes me to the Java RE download page and I did all the required and look!!!!


Java!!!!! This is the confirmation that I already have the software installed so what's the big idea? The Apple team are not doing a good job to support Java but I can browse to Youtube and watch video without installing Flash player (it recognises that it's already installed). Well I do not think I will be using this browser again anytime soon.

Final words
When it comes to browser to support, you have to test your application on multiple browser ( and OS platform too) to make sure it will not affect the expected user experience that we are so accustomed to.

I do not know why Opera and Safari have issues with the JavaFx site, it could be anything from the site designers to the respective browsers' team. I believe that Java is probably the best Cloud computing platform currently outthere (when it comes to high performance applications) and that browser providers should make sure that at least they do support the platform.

I have a question:

Who should be to blame if Java or any other plugins such Flash is not supported in the browser? The plug-ins developer or the browser developer?

I believe the plug-ins developer should be to blame as they can be a million plug-ins on the net and you cannot possibly cater for all of them. But on the other hand, as in Java 's case, the plug-in is supported without any major issues by the top 3 which accounts for 93.9% percent of the market (based on November 2009), should you as the plugin developer care? I say yes at least for the Mac users' sake. We can overlook opera for now but I am sure that all the Apple fans still use Safari as their prefered browser. Do not try to leave them out, they brought us the iPhone.

Anyway, based on my simple test, I think the best browser for Java applet is (in order of best performance):

1. Google Chrome
2. Internet Explorer (make sure you do support this browser as a priority)
   
3. Mozilla Firefox (this should also be supported right after IE)
   

The other two browsers are not included as they did not even successfully launch the applet. I am not saying that you guys are going to have the exact same issue as me and therefore looking forward to your comments.

Just over a week ago, Sun announced a RAD tool for JavaFx built on the Matisse framework, I believe. I was very critical of JavaFx for its lack of tool for building UI and I think this is a step in the right direction. The tool was made available through the NetBeans Update Center on the 14/12/2009. OK, so I have installed the plugin and here are my views; not just on the tools but also on other stuff I think would benefit the JavaFx community:

When comparing something, it only makes sense when we use a benchmark; here my benchmark will be Adobe Flash Builder (formerly known as Flex Builder). Over the years, Adobe had made it easy for the designer to build impressive user interface with minimal coding. Sun, in the other hand, made it easier for developers to build application, yes I am aware of some nice UI in Java but they still do not compare to the eye candy of Flash/ Flex.

I am going to look at the tools; Flash Builder and JavaFx Composer plugin, from a developer perspective.

Components:
A key feature of RAD tools is the amount of components they make available to developers without having to write too many codes. I understand the plugin is at a "preview" stage, whatever that mean (alpha?), but there are alot of missing components; as an example, this release version was meant to be a "preview" of what to look forward to but I cannot drag a "combox" from the components palette into my form, no data grid, no chart, no menu bar, no date components and can't even draw a rectangle which is possible but only through coding. I hope the JavaFx team add all the components available in JavaFx plugin to the Composer.

NetBeans JavaFx UI Composer

Adobe Flex/ Flash Builder

Round-trip code update
One thing I dislike with Java IDE's (or most of them) is the inability to change the generated code without requiring you to write more code. The Adobe team actually made a good job in giving more freedom to the developer. In Flash Builder, you can design your UI through drag-n-drop but also customise it directly through the XML file (MXML). This feature was not available in NetBeans Matisse, I could be wrong, but and again Matisse was not really used in large project (no comments, thanks), at least not were I worked. Why all the fuss, you might ask? Try to create a simple interface and add a "rectangle" object to it which you will use as a toolbar and tell me how simple that was.

The coding style in JavaFx is very similar to Flex/ Flash ActionScript (so why the "V"oid instead of void, but that's another issue) and very easy to learn. So far, I found it easier to actually code the canvas then using the Composer plugin. Another thing, when inspecting object properties; not all properties are available, for example: the gradient properties are not available, which will require you to write more lines of code.

UI Preview Panel
Again, a feature which Adobe Flex/ Flash builder excels at (I feel like I am starting to sound like an Adobe salesman) is the synchronize preview of codes. This is not a due to JavaFx Composer plugin but this seems as a bug as sometimes, you might have to restart the IDE in order for the UI Preview panel to start working again. Hopefully the introduction of the RAD (or not so much RAD) tool, will fix this issue.

Conclusion
You might feel that I was on a JavaFx bashing quest but this is not the case. JavaFx might not have a large components set (well what about all the SWING components available which you can use? You might not be able to "skin" them to your application look and feel but they still availabe to you) but I still think it has a good future. If you take a look at the screenshot below which was built with Adobe Flex, it took me less than five (5) minutes to build. Now time to synchronize your watches and tell me how fast it will take you to build the same interface using JavaFx Composer plugin. It will probably take me less than five (5) minutes if I was designing it with Matisse. My point is; a RAD tool is supposed to promote productivity and YES!!! I have realized this is a "PREVIEW" release but can you actually use it? I know I will still be coding JavaFx for the foreseable future and I would love it to succeed. If you are going to call a tool "a RAD tool for building Form-based JavaFx UI" then I suggest that you provide most of the form components.

Should JavaFx UI RAD tools be based on XML like Android and Adobe Flash Builder?

5 components I like to have on JavaFx

1. Menu and tool bar (come on guys, this was there in previous release)
2. Grids (even just a simple table will do. For now I use JTable)
3. Date picker, Rich Text and Navigator components
   
4. HTML panel (something that display HTML and can also be used as iFrames)
5. Panels similar to JInternalFrame (this will be useful in portlet-like applications)

I know it's not really 5 things but they will make a difference. Thanks for reading and tell me what you think about JavaFx and its UI Composer.

For the past few days, I have been working on a simple proof of concept; a web based stock streaming application with a community theme to it. I set myself to building the backend first. As you can guess, I am developing in Java and here are some of the requirements that I have to meet, at least:

1. The application shall allow the user to query a stock (quotes) either using the stock ticker or the company name and display the following: stream stock price with basic info, stock historical price; tabular view and financial chart analysis.
   
2. The ability to rate, comments and share stock information.
3. provide a real-time chat features for users of the application to interact together.
4. single sign-on integration with OpenSocial, OpenID and Facebook connect.

The above are some basic features in order for people to actually use the site. As you can see, they are mostly front-end requirements. Here is another important requirement:

• The application will be hosted on a Cloud-based service, the application shall keep to a minimum the load on the server as CPU and memory use will be charged per request.

I believe that last requirement was the key decision factor. I needed something that will make use of the user resources instead of stressing the server. Something that would execute on the browser, client-side. Being a Java developer, it is only normal for me to look for something that I can grasp easily and freely available on the market. I looked at a few RIA frameworks and tools but I needed something that can integrate within my development environment without the need switch between IDEs.

I had a look at JavaFX and GWT. Having worked on GWT in the past, I found that I could implement most of the requirements. GWT has a rich api and components sets (widgets). I could use the Google search, map, visualization... to build the front-end and implement the client side code.

It took me about two days to implement the basic front-end and back-end features; mostly concentrating requirements 1 and the last. But then I hit a brick wall, something that all Javascript developers already knew but I just came across:

The application is a mashup of different services from around the net. Some of those services were available for free and others were not available at all but I will still be connecting and parsing the relevant data to displayed on the screen. As requirement "1" was working fine, there was a disaster about to happen. Here is the basic architecture:

• when a user queries a stock, the data is sent to the back-end services.
• the back-end services queries a third-party web service which I do not have control over. ZERO.
• when the third-party web service returns, the data is then parsed into a format understood by the front-end and sent to the front-end services to display. 

The services was working fine until I had about 12 stocks displayed on my screen for testing purpose. The data was being streamed with a 1 minute interval. After about 30minutes later (and 360 requests = 12 *1 pm * 36m), I have noticed that the stock data was not being updated anymore and some screens were blank. No errors were logged and some other queries were still working such as the historical data. As I could not see the errrors from my debugging session, I therefore decided to query the third-party service manually through Firefox and IE and VOILA! The service provider had put a temporary ban on my IP address for making too many requests, it says. This was a major blocker as it seems that I could not access my primary data anymore. This left me questioning the feasibility of the project.

If a single user gets banned for tracking 12 stocks, what would happen when 100 or more users start watching their stocks?

OK, so I did not give up, at least not without a fight!

I looked at the problem from another perspective, the third-party view. How do they track my request as I do not have to register or sign-in? The obvious answer is my IP. So I thought, instead of making the request to their services from the back-end, I should send the request directly from the front-end. If each users make the same request, the third-party services would register different IP addresses for each one of them. Correct indeed but one big problem:

The front-end code is written in GWT which is then compiled to Javascript. Being a Java developer, I was not aware of the limitation of using AJAX in a mashup such as mine. After making the necessary changes, I then run the app just to get hit with another blocker - SOP (Javascript Same Origin Policy). What's in a monkey name was this all about? So after researching it - Google and Wikipedia, I knew what I was dealing with and I am sure all Javascript developers already knew that but not me :(. I never give up, it is not part of my nature, therefore I decided to look for ways around it and came across a tutorial on GWT site that shows you how to implement a workaround. Did the tutorial, implemented some basic methods and that worked fine but implementing the third-party service, did not work :(. The problem was simple, the workaround needs to be in JSON format which I coded but the third-party service needs to be able to send the request back to a "callback" method. This is it!!! Remember that I mentioned that I had ZERO control over the thrid-party service and therefore I could not implement this feature.

Remember, I never give up; when there's a will there's a way. So I hit a major blocker due to the technology, in this case it was Javascript. I know that if I was working on a pure java front-end GUI, this would have never occurred and Flex allows you to query other third-party services but I have no knowledge of ActionScript. I decided to go for JavaFX just because it is Java and allows me to connect and get my data (actually it's not mine). My options were Webstart, Applet and JavaFX. First of all, it has to be part of the site so my real options were Applet and JavaFX. Applet do not have a rich set of tools such as Map, Chart and everything else that JavaFX provides and I do not want to waste time coding them.

So same adventure but different episode; I am currently looking to implement the JavaFX UI so stay tune for the sequel and screenshot. I could have never anticipated those problems with the third-party and then Javascript but believe me it was a good experience and my Javascript just went +1.