R-She-Yeah

IFE - A Charity to promote the message of PEACE.

2010-08-07T01:22:00.004+01:00

For the past few months, I have been very busy devoting my personal time, to IFe. IFe stands for Islam Festival Edinburgh, and its an initiative to promote the message of ISLAM which stands for PEACE that is so misunderstood by the world today and linked to terrorism & violence, which is not what it is really all about.

I have been questioned by my peers @ work of what ISLAM is , and what the QURAN all about. To them, I invite you to go to www.islamfestival.com and DISCOVER ISLAM.

In religion, BELIEF comes first , than rationalising it. In maths / science, PROVABLE facts, come first then a CONCLUSION, to support the HYPOTHESIS. If today, blue-tooth and WI-FI technology does exist and mp3/images/documents can be downloaded, then surely- why is it so hard to believe that more than 1400 years ago , there was a way for GOD's word which comprises of the Holy Quran to be downloaded to a very human prophet. And if versions in software and the need of upgrades do exist, so from an OLD testament(downloaded to Moses), to the NEW testament (downloaded to Jesus) , to the Quran (downloaded to Mohammed P.B.U.H) as last and final release, so hard to believe...

And believe it or not, the technology to make human's as receivers of data- possible is yet to be DISCOVERED, sooner or later. And has SCIENCE been able to prove the existence of ANGELS, the existence of SOULs ? Surely, if matter is energy than we should have detectors to detect this natural phenomenon.

Well, IFE was made possible by HTML, JQUERY, PHOTOSHOP and the content managed by the social media elements like Twitter, Flickr ,Youtube. After all, I live and breathe and support social media REVOLUTION, coz I am a very SOCIAL being!!!!

Please see it here.

Paying a tribute to Hannah Barbera

2010-06-29T22:53:00.003+01:00

Meet George Jetson, his boy Elroy, his daughter Judie, Jane - his wife....

Yes , in the 1960's came this cartoon, and during my growing up years, I was fascinated by the technology of VIDEO calls (which is now a reality) , flat TV's and touch screen computer that interacts with the user ... to name a few, and still an AI robot is yet to come ...

