More goodies from MS

My interest in software scalability and performance often leads me to Microsoft's Parallel Framework Extensions team BLOG, which recently published this great presentation from their parallelism tour...

Spring Source - the viable alternative to J2EE?

J2EE projects tend to be very complex, spanning multiple layers, using various technologies from IOC, ORM to AJAX. Their clustering, performance, fail-over and deployment are extremely important aspects, which are hard to manage...

Spring Framework was very successful in helping with some of those difficult aspects. Now after getting venture capital backing, Interface21 presents us with Spring Source - an alternative to J2EE. Take a look at this article in which Rob Harrop, in usual fashion, very precisely describes what the Spring Source is all about and where it is going.

I wonder if great tooling and OSGI support will help in adoption of this project?

Avoid long debug sessions for Java dynamic proxy in Eclipse

Dynamic proxy is a great feature implemented in Java. It is being used in many software packages like Spring Framework. It helps with implementation of delegate or decorator design patterns. To facilitate double dispatch, AOP, duck typing etc. But the fun begins when your Eclipse debug session makes you step through code coming from several entities from within java.lang.reflect.* This not only makes your debug session longer but has the potential to make the whole exercise frustrating. The key to solve this are the Step Filers...

They provide with the means to filter out irrelevant packages or classes from step through paths in your debug session.

Make sure your filters are enabled and include all required classes and packages to be excluded in the debug session.


When you do not want to step to the selected class from the call stack again, simply right click and add to the filter.


You can easily toggle filters on and off.

Testing Skype's Extensibility

It has been quite some time since I have started using Skype - the free VoIP service provider. Being away from the homeland, we have been spending hours on the phone talking to family and friends. As expected the costs of calls were huge. So as soon as Skype has become available it is pretty much all the time on the menu.

The thing with Skype is, there is no way to indicate that you are in the call (simple feature found in MSN messenger for example). This way someone dialling in, has no idea you are busy, and makes you react to the incoming call or to bear the ring tone. This is a pain especially when you are away from the computer and to help myself with this,I have committed this simple Skype plugin

This little project has helped me to relax from my J2EE studies, I have been conducting lately. It was a really nice counter-point, I have to admit. It took a bit of C++, rough COM (no ATL) and C# together to get it going. I exposed myself to dynamic class loading, created custom controls and satellite assemblies to host Polish resources. Then I have thrown some code at NUnit and Rhino Mocks for testing. And everything using just publicly available development tools including Microsoft's Visual Studio Express

I have to admit that after Eclipse or even VS professional, it was really difficult to go back to such primitive development environment. Insufficient class browsing, limited code re-factoring, no free integrated tooling, limited debugging and project options - did not encourage. It felt like going back in time. I have to admit that at one point, I thought of using Resharper and VS 2008 BETA. But the idea got dropped.

It continues to surprise me how many free and well integrated tools there are available for Java, comparing to MS .NET - Is it just sad story or opportunity, what do you think?

Anyway, now after passing the test for J2EE architect, I have my plugin working, what makes me doubly happy..

UML Tools I have used

After my reply to the article on the Coding Architecture Blog, which discussed UML tool of choice, I thought to get a bit more information about the UML tools I have used and why.


I was always fond of modelling. Maybe it is because I like abstraction. Maybe because it somehow connects me with my soul of automatics engineer. Or maybe simply because I prefer pretty pictures over large books of documentation. Who knows? ;) The fact is, when the design/modelling process is over, all the stake holders become more aware of the domain: its characteristics, requirements and hidden not so obvious processes or artefacts. So it is great to model! But lets talk about tools as promised.

UML Tools
Nowadays, most of the tools will allow you to capture the design in one way or the other. The problems will start appearing when you want to develop a model quickly, share it with others and keep it up to date. These are the objective factors (let me skip money for the moment). Not less important are the subjective factors like beauty of the created diagrams and ease of use of the software. Think especially about your audience and the fact that it is much more pleasing for them to look at diagrams with WOW factor rather then rough technical layouts...

1. Together Soft [Code is your model], which was great for forward and reverse engineering of the models directly in the code. First tool to propose GoF design patterns during development. Now it is integrated into Eclipse.
   
