Tip: Eclipse plugins error - prerequisite build errors

I've faced this issue many times with eclipse.

Even though we have all the plugins and their dependencies defined correctly, still eclipse shows the errors by saying the prerequisite has to be build first.

It's frustrating since I have not made any changes in the project from the last time.

Okay, so the solution for this is:

1. Identify the root prerequisite plugin which eclipse is complaining about.
2. Close that root plugin
3. Re-open it
4. Do clean build for all projects

How to get your colleague Pull request into your system for testing

For my own reference:

http://stackoverflow.com/questions/5884784/how-to-pull-remote-branch-from-somebody-elses-repo

Example:

git remote add coworker https://github.com/coworker/titanium_studio.git

git fetch coworker

git checkout --track coworker/TIMOB-23628

If your co-worker has made some more changes, then you pull the latest changes in the below way.

git checkout TIMOB-23628

git pull

To push it back to your colleague branch
git puh coworker TIMOB-23628

https://help.github.com/articles/checking-out-pull-requests-locally/

http://stackoverflow.com/questions/22984262/cannot-update-paths-and-switch-to-branch-at-the-same-time

Another way would be

To fetch a remote PR into your local repo,

git fetch origin pull/ID/head:BRANCHNAME

where ID is the pull request id and BRANCHNAME is the name of the new branch that you want to create. Once you have created the branch, then simply

git checkout BRANCHNAME

Reference: https://stackoverflow.com/questions/27567846/how-can-i-check-out-a-github-pull-request-with-git

Best Practice: Never ever execute long running operations in the Display.asyncExec() also

//The thread which calls this method is suspended until the runnable completes.

Display.getDefault().syncExec(new Runnable()

{

public void run()

{

//Do only UI operation

}

});

//The caller of this method continues to run in parallel

Display.getDefault().asyncExec(new Runnable()

{

public void run()

{

//Do only UI operation

}

});

I've seen most of the people will misuse Display.getDefault().asyncExec() by thinking that it will not impact the application performance. But the important thing to remember here is, SWT is a single threaded model - Yes, it's a single-threaded UI model. Any UI operation which you do, will happen through Display main thread. 

Example:

Display.getDefault().asyncExec(new Runnable()

{

public void run()

{

   //step 1: network connection involvement

                               

   //step 2: UI code to execute - example: opening a browser

}

});

From above, it has non-UI and UI code. If accessing the network takes time, UI thread will be blocked for a long time so that no other thread can able to get an access to execute other UI code.

That means, at any point of time - only one UI thread will be there i.e, Display thread.

To resolve this kind of things, we need to use jobs and invoke only necessary code in the UI thread.

new Job("Browser opening job...")

{

@Override

protected IStatus run(IProgressMonitor monitor)

{

//step 1: network connection involvement

Display.getDefault().asyncExec(new Runnable()

{

public void run()

{

 //step 2: UI code to execute - example: opening a browser                  

         

}

});

return Status.OK_STATUS;

}

}.schedule();

Best Practice: Always check for Control disposed in Display.asyncExec()

Display.getDefault().asyncExec(new Runnable()

{

public void run()

{

//Always check for whether the control is disposed.

if (!progressComposite.isDisposed())

{

//perform UI operation.

}

}

});

Reason being, when we say asyncExec thread - it will execute on the next reasonable opportunity. But by that time the control would have been disposed.

HttpURLConnection setConnectTimeout issues

HttpURLConnection connection = (HttpURLConnection) url.openConnection();

// Give it a 4 seconds delay before deciding that it's a dead connection

connection.setConnectTimeout(10000);

connection.setRequestMethod("HEAD"); // Don't ask for content

connection.setAllowUserInteraction(false);

connection.connect(); 

Problem here is, application can hung for more than 10 sec even after configuring the timeout for connection.

How that can happen?

connection.setConnectTimeout() is only for configuring timeout to accept the connection, but after accepting the request server might take a long time to respond to you due to various issues at the server end. 

As per the doc - “timeout for opening a communications link to the resource referenced by this URLConnection”.

This kind of things will lead to application hung if you’re waiting for the response.

To resolve this - we should also set the connection.setReadTimeout(5000). 

As per doc - “timeout when reading from Input stream when a connection is established to a resource.”

How to set default language for eclipse or for your RCP product

Before you launch an eclipse, configure  -Duser.language=en property in eclipse.ini file.

In the context of mac os.

Example:

1. Go to /Applications/Eclipse/eclipse.app/Contents/MacOS/
2. Open eclispe.ini file
3. Append -Duser.language=en to the end of the file
4. Restart eclipse

In windows, you can find eclipse.ini file in the eclipse root directory.

SWT - Single UI threaded model

http://www.pcdoctor-community.com/wp/posts/2007/07/swt-and-threads/

The backbone of any UI toolkits are threads. The most basic aspect of UI toolkits is to provide a nice event driven architecture, as events are the most integral part of any UI.

The underlying operating system maintains a queue of application events and if that event is long running and is blocked it will freeze your UI.

In SWT when a user presses a mouse a mouse pressed event is generated. Determining which window is supposed to receive the event and placing it in an event queue is done by the underlying OS.

SWT has a single UI thread which creates the display and from which all other widgets are created. When writing a SWT app the most common piece of code existing in all programs is

while (!shell.isDisposed())

{

if (!display.readAndDispatch())

display.sleep();

}

display in SWT is the class which interacts with the underlying operating system. In the above code readAndDispatch() is the call which reads events from the event queue and dispatches them to the correct place.

Since there is only one UI thread, if we try and process events in the same thread the UI will freeze. This is where threads come to our rescue. But again when working with UI’s the most tricky and dangerous thing to do would be access UI components from non UI threads. If you spawn a new thread and try to update UI components from that non UI thread you will be in for a bummer. When your UI toolkit is SWT, it will nicely point out to you your chivalry and throw an SWTException.