Hence for the digital inspiration, I take my hats off to Mr. Hannah & Barbera, for their vision of the future , a peek into the `year -2062' , about 50 years ago, long before anyone thought it was imaginable , let alone possible....

Thinking about Forms and Usability...

2010-05-23T22:22:00.038+01:00

Notes from the book - Forms that work: Designing Web Forms for Usability by Caroline Garret

There is a theory to think about when designing FORMS !
The theory is of the three layers of the form: Relationship, Conversation, and Appearance .

The relationship of a form is the relationship between the organization
that is asking the questions and the person who is answering.
- Pursuading people to answer.
   - Pick the right moment to ask a question.
   - Three rules that infl uence response rates
         - Rule 1: Establish trust.
1. Show that the form is published by a real organization.
              2. Make it easy to contact the organization that publishes the form.
              3. Ensure that the form has a clear purpose.
              4. Make sure that the form looks as if it has been designed by a professional.
              5. Keep advertising away from the form.
              6. Check that the form works correctly: no defects, no typographical errors.

         - Rule 2: Reduce social costs.-Social costs are bad feelings, like being made to feel inferior or being put at a disadvantage.
                      1. Ask for answers; don’t demand them.
                      2. Keep the form short and easy.
                      3. Help users to feel in control of the form by giving them a progress indicator
                          or summary menu.
                      4. Minimize requests for sensitive or personal information.
                      5. Design questions that users can answer.
                      6. Use error messages that respect the effort the user is making.
                      7. If the user does make a mistake, preserve as much of that user’s work as
                          possible. Keep retyping to the minimum necessary to correct the problem.

         - Rule 3: Increase rewards.
People are more likely to respond if they perceive that they will get some reward by doing so.

How long can a form be ?
The form is the right length if these factors are in balance:
● There is a basis of trust: the user trusts the organization enough to
put in some effort.
● The user perceives that there is suffi cient reward for completing the
form.
● The effort (mental effort, number of questions, time to complete the
form) is appropriate.

Who will answer your questions?
Understanding your users is often called “user profi ling” or “user needs analysis.”

To ensure that you get honest and timely data from your users,
make sure that you:
● Pick the right moment to ask a question;
● Think about who will use the form and his or her relationship with
the organization;
● Understand the user’s goals associated with the form;
● Ensure that the reward the user gets from fi lling in the form is in
balance with the amount of effort required to complete it.

- Asking for the right information

Find out why you’re asking your users for information, what you’re going
to do with it, and when you need it:
● Asking for information that you don’t need is bad.
● Check with stakeholders to see what information is really needed.
● Users will assume that you will actually use the information you
request, so make sure you do use it in a sensible way.
● Find out what your competitors and similar organizations are doing.

The conversation of a form comes from the questions that it asks, any
other instructions, and the way the form is arranged into topics.
- Making questions easy to answer.
The four steps of answering a question:
1. Understand the question.
2. Find the answer.
3. Judge the answer.
4. Put the answer on the form.
To make these steps as easy as possible:
● Ask about concepts that the users are familiar with, using words
that they understand.
● Think about how users fi nd the answer. Should you offer help about
where an answer could come from?
● Think about whether users will want to answer. Is this the right
moment in the relationship to ask this question?
● And think about forcing users into your options. Could you offer an
“ other” option to cater for the unexpected?

- Writing useful insturctions
Start by making sure that your instructions are in plain language:
● Use words that your target users are familiar with.
● Use simple sentences in the active voice.
● Get rid of big blocks of text.
● Put choices before actions: “If” before “then.”
● Remember that good headings help, bad headings hurt.
Then review your instructions to make sure that you have only the useful
ones and that they are in the right place:
At the start of the form, you need to do the following:
● Include a title that says what the form is for.
● If you have gathered answers, then provide a list of things to gather.
● If some people should use a different form, then send them off to it.
But don’t put things that happen at the end of the form at the
beginning.
- Choosing form controls - input box, checkbox, dropdown
Think about users’ expectations of how the controls work.
● If typing the answer is more natural, then go for a type-in box.
● If users are likely to make mistakes when typing, then opt for
something they can click.
● If there are a lot of options, using a drop-down may be best. But
could you redesign the question instead?
● If the users are able to select more than one option, checkboxes are
likely to be the best control.
● If the options all look alike, you may do better to let the users type
into a text box instead.
● If the users need to see the options to understand the question,
then radio buttons or checkboxes require less effort. Drop-downs, radio buttons, and checkboxes all need options as well as labels.
Describe your options clearly and choose a sensible order for the options.
Specialist controls such as calendars and maps have their place, but if
you do use them, then make sure that you offer a plain text alternative.

- Making the form flow easily

A good conversation fl ows naturally from topic to topic. Exploit this to break up large forms into manageable chunks.
If your form includes some gathered or third-party answers, then find a good way of allowing users to store the form and come back to it, and opt for a summary menu rather than a progress indicator.
Avoid surprising users with sudden changes. If you need to be selective about what questions you present to users, then build pages that reflect their earlier answers.
Be gentle with errors. Validations may help guide users to correct input, but they may also force incorrect (or even downright stupid) answers out of reluctant users and undermine the relationship.
Be as careful with the fi nal “thank you ” or acknowledgment page as with the rest of your site. Even if you have to break bad news to the user, try to be as helpful as possible while doing it.

The appearance of a form is the way that it looks: the arrangement of
text, input areas such as fi elds and graphics, and the use of color.
- Taking care of the details
● End each label with a colon.
● Use sentence case for labels.
● Use an asterisk as a required fi eld indicator, supplemented by the required markup and a short explanation of the indicator at the start of the fi elds.
● Choose a legible font such as Verdana, use it at a large size, and
make sure that users can easily change the size.
● Aim for a line length that is long enough to create coherent phrases
but short enough to allow easy eye-movements back to the start of
each line.
- Making the form look easy

When users are dealing with the questions and answers, they focus
tightly on the fields and labels.
But when they swap to a different task, such as asking “Who are you ” or
looking for contact details, they snap out of the narrow focus and start
looking at the page furniture. Help them by making sure your form is
lightly but clearly branded as part of your site.
Lining up forms to a vertical grid makes them look tidy and thoughtfully
designed; that increases user confi dence in the form.
Forms look easier to handle if the fi elds are organized into groups.
Placement is the easiest, clearest way of showing groups, but lines may
undermine grouping.
Once you have established a grouping pattern, don’t break it.
Two-column layouts can create ambiguous reading orders; users can go
across horizontally or down vertically. Avoid using two columns.

Page Speed

2010-05-22T21:12:00.000+01:00

Page Speed - is an open-source Firefox/Firebug Add-on. Webmasters and web developers can use Page Speed to evaluate the performance of their web pages and to get suggestions on how to improve them.
Read more about it here.

One ON One on R-She-Yeah

2010-05-22T17:58:00.004+01:00

Okay, my thoughts of doing ONE thing over an over - its BORING !!!
Well , an actor gets to play different type of ROLE's , I too believe in VARIETY and taking up challenging, diverse tasks from a technical perspective- just to feel ALIVE, and live ON THE EDGE. I love being CREATIVE, having CREATIVE visions, taking CREATIVE decisions, while staying FOCUSSED and persistent to accomplish my ideas. Thats me, simply r-she-yeah

Notes about differences between Java and JavaScript

2010-05-20T15:04:00.003+01:00

Dynamic binding VS Static binding
JavaScript features DYNAMIC binding, so all object references are checked at run time. Java, on the other hand, is based on STATIC binding, meaning that all object references must exist and be valid at compile time. However, an object-oriented language may require dynamic method bindings because polymorphism allows multiple definitions of methods sharing a common name, and calling such polymorphic methods often cannot be resolved until run time. The most obvious reason for this difference is that JavaScript is NOT compiled, so checking object references at compile time has no meaning.

Object-oriented VS Object-based
JavaScript is based on a simple object-oriented paradigm. This paradigm is often called object based, as opposed to object oriented. If you are used to a truly object-oriented language such as C#, Java, or C++, you will find much of that functionality is missing in JavaScript. For example, classes do not exist in JavaScript (all objects belong to one “class”), nor do packages (because a package groups classes together). The object hierarchy in JavaScript is a containment hierarchy, not an inheritance hierarchy as in Java and C++. That is, an object does not inherit from other objects, but it can be contained by another object if it is a property of that object. Most object-oriented languages require static resolution of objects at compile time.
However, an object-oriented language may require dynamic method bindings because polymorphism allows multiple definitions of methods sharing a common name. Calling such polymorphic methods often cannot be resolved until run time. JavaScript is completely based on dynamic binding. That is, object references are checked at run time. There are many other differences between the object paradigm in JavaScript and the one in full object-oriented languages (such as Java and C++).

Reference: Advanced JavaScript by Chuck Eastom

Logo design for Ryer Corporate Solutions

2010-03-28T22:06:00.000+01:00

After nearly a gap of 4 years, upon the request of a friend, who plans to launch an IT startup based in Australia, I got down to designing a LOGO for him and unleashing my creativity.

Please see here.

Checking out the blogeditor built by GWT

2010-03-03T12:15:00.002Z

Try it here.

Facebook JAVA API

2010-02-23T12:16:00.002Z

A Facebook API client implemented in Java, originally derived from the official Facebook client. Check it out here.

MySQL cries Time Out !!!

2010-02-12T23:58:00.010Z

Problem: MySQL after being idle for some time like 180 seconds, experiences " Time Out" - Communications Link Failure, closes the connection and shuts itself off- No Entry !!

12:56:20,561 ERROR SchemaUpdate:188 - could not complete schema update com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure

Caused by: java.net.ConnectException: Connection timed out  at java.net.PlainSocketImpl.socketConnect(Native Method)  at java.net.PlainSocketImpl.doConnect(PlainSocketImpl.java:333)  at java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.java:195)  at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:182)  at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:366)  at java.net.Socket.connect(Socket.java:525)  at java.net.Socket.connect(Socket.java:475)  at java.net.Socket.(Socket.java:372)  at java.net.Socket.(Socket.java:215)  at com.mysql.jdbc.StandardSocketFactory.connect(StandardSocketFactory.java:253)  at com.mysql.jdbc.MysqlIO.(MysqlIO.java:280)  at com.mysql.jdbc.ConnectionImpl.createNewIO(ConnectionImpl.java:2026)  ... 48 more


And these are the settings on the MySQL :[root@db ~]# grep time /etc/my.cnf interactive_timeout=180 wait_timeout=180

meaning...The MySQL server will close connections that aren't doing anything after 180 seconds (3 minutes) 

So now the solution lies in importing the c3p0.jar and  programmatic-ally configuring the hibernate configuration file- as follows:

<property name="hibernate.connection.provider_class"> org.hibernate.connection.C3P0ConnectionProvider </property>
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.max_size">30</property>
<property name="hibernate.c3p0.timeout">5000</property>
<property name="hibernate.c3p0.max_statements">100</property>
<property name="hibernate.c3p0.acquire_increment">5</property>
<property name="hibernate.c3p0.idle_test_period">100</property>
<property name="hibernate.c3p0.preferredTestQuery">SELECT 1</property>

How to deal with exceptions of org.hibernate.cfg.Configuration.xmlHelper...?

2010-01-26T12:47:00.002Z

The exact exception I came across -

Exception in thread “main” java.lang.IllegalAccessError: tried to access field org.hibernate.cfg.Configuration.xmlHelper from class org.hibernate.cfg.AnnotationConfiguration
at org.hibernate.cfg.AnnotationConfiguration.addInputStream(AnnotationConfiguration.java:712)
at org.hibernate.cfg.Configuration.addResource(Configuration.java:481)
at.......

It simply means you got to check the compatibility of the hibernate jar files present in your lib folder for the project at hand.

http://www.hibernate.org/30.html

If there are incompatibilities, this error gets thrown...

r-she-yeah

com.mysql.jdbc.PacketTooBigException

2010-01-19T18:34:00.002Z

Packet too Big Exception originates from MySQL when the packet of data is too big for MYSQL to handle.
com.mysql.jdbc.PacketTooBigException: Packet for query is too large (4739923 > 1048576).
After a whole day of nerves wrecked for this, I figured out that i need to increase the size of "max_allowed_packet variable" in two places at the client's and server's end - as stated by MYSQL (http://dev.mysql.com/doc/refman/5.1/en/packet-too-large.html)

mysql> show variables like '%max_allowed_packet';

mysql> set global max_allowed_packet=52428800;

File: /etc/my.cnf
max_allowed_packet=50M

The maximum allowed packet size is 1GB ie 100MB.
Oh btw, 1 MB = 1048576 bytes.

And viola, then restart the server.

/etc/init.d/mysqld restart && tail -f /var/log/mysqld.log

Yeah ! problem solved...

org.hibernate.MappingException Unknown entity: AFullyQualifiedClassName

2009-12-18T15:07:00.006Z

I was struggling with this error after having generated the DAO classes using MyEclipse IDE.
My hibernate configuration file was alright, the libs were in place (hibernate3.jar ,hibernate-annotations.jar) and so was the desired mapping path present...

mapping resource="com/bmb/model/BlogFeed.hbm.xml"

I was importing the proper classes for the annotations

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

But the compiler continued to shout :

15:13:48,959 DEBUG BlogFeedDAO:62 - getting BlogFeed instance with id: 1
Entity retrieval failed.15:13:48,961 ERROR BlogFeedDAO:68 - get failed
org.hibernate.MappingException: Unknown entity: BlogFeed.class

Finally after hours, I realized the mistake and changed the code from orange to green...


public BlogFeed findById( java.lang.Integer id) {
     log.debug("getting BlogFeed instance with id: " + id);
     try {

          //error BlogFeed instance = (BlogFeed) getSession().get("BlogFeed", id);

          BlogFeed instance = (BlogFeed) getSession().get(BlogFeed.class, id);
         return instance;
     } catch (RuntimeException re) {
         log.error("get failed", re);
         throw re;
     }
 }

Having this -
Object org.hibernate.Session.get(Class arg0, Serializable arg1) throws HibernateException, forces the compiler to fetch the class (you can also specify the fully qualified class name).

Investigating the tech behind an iPhone Accelerometer

2009-11-29T16:09:00.000Z

Interesting ways of making technology make SENSE !!!

The iPhone contains 2 accelerometers which is used to detect orientation change with relation to gravity and 3D space. Many of us am sure must have played around with rotation from potrait to landscape mode or back...

Here are the many creative ways in which it is being used. Check it out here.

Its time - " Jack of all, master in MSc Mobile and Wireless Computing"

2009-11-29T12:27:00.003Z

I have decided to start pursuing masters in MSc Mobile and Wireless Computing at the University of West Minister,London,UK. Check out this link.
Its is a 2 to 5 years, part-time course. I plan to finish it off in 2 years.

OMG = SixthSense Technology by Pranav Mistry !!!!

2009-11-29T12:14:00.006Z

Pranav Mistry - A true genious !!!

Pranav Mistry demos several tools that help the physical world interact with the world of data -- including a deep look at his SixthSense device and a new, paradigm-shifting paper "laptop." In an onstage Q&A, Mistry says he'll open-source the software behind SixthSense, to open its possibilities to all

PART 1:

PART 2:

Cant wait- The future is HERE !!!

Google Blog Search API

2009-11-25T18:37:00.005Z

I am currently investigating how to implement Google Blog search using the Java API, in an attempt to architect & implement an aggregator.

Check this link out.

Busy@BMB building an Aggregator

2009-11-24T16:49:00.004Z

I have dived deep into the world of YouTube API, along with Twitter and Flickr in an attempt to build a prototype feeds "aggregator". Soon i will move onto the Blogger API. I must say - interesting stuff , playing around with feeds from the Java / j2EE , Hibernate platform. It is fun!

Interview with Tom Sugden !!!

2009-10-15T18:11:00.004+01:00

OMG - I just had a 30 min conversation with "Tom Sugden" from Adobe Consulting!!!

All time favorite book !

2009-09-04T22:13:00.005+01:00

Design Pattern for Dummies by Stenven Holzner

Click here to try it!

A new Discovery - Xenocode !

2009-09-01T00:28:00.008+01:00

Today, after tireless attempts to install IE 7.0 on my 64-bit Windows Vista Home Premium Operating System that came pre-loaded with IE 8.0 - I have thanks to the technical guidance by the guru's at BazaarVoice discovered XENOCODE.

Now XENOCODE is simply ingenious! As aptly stated " brings the world of software to the web". No installation, no hassles by amateurs like me. To date, whenever I play with the O.S it crashes.

Hence I am overjoyed at this discovery and happy that my multiple IE browser installation and uninstallation days are over...

Please visit XENOCODE for more information.

Working with Strategy in AS3/Flex

2009-08-27T21:36:00.014+01:00

Strategy tells us to
• Define and encapsulate a family of algorithms.
• Make encapsulated algorithms interchangeable.
• Allow algorithms to change independently from the clients that use it.

HRAgency

For illustration purposes,in this sample application, a Strategy pattern is used to implement a solution for an HR employment agency.
• The agency has a number of consultants it represents. Clients call for different consultant job types targeted at either- employer or jobseeker. They want either a particular consultant or particular support tasks or main tasks they can perform.
• To create a flexible program for the HR agency, each of the specific support related and main tasks has been created in separate algorithms. The algorithms are encapsulated, and the consultants delegate their performance skills to the encapsulated algorithms—strategies.

The base Consultant context class

The first step is to create a context class and concrete contexts that will use the different tasks and support jobs.
Consultant class is the base class, establishing the references to the strategy methods.
The main tasks and support operations are delegated to the strategy classes.

The concrete Consultant classes
• EmployeeConsultant extends the context Consultant
• JobSeekerConsultant extends the context Consultant

Each is assigned a different task and support that are delegated to concrete strategy instances.

package { class Consultant { protected var mytasks:ITasks; protected var mysupport:ISupport; public function doManagementTasks( ):void { mytasks.task( ); } public function doSupportTasks( ):void { mysupport.support( ); } } } package { class EmployeeConsultant extends Consultant { public function EmployeeConsultant( ) { tasks = new NewHireInduction( ); support = new FileRecord( ); } } } package { class JobSeekerConsultant extends Consultant { public function JobSeekerConsultant( ) { tasks = new Close( ); support = new CallUp( ); } } }

The Tasks Interface and Implementations

All the algorithms for doing tasks are encapsulated in the concrete strategy subclasses.
The TASKS interface provides the abstract method, and the subclasses add detail to the operations. A total of three TASK algorithms are implemented.
• Manage.as
• Close.as
• NewHireInduction.as

package { interface ITasks { function task( ):void; } } package { //Manage Multiple Projects public class Manage implements Tasks { public function tasks( ):void { trace("Look at me juggle! Whoops!\n") } } } package { //Make Open Files Close public class Close implements ITasks { public function task( ):void { trace("Now close the open tasks. Successfully found the job!\n") } } }

The Support Interface and Implementations

All the algorithms for doing tasks are encapsulated in the concrete strategy subclasses.
The SUPPORT interface provides the abstract method, and the subclasses add detail to the operations.
A total of two SUPPORT algorithms are implemented.
• Callup.as
• FileRecord.as

package { //Support Tasks Interface interface ISupport { function support( ):void; } } package { //Consultants chase each other public class CallUp implements ISupport { public function support( ):void { trace("Status Call - I'm going to talk to you!"); } } } package { public class FileRecord implements ISupport { public function support( ):void { trace("I'm adding this client in the records!") } } }

The HRManager Sprite

The HRManager class instantiates two different consultant classes, through their interfaces rather than implementations by instantiating through the Consultant subclasses.
All are delegated from the Consultant context class and implemented in the concrete consultant classes.
The output represents the algorithms set up in the strategy classes.
package { import flash.display.Sprite; public class HRManager extends Sprite { public function HRManager() { var jobseeker:Consultant=new JobSeekerConsultant(); jobseeker.doManagementTasks(); jobseeker.doSupportTasks(); var employer:Consultant=new EmployeeConsultant(); employer.doManagementTasks(); employer.doSupportTasks(); } } }

Creating Combobox within a DataGrid column in Flex

2009-08-22T16:49:00.005+01:00

The compononet that needs to be attached might be a Combobox or a Checkbox.
One of the techniques is to create a custom ComboBox and use the itemRenderer property of the DataGridColumn to display it inside the data grid as a Combobox which then, internally fetches its values from an XML.
<mx:DataGrid id="portfolioGrid" width="100%" height="100%" dataProvider="{portfolioModel.security}" selectable="true"> <mx:columns><mx:Array> <mx:DataGridColumn dataField="Symbol"/> <mx:DataGridColumn dataField="Quantity" textAlign="right"/> <mx:DataGridColumn dataField="Price" textAlign="right"/> <mx:DataGridColumn dataField="Value" textAlign="right"/> <mx:DataGridColumn dataField="portfolioType" width="175" textAlign="center" headerText="Type" sortable="false" editable="true" editorDataField="newState" rendererIsEditor="true" itemRenderer="MyComboBox"/> </mx:Array></mx:columns> </mx:DataGrid>

MyComboBox.mxml needs to be imported and corresponding handler functions for the ComboBox component needs to be defined in this separate file.

"Protocols that RULE the FLEX world"

2009-08-16T09:48:00.018+01:00

In the context of RIA, protocols that we need to get familiarized with are
1. REST - HTTP Object <mx:httpservice>
2. SOAP - WebServices Object WSDL <mx:webservices>
3. AMF - Remote Objects <mx:remoteobject>
4. XML Sockets (myXML = new XMLSocket;)

RIA's essentially reside on the client and communicate with the servers only to request and process data unlike normal web apps which are page-centric.

First is the widely used, REST(Responseful State Transfer) includes - HTTP(Hyper Text Transfer Protocol):

HTTP Service Component typically consumes XML responses.
They let you send HTTP GET, POST, HEAD, OPTIONS, PUT, TRACE, and DELETE requests and include data from HTTP responses in a Flex application.
Flex does not support mulitpart form POSTs.
The HTTPService's send() method makes the call to the JSP page.
The resultFormat property of the HTTPService component is set to object, so the data is sent back to the Flex application as a graph of ActionScript objects.

<mx:HTTPService id="srv" url="catalog.jsp"/> <mx:DataGrid dataProvider="{srv.lastResult.catalog.product}" width="100%" height="100%"/> <mx:Button label="Get Data" click="srv.send()"/>

For RemoteObjects:
The results of remote invocations are returned via events.
RemoteObject provides the result event for success or fault for failures.

To implement we must write the corresponding handler functions. Flex will call these methods, supplying an Event object as a parameter. It’s our responsibility to get the information from the event and act accordingly.
Explicitly mapping Action Script objects to Java objects and Serializaton of data
Converting data from Java to Action Script

<mx:RemoteObject id="srv" destination="product"/> <mx:DataGrid dataProvider="{srv.getProducts.lastResult}" width="100%" height="100%"/> <mx:Button label="Get Data" click="srv.getProducts()"/>

For more indepth information, please refer to Flex3 with Java.

RSheYeah's System Reset & Restart

2009-07-16T12:07:00.003+01:00

I have re-set and re-start 'ed, in London...and that explains the lapse in blogging, developing and pretty much everything...

Google Plugin for Eclipse 3.4 (Ganymede)

2009-04-23T17:49:00.002+01:00

Instructions to jump start your Journey into the Google Development World. Read it here.

-Thanks Google

Spice up your GWT components with GWT EXT - (read gwit extension)

2009-03-13T19:40:00.005Z

GWText comes with some great components that spices up your otherwise plain GWT components.

Place the 'gwtext.jar' file and include in your project classpath ie. compiler and shell script

@java -Xmx256M -cp "%~dp0\src;%~dp0\bin;C:/gwt-windows-1.5.2/gwt-user.jar;C:/gwt-windows-1.5.2/gwt-dev-windows.jar;C:/gwt-windows-1.5.2/gwtext.jar" com.google.gwt.dev.GWTCompiler -out "%~dp0\www" %* com.rsheyeah.gwt.UITest

Make sure you have these lines in UITest.gwt.xml file

<inherits name='com.gwtext.GwtExt' />
<script src="js/ext/adapter/ext/ext-base.js" />
<script src="js/ext/ext-all.js" />
<stylesheet src="js/ext/resources/css/ext-all.css" />

Lastly, just have the appropriate resource files in their respective js folder

Otherwise, the compiler screams "No source code is available for type com.gwtext.client.widgets.form.*****; did you forget to inherit a required module?"

Creating JUnit test cases for your GWT project

2009-03-13T16:37:00.004Z

The importance of JUnit testing and benchmarking cannot be undermined for java projects, let alone GWT projects.

Out-of-box JUnit test support is shipped with GWT for client and server side synchronous and asynchronous testing.Each GWT JUnit test extends GWTTestCase and implements getModuleName() method which defines the interest of GWT module.

Hence, if you like to create a project "MyUITest" in eclipse:
Go to your GWT_HOME (the place where your gwt related jars reside) directory and in the command prompt, promptly type in
projectCreator -eclipse MyUITest
and
applicationCreator -eclipse MyUITest -out MyUITest com.rsheyeah.gwt.client.UITest

and the result is as follows:
Created directory MyUITest\src
Created directory MyUITest\src\com\rsheyeah\gwt
Created directory MyUITest\src\com\rsheyeah\gwt\client
Created directory MyUITest\src\com\rsheyeah\gwt\public
Created file MyUITest\src\com\rsheyeah\gwt\UITest.gwt.xml
Created file MyUITest\src\com\rsheyeah\gwt\public\UITest.html
Created file MyUITest\src\com\rsheyeah\gwt\public\UITest.css
Created file MyUITest\src\com\rsheyeah\gwt\client\UITest.java
Created file MyUITest\UITest.launch
Created file MyUITest\UITest-shell.cmd
Created file MyUITest\UITest-compile.cmd

Now heres the line which generates the junit files:

junitCreator -junit "F:\eclipse-jee-ganymede-SR2-win32\plugins\org.junit_3.8.2.v20080602-1318\junit.jar" -module com.rsheyeah.gwt.UITest -eclipse MyUITest com.rsheyeah.gwt.client.UITester

and the result is as follows:
Created directory C:\gwt-windows-1.5.2\test
Created directory C:\gwt-windows-1.5.2\test\com\rsheyeah\gwt\client
Created file C:\gwt-windows-1.5.2\test\com\rsheyeah\gwt\client\UITester.java
Created file C:\gwt-windows-1.5.2\UITester-hosted.launch
Created file C:\gwt-windows-1.5.2\UITester-web.launch
Created file C:\gwt-windows-1.5.2\UITester-hosted.cmd
Created file C:\gwt-windows-1.5.2\UITester-web.cmd

Hence, it is recommended to use GWT JUnit for non-UI based tests, such as logic and functionality tests which may or may not require client and server asynchronous communication.

Feel like smoothening your GWT Development...

2009-03-03T13:34:00.005Z

GWT Designer helps kick start your GWT development. GWT Designer™ is a GUI creator that supports GWT. Use GWT Designer's visual tools and wizards, and Java code will be generated for you. You don't need to write any lines of Java code, but you can fully edit the resulting Java if you wish.
Below are the list of features cited -
"GWT Designer™ from Instantiations is powerful, easy-to-use, and bi-directional. With its WYSIWYG tools, you can easily:
- add controls using drag-and-drop.
- add event handlers to your controls.
- change various properties of controls using a property editor.
- change and refactor its generated code and see it immediately in the visual designer.
- reverse engineer code created by hand."

So, don't wait to try it out here. It comes with a 15 day trial period, which I believe is enough time frame to get you hooked.

Yow will soon find out its worth the effort. Just download the 90 MB installer and point it to your favorite eclipse installation directory. And you are all set.

Wannabe iPhone App Developer...

2009-03-03T06:13:00.002Z

Have fun exploring the following sites -

The KamiCrazy development blog
The official iPhone development site
Idevgames - a developers site
Iphonedevsdk - a community development forum
Mobile Orchard - information and useful blog posts
148apps - an app review site

What is with GWT, AWT and SWING ?

2009-03-01T17:42:00.006Z

So you have experienced Panels, Widgets and Event Listeners in AWT and Swing. And found the concept is pretty much similar in GWT as well. The differrence comes with the intent - Think of GWT and think of Javascript and HTML as Assembly language and GWT as a sort of High level language which generates Javascript and HTML.

Moreover, AWT/Swing are used for desktop Java apps or applets and both require JVM to run as opposed to GWT that is targeted for building web apps that run on browsers and are look-alike of desktop apps

Ever wondered how to script "Closures" in JS ?

2009-02-27T18:47:00.003Z

Anonymous / Inner Classes in Java are quite famous, with event handlers. Closures in JS are similar, not quite the same.
Closures are expressions, usually functions, which can work with variables set within a certain context. Or, to try and make it easier, inner functions referring to local variables of its outer function create closures.

Read it here as explained quite nicely by Morris Johns.

Classy JS => Prototypes

2009-02-27T18:42:00.004Z

An excellent read about how to make an otherwise class-less java script emulate classes.
Read it here.

-Thanks Morris

Android - Cheezy name

2009-02-24T20:05:00.004Z

Wow !!! this is truly a cheezy technological innovation by folks at Google and little known "Open Alliance" group.
Read more about it here or Watch it here.

Ajax Men with TOOLS

2009-02-23T20:59:00.007Z

GWT is headed by Bruce Johnson.
JQuery by John Resig.
Prototype by Sam Stephenson.
Script.aculo.us by Thomas Fuchs
Ajax by James Garret of Adaptive Path.
Dojo by Alex Russel

GWT 101

2009-02-23T20:08:00.000Z

What is GWT?
A set of tools to write AJAX applications in JAVA.
GWT is an open source, cross-browser framework that allows developers to write AJAX applications in Java and get the bytecode compiled into JavaScript.

What makes GWT interesting is Java to JavaScript compiler?
GWT is more than just a Java-JavaScript Compiler.
Based on the code that you write in Java, it performs dead code elimination, code optimization etc straightening polymorphic calls, method call in lining and string interning. basically the features of what a "compiler" does.

Well why Java ?
Because Java is a strongly typed language unlike python and that is when you get benefit of the compiler optimizations. But then again Java is the chosen one, because of the availability of IDE's, debugging tools etc and not that its the only best language in the world. Google didn't choose Java because of a particular attachment to the language, but because of the abundance of tools out there available for Java. According to Rasmussen the final code you end up with will be faster and smaller than what you would write yourself.

GWT enables software development capabilities with AJAX. These are some of its advantages:
>>Java IDEs -- you can use any Java IDE or Notepad if you prefer
>>Quick editing, testing, debugging and refactor cycle -- the browser lets you debug code at Java level. You start your hosted browser in debug mode, edit your Java code, refresh your browser and you will see the changes straight away.
>>Unit testing -- GWTTestCase class is provided so that it can be integrated with JUnit
>>Reuse through jars -- Modules or jar files of one application can be referenced from another
>>Make the most of Object Oriented design principles
>>Javadoc -- GWT API documentation
>>Compile time errors -- With Eclipse the errors are fixed as you are typing code.

How to build the UI in GWT?
GWT preserves the principles of Web usability by: providing regular UI elements; enabling keyboard-only use and font size preferences; allowing the user to be in control of the browser; facilitating a fast start-up; and, allowing the user to feel like they are using a standard Web app, but with an enhanced experience.

The User Interface is created using a GWT widget library. The widgets got to be added to the panels. And its very similar to Swings. It follows the observer pattern to handle events. Widgets publish events which can be subscribed to, when the event occurs all the subscribers will be notified.

How to GWT applications talk to the server?
GWT RPC makes it easy for the client and server to pass Java objects back and forth over HTTP. When used properly, RPCs give you the opportunity to move all of your UI logic to the client, resulting in greatly improved performance, reduced bandwidth, reduced web server load, and a pleasantly fluid user experience

"Don't Click the Back Button"- The History
GWT's history API provides a means for you to access the browser's history stack and control what happens when the back or reload button is clicked. This way, even if you click the back button you can still return to the same state of the app.

Some aspects of the API are: the historyToken parameter is the current history state so each item in the history stack is called a token; HistoryListener is triggered when the back or forward button is clicked, you would implement this to get notified when there is a change to the browser history; you can create new history items on the stack -- for instance, History.newItem(token); hyperlink class provides a link to a different state of the app where it creates a new history item without reloading the page.

Internationalization
GWT provides a way for you to internationalize your applications and libraries. With the I18N package you can translate your apps into other languages.

To create localised messages, you need to implement the Messages interface and then add the corresponding localised properties files. .properties files store the translated strings.

Controlling the look of widgets with CSS

With GWT you can control the look of your widgets using CSS and keep the code and presentation separate. Every widget has a style name which is associated with a CSS rule.

To change the font size of all your buttons, as demonstrated here, you would do the following:

.gwt-Button { font-size: 150%; }

Optimised Permutations

GWT compiler constructs multiple compilations based on all possible permutations and records them in a file -- suffix.cache.html

The end-user only downloads one optimized compilation for their particular circumstances. For instance, a compilation for Firefox 3 and UK English. The performance is optimised, because the user is downloading only what is relevant to them.

JavaScript Native Interface (JSNI)

JSNI allows you to incorporate JavaScript into your Java code with the use of the native keyword. The JavaScript code in JSNI methods is encapsulated inside a comment block. It starts with /*-{ and ends with }-*/ and is inserted between the parameter list and the ending semicolon.

What's new in GWT 1.5?

Some of the features in the release candidate for 1.5 are:

Java 5 support (enums, annotations, autoboxing etc)
An improved compiler to make apps faster
Additions to the UI library such as widget animations
DOM API -- to make DOM development easier
Improvements to internationalization
Accessibility Support
Improvements to JRE Emulation Library

Exceptions - To check or uncheck

2009-02-23T19:38:00.000Z

To decide whether to throw a checked exception or an unchecked runtime exception, you must look at the abnormal condition you are signalling. If you are throwing an exception to indicate an improper use of your class, you are signalling a software bug. The class of exception you throw probably should descend from RuntimeException, which will make it UNCHECKED.
Otherwise, if you are throwing an exception to indicate not a software bug but an abnormal condition that client programmers should deal with every time they use your method, your exception should be CHECKED.

The Moody Thread States

2009-02-23T18:50:00.000Z

Understanding the moods of threads is critical to programming with threads.

1. New state – After the creations of Thread instance the thread is in this state but before the start() method invocation. At this point, the thread is considered not alive.

2. Runnable (Ready-to-run) state – A thread start its life from Runnable state. A thread first enters runnable state after the invoking of start() method but a thread can return to this state after either running, waiting, sleeping or coming back from blocked state also. On this state a thread is waiting for a turn on the processor.

3. Running state – A thread is in running state that means the thread is currently executing. There are several ways to enter in Runnable state but there is only one way to enter in Running state: the scheduler select a thread from runnable pool.

4. Dead state – A thread can be considered dead when its run() method completes. If any thread comes on this state that means it cannot ever run again.

5. Blocked - A thread can enter in this state because of waiting the resources that are hold by another thread.

A running thread can enter to any non-runnable state, depending on the circumstances. A thread cannot enter directly to the running state from non-runnable state, firstly it goes to runnable state. Now lets understand the some non-runnable states which may be occur handling the multithreads.

1.Sleeping – On this state, the thread is still alive but it is not runnable, it might be return to runnable state later, if a particular event occurs. On this state a thread sleeps for a specified amount of time. You can use the method sleep( ) to stop the running state of a thread.

static void sleep(long millisecond) throws InterruptedException

2.Waiting for Notification – A thread waits for notification from another thread. The thread sends back to runnable state after sending notification from another thread.

final void wait(long timeout) throws InterruptedException
final void wait(long timeout, int nanos) throws InterruptedException
final void wait() throws InterruptedException

3.Blocked on I/O – The thread waits for completion of blocking operation. A thread can enter on this state because of waiting I/O resource. In that case the thread sends back to runnable state after availability of resources.

4.Blocked for joint completion – The thread can come on this state because of waiting the completion of another thread.

5.Blocked for lock acquisition – The thread can come on this state because of waiting to acquire the lock of an object.

The Cache in Hibernate!

2009-02-23T18:08:00.000Z

Hibernate has two kinds of cache, which are the first-level cache and the second-level cache. The first-level cache aka "session cache", and the second-level cache aka "process-level cache".

The first-level cache is mandatory and can’t be turned off; However, the second-level cache in Hibernate is optional. Because the process-level cache caches objects across sessions and has process or cluster scope, in some situation, turning on the process-level cache can improve the performance of the application. In fact, before accessing the database to load an object, Hibernate will first look in the Session cache and then in the process-level cache.

The process-level cache is best used to store objects that change relatively infrequently, and it is set up in two steps. First, you have to decide which concurrency strategy to use. After that, you configure cache expiration and physical cache attribtes using the cache provider.

Hibernate supports a variety of caching strategies including:

read-only : which is suitable for objects which never changes. Use if for reference data only.
read-write : which is suitable for objects that are modified by the application.

To cache these classes in the process-level cache, we must use the <cache> element in the O/R mapping.

iBATIS, Hibernate, and JPA - Which one ?

2009-02-23T17:47:00.000Z

iBATIS, Hibernate, and JPA are three different mechanisms for persisting data in a relational database, each one with its own advantages and limitations.

Before we delve into which one - lets think back on our criteria of choosing. Is it that you require complete control over SQL for your application, do you need to auto-generate SQL, or just want an easy-to-program complete ORM solution.

iBATIS does not provide a complete ORM solution, and does not provide any direct mapping of objects and relational models. However, iBATIS provides you with complete control over queries.
Hibernate provides a complete ORM solution, but offers you no control over the queries. Hibernate is very popular and a large and active community provides support for new users.

JPA also provides a complete ORM solution, and provides support for object-oriented programming features like inheritance and polymorphism, but its performance depends on the persistence provider.

A much more detailed analysis is always most welcome.

Best Lyrics and Best Original Score

2009-02-23T09:53:00.000Z

Truly, Not only A.R Rahman's moment to cherish - In a time when copy, paste has become the default tool, almost second habit, we have to remind ourselves that it is innovation which drives passion - to excel and always originality is lauded.

Remarkable Stories on Technologies I have experienced...

2009-02-23T09:09:00.000Z

From the beginning of days I started delving into application development, I always felt there is always an alternative. An alternative to paths that ultimately leads to an end ie. "The End Product". What it means to be adopting Java or .NET, what it means to be adopting DOJO or YUI. I have a lot of experiences to share along the lines of "Why a certain technology has been adopted looking at the specifics for the project at hand"... So stay tuned...

R-She-Yeah decides to BLOG

2007-08-22T14:21:00.000+01:00

Is blogging healthy? Its a great way to express your thoughts, whatever they may be... Mostly, you will find technical discussions on various "new trends and technologies" that are born and have a huge impact in our (coder's) lives.