2. Rational Rose [Complexity doesn't matter], which was great for sharing distributed models. After integration into Eclipse, it allows meta-model handling using QVT
   
3. MS Visio [Beautiful Deployment], which is great for beautiful stencils and allows sharing models with other MS Office users
4. Poseidon [Free and MDA Compatible], which was great as being the first exporting models into XMI to be able to employ e.g. AndroMDA
   
5. Magic Draw [WOW but might be expensive], which I am fond of at the moment. As it does nearly all the things mentioned above plus more and has the WOW factor. Check CSE Builder for flash demo.
   

There are others worth evaluating:

• Select Enterprise [Model your process]
  
• iUML by Kennedy and Carter [TEST! your models before employing MDA]

Just downloaded StarUML, which is getting hype mentioned by many on the web...Have you tried Altova's UModel?

In case you are looking for information on UML
Check those links:

• UML Specification
  
• Learn about various resources on UML.ORG as supported by the OMG
• UML Tutorial by Borland

Or try out UML Distilled book by Martin Fowler

Custom Search Engine Builder

I have been using my Google account for quite a while and only recently came across COOP and Custom Search Engines. The whole CSE thing seems a great idea, as I can see myself wanting to be able to customize Google search engine. Funny thing is, the whole CSE definition process employs tagging techniques. This made me think, that it would be great to have a tool allowing me to use my own tagged data stored on Delicious to drive the definition of the Google Custom Search Engine. I thought of coding a prototype to do that. And here are the results of my work.

General Info
Delicious allows users accumulating bookmarks of their favourite internet sites and to categorize them by tagging with custom labels.

Google Custom Search Engine (CSE) provides utilities to allow users predefining their own search domains leading to more accurate and relevant searches. It is done by specifying list of sites, which should be included and excluded while performing the searches using standard Google search technology.

The idea
Now since CSE definition involves providing internet site details, the idea is to extract, transform and source information collected on Delicious into the CSE.
As you can see, what is being proposed here, is a simple tool allowing integrating public data between the two service providers. Let’s call it CSEB for CSE Builder.

How does the CSEB work and how do I use it?
When using the app, here are the steps to follow:

1. Provide your Delicious user id
2. Configure which tags to include or exclude from CSE
3. Provide your CSE inclusion and exclusion labels
4. Generate annotations
5. Provide your CSE details
6. Generate the context
7. Upload your annotations and context into the CSE

In case you want to see the application in action, check the Winked demo detailing the steps and outcome of taken actions.

Here is the Flash movie:

or if you reading this using RSS reader try this link.

Design aspects
APIs
Delicious API allows execution of various kinds of REST full queries. This way it is possible to retrieve information about tags and bookmarks/sites which can be fed to the client using RSS or JSON formats.
CSE provides with end-user controlled way of uploading files containing: site information (called annotations) and configuration information (called context).

Application
Since I do not host nor own any internet server, I thought of embedding all the functionality within client side Java Script. This way the prototype can be also easily distributed without need for large downloads and installations etc. The downside is that such approach requires nearly all processing to happen within the end-users’ browser.

Platform
I am not a JavaScript guru. Although after Dr.Dobbs review, I should probably choose YUI but I have decided to leverage my Java skills and employed GWT to compile my Java code into JavaScript, which could be then executed within several supported and most common browsers.


Development Environment Setup
GWT integrates really well into Eclipse I must say. This speeds up the development process tremendously as you can debug your Java code, while driving the generated web UI in the hosted browser – perfect!

So, I have downloaded Europa (the largest open source project release to date). During the setup, of the development environment, I have defined two run configurations and made them persist into files for re-usability. Check tab common\save as\shared file edit box.

First one is hosted debug. In the run configuration dialog-box I have:

• chosen java application configuration type
• chosen com.google.gwt.dev.GWTShell for main class
  
• selected arguments tab and within program arguments edit box typed

  -port 9999 -logLevel DEBUG -noserver ${project_loc}\www\org.cse.csebuilder\csebuilder.html

  where: 9999 is my port of choice as since I am running many services on my poor box so the standard ports get allocated pretty quickly
  

Second one is for unit testing. Again in the run configuration dialog-box I have:

• chosen JUnit run configuration type
• selected run all tests... option for Junit3
• selected arguments tab and within VM arguments edit box typed:

  -Dgwt.args="-out www-test"

  where: www-test is my directory of choice for storing unit test

As it is a good practice to eradicate the warnings from your project, and since GWT does support JAVA 5, I have setup the project compiler settings to use JAVA 1.4 compliance level and switched to JUNIT 3.8. But before linking the external dependencies I have defined two Java build path environment variables for GWT and JUNIT accordingly.

GWT allows generating the Eclipse project without much of a hassle. The only thing is that it generates batch files, which need to be executed for compilation, debug and testing purposes. I do not know about you, but I like to use ANT or Maven to script such tasks. So to get the project going I have setup my ANT script accordingly.

Then, I have downloaded and configured Subclipse,which is an Eclipse Subversion client. This allowed me sharing the code using Google Project Hosting Services.

Same Origin Policy – the reason why I started dealing with JSON
Since all processing is to happen within a client web browser I needed to find out the way to fetch and use the remote data. The way of doing it is to use AJAX methods and issue asynchronous requests for content. Problem is that, the data fed into the client is going to be retrieved from a different site to the CSEB. So it is subject to restrictions as defined by the Same Origin Policy (SOP). Under this policy the only thing I could do, was to use JSON format. When employing JSON one dynamically changes content of the DOM model and injects script tags. This asks the browser to download remote script contents and this way obtain new data available to your application. Additional information about JSON in GWT can be found here.

I have written custom utility class to handle this. It is made responsible for injecting the script object and managing its lifetime. The class does so, by using ID attribute within page DOM, which gets populated with the request URL and therefore allows replacing corresponding items when when multiple requests are being issued.


Data Processing delegated to Yahoo Pipes
Although Delicious provides with API, for tags and bookmarks retrieval, but the JSON APIs are subject to restrictions. You simply cannot fetch more than 100 items at a time. Such restrictions are good for the server side and scalability but are limiting the amount of things, which could be done in the CSEB application. Another thing is that, to make sure all relevant bookmarks are retrieved; the client would need to issue as many requests for the bookmarks as there are selected tags. This way one would have to handle chain of asynchronous communications on the client. What happens if one of them fails? Additionally it is possible to encounter a bookmark, which is a part of a few different categories. Therefore there is a need to handle duplicates. It tends to become resource hungry == really ugly…

To sort this out, I thought of using custom build yahoo pipes, so that the processing is delegated to the Yahoo Pipes service. Such service consists of two linked pipes.

1. First one is made responsible of fetching JSON for delicious bookmarks owned by a user and associated with category / tag provided.
   
2. Second pipe uses up to N fetching pipes. It aggregates their output, removes duplicated sites and returns JSON feed to the CSEB.

The downside of this approach is that the more services are introduced; it is more likely to suffer from connectivity and service downtime issues.

Mind you, now to achieve similar results you could employ worker pool from recently released Google Gears. This would require Gears download and refactoring, though.

Saving mashed information into a local file.
Once all the data is fetched and transformed into XML, end-user is asked to create a file to be able (in the dedicated separate step) to upload it into the CSE itself. It could be achieved in two ways: firstly by using a clipboard and file editor (which is a two-step operation) or secondly user could try persisting content into a local file from the browser (ideal). But such operation is subject to SOP again. As it would open up the way for all type of malicious Cross Site scripting attacks if local persistance was allowed.

Trying to get my local persistance working, I have coded a widget displaying generic, dialog like, page to allow end-user persisting XML content using Save Page As browser command.

The whole idea is based on the fact, that the browser will persist text exposed by the currently visible DOM objects. So providing, that your host page does not include textual fields, this widget will be able to control all the displayable elements. The widget contains several HTML widgets, styled not to be displayed, which will blend their contents to form valid XML document when the page gets saved. The whole trick is about inserting XML comments just before closing part of the root element. This way textual content of the page will end up being part of XML comment and the whole page can be persisted a valid XML (that is if you do not mind some rubbish in comments;) Here is the example of the generated XML:

<?xml version="1.0" encoding="UTF-8" ?>
<YourRootElem>
<YourElem... />

<!--
contents of the dialog goes here
-->
</YourRootElem>

GWT History
To be able to achieve local file persistence I needed to try out GWT History subsystem. It allows maintaining the state of the application when switching between populated main page and a Save as widget.
During unit testing I have found that although you can call History methods to programmatically invoke back and forward commands of the browser, but this happens without raising corresponding onHistoryChange event. I raised this as an issue on the GWT forum.

If you think you do not have to know HTML and JavaScript you might get disappointed
When coding CSEB, I have realized that it would be very difficult to develop an application without basic knowledge of HTML, CSS or JavaScript primitives. The GWT is stable but still very much evolving piece of software following the evolution of the browser technology.
This prototype required me to write a few custom widgets and implement a few lines of JSNI. This is only to get access to the required functionality making it possible to provide with desired UI metaphors.

Unfortunately due to limitations I could not test all of the JSNI code against all supported browsers but only two: FireFox and Internet Explorer.

When something worked not exaclty according to plan, I used FireFox and its great FireBug addon to debug the generated code and styles. So many thanks go to to its author Joe Hewitt.


Polishing the UI
Being of Polish origin, I wanted to have the CSEB available in my native language. To achieve this, I have localized the app, written all the necessary I18N code and developed a custom widget allowing the user to switch locale during runtime. I have written all relevant property files and things worked just fine.

GWT expects the whole locale specific data to be nicely separated in Java. Then it gets compiled into optionally obfuscated JavaScript. This works perfectly, but such approach does not allow language contributions without recompilation and IMHO presents itself as a little inconvenience. I think it would be beneficial to be able to ask for language contributions, which could be integrated with greater ease. So that locale specific data is loaded via e.g. XML from the same origin. Another reason would be that the supported languages add to the complexity of the compilation process as the GWT compiler generates files to cater for language-browser specific JavaScript combinations. So by removing the language from the combination would simplify the compilation process...


Testing, testing and once more testing
One of the things you need to love about GWT is the fact you can use JUNIT to test the functionality. It is even possible to emulate execution of the asynchronous code. I keep asking myself though, how accurate is to test the code which gets auto generated by the GWT compiler? But the similarity of the allowed subset of JAVA and JavaScript should make one quite comfortable…

The availability of unit testing most definitely contributes to the better quality of the solutions. As now there is no excuse to leave your code in un-testable and highly coupled state in JAVA. Now all the good coding practices can make their way into the JavaScript territory, providing GWT compiler will do the most out of them:

1. Introduction of proper layering and class design to facilitate
   
• Single concern principle
• Low Coupling
• High Cohesion
2. Removal of various code smells
3. Documentation
   

In case you are new to testing take a look at Google testing blog for guidance. It is really good read.


Architecture
The idea was to keep the subsystems small, low coupled and testable.
But following the rule that

A picture says a million words.

I have created the demonstration discussing the architecture on canvas of the UML diagrams. So check up:

• The use case diagram for project functional requirements
• The deployment diagram for deployment details
• Sequence diagrams describing realization of the proposed use cases
• Class diagrams for layering and internal infrastructure
• Collaboration Diagrams for the algorithm descriptions

Here is the Flash movie:

or if you reading this using RSS reader try this link.

The model has been created in MagicDraw and uploaded to here for your reference. You can easily view using free Magic Draw Reader.

Deployment
I have subscribed to Google Page Creator Services and thought of deploying the application to my custom site. The unexpected issue I have hit was related to the fact that the file upload mechanism has truncated the file names down to 41 characters max. This made code another utility to shorten the compiled names. Let me know if you would like me to publish this as well.

So finally, the CSEB application can be found here for test run.

License and Attributions.
The project including sources, documentation etc. got uploaded and is hosted by the Google Code. Check main project's page for license information.

Icons are provided by the FamFamFam.

After dealing with enterprise software it was really great fun to delve into the world of internet technologies. Let me know what you think of this all.

Creating Unicode Content

It is quite some time since my last entry. So trying to defy the opinions that the usual blog's life time is 3 months - let me post this and share with you some information about writing true Unicode text files using TextPad...

Why TextPad? Well, it is because it is my favoutite editor. It is windows based. I have it installed at work and obviously it has its Polish release. It is extensible and there are many addons available for it. It refreshes the content in case of file changed. It is also capable of dealing with huge files.

Unicode Editors
There are some other editors available as well like:

• jEdit, infrequently used by me, which is a great open source, extensible and free Java editor.

• UltraEdit, infrequently used by me, which is very good and reach in features but may prove costly (not checked their new Lite version yet)

• Multi-Edit, which I have not used yet

• You can also use notepad but even thinking about it hurts...

Setup presentation
Anyways, back to the TextPad. I had recently a few Unicode files to write and, as it usually happens, not a lot of time to spend to configure the tool. So went to ask colleagues to find out about the details, as they have done it recently. But hey - they managed to forget it all. Setup is really simple but you need to spend some time to get the document persistance right to be able to write correct file format. Then setup the font so the tool is capable of displaying characters on the screen. I thought it would be a good idea to capture those little details in a form of presentation for future reference. And give my new open source screen casting software WINK a test drive.

So here it is - mind you, since it is a flash movie make sure your add blocker allows it to execute:


TextPad Addon
One last thing mentioned during the presentation is my custom written TextPad addon. I created it to help me writing ANSI files containing Polish Unicode character codes. Feel free to download it and use it. In order to install it simply drop it into the TextPad\Samples directory and re-run the application.