The Coder Lounge

Weird code pattern in Eclipse SDK

2012-01-26T09:47:00.000-08:00

In recent Juno milestones JDT has added several new static analysis capabilities - resource leak detection (Juno M3), annotation based null analysis (Juno M4), null analysis for fields (Juno M5). This week I have been testing these new features on the entire Eclipse SDK source code.

While there are quite a few 'gems', the following code pattern occurs quite frequently. If the object can be null at the first if condition, how is it magically guaranteed to be non-null at the second if statement? :-)

As Stephan mentioned in his blog today - Help the JDT Compiler helping you. Please start using the new static analysis options and report any issues you find. In the process you will certainly make improvements to your code as well.

Active JDT Committers

2011-12-19T11:29:00.000-08:00

In my talks on JDT I generally include a slide with the above image. I thought I should also write a post and include the following bits of (interesting) information about the committers.

JDT committers are spread over 3 continents, 4 countries and 5 cities.
More than half (6 out of 11) of active committers are based out of Bangalore, India.
Dani and Olivier have been there since the very beginning of Eclipse, and Markus has been a JDT committer since 2003.
Srikanth has been working on compilers and related technology forever.
In all eight to nine languages can be spoken in the team. Even the commiters in Bangalore speak many different languages, for instance I can communicate in my mother tongue, Hindi, only with Ayush. Hence, we pretty much communicate in English :-)
Unfortunately the team is dominated by men with Raksha being the only member of the fairer sex.
Ayush at 24 is the youngest committer in the team and I come a close second at 25.

Annotation based null analysis with JDT

2011-12-06T09:14:00.001-08:00

Eclipse Juno M4 includes support for annotation based null analysis. To take advantage of the feature enable the preference shown below and start using the default annotations mentioned in the text fields.

You will also notice that all the null analysis related options have moved to a new group on the preference page.

As usual feedback is extremely welcome especially in form of bug reports :-)

UPDATE: JDT provides default annotations which are shipped in org.eclipse.jdt.annotation bundle with the Eclipse SDK. However you are free to use your own annotation types, just specify the custom annotations in the preferences.

CodingSpectator: Research study on Eclipse

2011-12-03T11:33:00.001-08:00

These guys have been contributing to JDT by reporting a bunch of bugs based on their findings, so I thought I should talk about them :)

The aim of CodingSpectator project is to study how developers interact with the Eclipse IDE, by collecting and analyzing usage data. CodingSpectator has been developed at Ralph Johnson’s research group by the following graduate students: Mohsen Vakilian, Nicholas Chen, Stas Negara, Roshanak Zilouchian and Balaji Ambresh. Ralph is a co-author of the seminal book on design patterns (GoF) and his research group has a history of important contributions to IDEs. CodingSpectator monitors programming interactions non-intrusively in the background and periodically uploads it to a secure server at UIUC.

They have presented some of their findings in this technical report - Use, Disuse, and Misuse of Automated Refactorings. Based on the same report they have reported a number of insightful bugs against JDT and also provided suggestions on how some of the refactorings can be improved. A few bugs have already been fixed. In addition their technical report also improved my understanding of an average JDT user's behavior. Thanks guys!

Probably the biggest challenge with a usage study is finding a good number of participants. They are looking for more participants in order to continue their research study. If you’re interested in helping the researchers out, you could install CodingSpectator.

Detecting resource leaks with Eclipse JDT

2011-10-03T02:46:00.000-07:00

You can now detect resource leaks with Eclipse JDT. The following 3 warnings have been added, and the defaults are as shown (this feature is available in I-Builds starting Oct 4 )

For the purpose of this analysis, a resource is a local variable of type java.io.Closeable in pre-Java 7 world and in Java 7 world a resource is a local variable of type java.lang.AutoCloseable. (Note that in Java 7 java.io.Closeable extends java.lang.AutoCloseable)

To take a few examples

if close() is never called on the resource a 'Resource is never closed' warning is emitted

if close() is called but not on all code paths, the warning indicates the locations where the resource is not closed

if a locally created resource is passed to another method, then it cannot be ascertained what that method does with the resource, i.e. the method may or may not close the resource, e.g. in the snippet below a helper method is used to close a resource, however one may also create helper methods to perform other tasks. Hence, in these cases the warning is a 'Potential resource leak' and this warning is not enabled by default.

if a resource is correctly closed, and the compiler compliance is 1.7 then Eclipse suggests to use the new try-with-resource statement

Several other cases are also handled, e.g. a resource is returned from a method, a resource variable is reassigned etc. However, we may have missed something, hence bugs, suggestions and comments are welcome!

Most of the credit for this feature goes to Stephan Herrmann, in fact I often wonder how he gets time to contribute so much to JDT given that he has a day job and is also the lead of the Eclipse Object Teams Project. Thanks Stephan!

Java 7 Support in Eclipse 3.7.1, 3.8, 4.2 builds

2011-07-28T21:26:00.000-07:00

So far the Java 7 support work was done in the BETA_JAVA7 branch. This branch has now been merged to HEAD and R3_7_maintenance. As a result all upcoming 3.7.1, 3.8 and 4.2 builds will fully support Java 7 development.

Java 7 Support in Eclipse JDT (BETA) - Part III

2011-07-22T03:34:00.000-07:00

I have already talked about adding Java 7 support to your Eclipse 3.7 or 4.1 install. Last week I also talked about the new features in JDT for Multi-catch, try-with-resources and Simplified Varargs Method Invocation. Now I will talk about Improved Type Inference for Generic Instance Creation (Diamond).

This language change allows explicit type arguments to constructors of parameterized classes to be omitted in many situations. The compiler infers the omitted type arguments based on the expected type.

The JDT compiler detects redundant specification of type arguments, which you can remove via Remove type arguments quick fix.

This warning can be configured as shown below.

You can also insert inferred type arguments via a quick assist.

Where possible, Content assist inserts diamond instead of explicit type arguments.

Future items: We plan to show the inferred type arguments right in the constructor hover, see bug 351048. In 3.8 we also plan to provide Remove redundant type arguments as a cleanup, see bug 351956.

Note that the type inference done by the compiler can at times be non-obvious. For example, at first glance the following two methods might appear equivalent, when in fact the one with conditional operator has an error.

An analogous example from the pre-Java 7 world.

Java 7 Support in Eclipse JDT (BETA) - Part II

2011-07-14T08:37:00.000-07:00

I have already talked about the new features to support multi-catch in an earlier post. Now I will talk about Try-with-resources statement and Simplified Varargs Method Invocation.

The compiler detects unhandled exceptions thrown by automatic/implicit close() invocation on a resource.

With Mark Occurrences enabled, the closing '}' of a try-with-resources statement is marked as a method exit point if the implicit close() invocation throws an exception. The corresponding resource variable is also highlighted.

Future items: In 3.8 we plan to add warnings to indicate that a resource is not closed, see bug 349326. In Java 7 a resource is a subtype of java.lang.AutoCloseable and in the pre-Java 7 world a resource is a subtype of java.io.Closeable. Based on these warnings we will also provide quick fixes/assists and clean-ups to enclose a resource in a try-with-resources statement, see bug 349390.

A new quick fix Add @SafeVarargs is offered for potential heap pollution warnings on method declarations.

Add @SafeVarargs quick fix is also offered from call sites.

Remove @SafeVarargs quick fix is offered for incorrect usage of @SafeVarargs annotation.

Note: This is an implementation of an early-draft specification developed under the Java Community Process (JCP) and is made available for testing and evaluation purposes only. The code is not compatible with any specification of the JCP.

Java 7 Support in Eclipse JDT (BETA) - Part I

2011-07-14T07:00:00.000-07:00

JDT team has been working overtime over the last few months on the Java 7 support. The compiler is rock solid now and the UI is looking good with a number of new features. You can add the Java 7 support to your existing 3.7 or 4.1 install by following the instructions on http://wiki.eclipse.org/JDT/Eclipse_Java_7_Support_(BETA).

This post is the first in a series in which I will talk about the new features in JDT for Java 7. In this post I will focus on Multi-catch.

The new action Source > Surround With > Try/multi-catch Block allows you to surround the selected statements with a try/multi-catch block. This is also available as Surround with try/multi-catch quick fix in case there are multiple uncaught exceptions.

The new Add exceptions to existing catch clause quick fix allows you to add uncaught exceptions to an existing catch clause.

You can replace a multi-catch clause with individual catch blocks via Use separate catch blocks quick assist. The quick assist will create separate catch clauses for all the exceptions.

You can also pick out one or more selected exceptions from a multi-catch clause via Move exceptions to separate catch block.

The new Combine catch blocks quick assist allows you to combine separate catch blocks into a single multi-catch block, pretty useful for migrating existing code to Java 7. The quick assist is offered only when bodies of all the catch blocks are same, we still need to make it a little more smarter, see bug 350308. In 3.8 we will also provide this as a clean-up (bug 351179).

The compiler gives an error if an exception in a multi-catch clause is already caught by an alternative exception. The new Remove exception quick fix allows you to remove this exception.

Mark Occurrences has been updated to understand the multi-catch syntax.

There are also new Line Wrapping options in the Formatter for the multi-catch syntax.

Note: This is an implementation of an early-draft specification developed under the Java Community Process (JCP) and is made available for testing and evaluation purposes only. The code is not compatible with any specification of the JCP.

JazzHub

2011-07-09T06:30:00.000-07:00

JazzHub is a free, public, hosting hub for the open development of academic research and classroom projects. Currently it is in limited beta. To participate in the beta you can request a project creation code.

On JazzHub students and professors can plan projects, collaborate on source code, and track progress, all with the latest Jazz technology in Rational Team Concert.

Source code management
Work Item Tracking
Project and personal dashboards
Agile planning
Reporting
Web, Eclipse and Visual Studio interfaces

Rational Team Concert (RTC) is also available FREE of charge for qualified open source projects, academic institutions, and research projects. Steps to help you get started are available here. You can also read about RSSOwl's adoption of RTC, this also includes a great video which illustrates how the developers can benefit from RTC.

You can learn more about JazzHub at Innovate 2011, Bangalore. If you're a student, you can also win free passes to Innovate by blogging or tweeting about rational products (use hashtag #innovateindia).

Java 7 Support in Eclipse JDT (BETA)

2011-06-23T20:34:00.000-07:00

Java 7 is not publicly released yet and hence the Eclipse Java 7 support could not be shipped with 3.7 or 4.1. However those who want to use it in 3.7 or 4.1 can do it using the install instructions mentioned on http://wiki.eclipse.org/JDT/Eclipse_Java_7_Support_(BETA).

If you find a bug or have ideas on new quick fixes / refactorings / templates / ... , please file a bug with the [1.7] tag !

I should add that this is a work in progress, and more details are available on the following two wiki pages

JDT Tip: See different hovers in Java editor by using modifier keys

2011-06-05T09:27:00.000-07:00

When you move the mouse over an identifier that has no error or warning, by default a hover with the Javadoc is shown.

However if there is an error or a warning on the identifier then the corresponding message is shown.

To see the Javadoc even in this case, you can enable the Javadoc hover on this preference page and define a key modifier e.g. Ctrl+Shift.

Now press Ctrl+Shift while hovering to see the javadoc.

JDT Tip: Mark Occurrences in Java editor

2011-06-02T23:27:00.000-07:00

I think everyone knows that the Java editor highlights occurrences of variables and method calls.

But did you know that it also highlights

Method exit points - select (or place caret in) the method return type

Method calls or statements throwing an exception - select (or place caret in) an exception in a catch block

Break/Continue targets - select (or place caret in) break or continue keywords

Mobile sessions at IBM Innovate

2011-06-02T22:08:00.000-07:00

Attending Innovate 2011 ? Interested in mobile development ? If yes, then the following sessions might be of interest to you.

Mon, Jun 6, 2011
4:15 PM : ALM-1602A Bringing Collaborative Lifecycle Development to Mobile Software
8:00 PM : BOF-2303A How is the Need for Developing Mobile Applications Changing Development Efforts

Tue, Jun 7, 2011
1:45 PM : CS-1359B Agile Adoption for Android Mobile Project using IBM Rational Team Concert - Samsung SDS Agile Transition

Wed, Jun 8, 2011
11:15 AM : SE-2206A Mobile Application Development: Strategies for Accelerated Delivery and Deployment
1:45 PM : MAC-1756A Web 2.0 and Mobile Development Fast and Easy with IBM Rational Application Developer 8.0
3:00 PM : PPM-1300A Importance of Understanding User Needs in Mobile Development
3:00 PM : SIS-1609A Model-Driven Development for Mobile Applications

In addition there are also some demo pedestals in the Solution Center.

Eclipse Day India 2011

2011-05-10T06:12:00.000-07:00

Anshu Jain started of the day with an excellent talk Eclipse - A Framework of Frameworks. In his talk he went through the design of a very simple calculator framework to explain all the things that Eclipse does - extensions, dynamic loading, plugin discovery etc. There was also a .cff file (calculator framework format) equivalent to plugin.xml in Eclipse. The example code from his talk is available at his site - highly recommended for someone starting of with plug-in development.

Ankur followed up with another great talk Good Practices for Plug-in Developers. Some of the images he used to drive his point home were really funny and awesome. I thought my session JDT Bootcamp (JDT Tips and Tricks, and Extending JDT) went well, of course the fact that Satyam did a fantastic job of explaining the Java Model and the Search APIs helped a great deal.

There was a lot of interest in What's new in Java 7 talk by Ayush (the guy with the funny pose in the above pic), which was nice to see. After this Praveen talked about his experience at Adobe with migrating a Eclipse 3.x application to Eclipse 4.x platform. It was nice to hear that Adobe wants to stay on the latest Eclipse platform and has made considerable progress in this regard.

The day ended with an interesting talk about Eclipse UOMo project. Werner Keil gave a few funny examples on what can go wrong if the proper care is not taken in consistently interpreting the units, for e.g. if one team uses inches and feet and the another team interprets the values as meters and centimeters. The image of an upside down NASA shuttle because someone messed up the measurement units will always stay in my mind :)

Lastly a big thank you to SAP Laps for hosting the event! You have been a great host for Eclipse Day India 2011 and the demo camp in Nov 2010. However I would like to see the next Eclipse event in Bangalore hosted at a different venue - just for variety :) Maybe other organizations can step forward.

I almost forgot, the 'discussion' over drinks in the evening with fellow Eclipse committers and Eclipse users was 'entertaining' ;-) Those who could not join us for drinks, please do next time.

Eclipse JDT and Java 7

2011-05-02T07:48:00.000-07:00

Will Eclipse 3.7 include support for Java 7?
Short answer: No
Slightly longer answer: "Due to late availability of JSR-292 (Invoke Dynamic) and JSR-334 (Project Coin) and due to the official release date (July 28, 2011) of Java 7 being after 3.7 ships we had to defer the Java 7 support to 3.7.1. It has not yet been decided whether this will be available as part of the 3.7.1 downloads or as separate feature update.

The work for the Java 7 features is currently in progress in the 'BETA_JAVA7' branch and we will deliver separate updates for the stable builds in order to provide early access to the Java 7 features for interested parties."
See bug 288548.

What is the current status of support for Java 7 in JDT ?
Take a look at the wiki page: http://wiki.eclipse.org/JDT_Core/Java7

I want to try some of the new features of Java 7 in Eclipse
At this point in time you will need to

Create a new CVS repository location to:

:pserver:anonymous@dev.eclipse.org:/cvsroot/eclipse

Check out the following projects from BETA_JAVA7 branch:

org.eclipse.jdt.core
org.eclipse.jdt.ui

Launch another eclipse application from this workspace or export the two plugins into the host eclipse.
Of course you will also need to install a JDK7 build as an installed JRE.

Debugging Eclipse builders

2011-04-28T21:17:00.000-07:00

Do you think Eclipse builds too often ? Do you think Eclipse build too much ? At least I do, or maybe I just got tired of seeing 'Building workspace: (12%)' in the status bar. Anyway I decided to see for myself what the heck the builders were doing.

I use JDT and PDE which means there are two builders of interest

Java Builder
API Analysis Builder

There are also Plug-in Manifest Builder and Extension Point Schema Builder, but I think these two do not do much and hence do not take much time.

To know what these two builders are doing in your running Eclipse instance two things are required

Start Eclipse with -debug option, to me more precise I used the following to redirect the debug output to a file as the debug output can grow large very soon and overflow the console buffer

eclipsec –debug > log.txt

Enable debug options for three plug-ins (details below)

org.eclipse.core.resources
org.eclipse.jdt.core
org.eclipse.pde.api.tools

All three plug-ins ship a .options file containing all the debug options provided by these plug-ins, just open the the corresponding jars in your eclipse installation to get the .options files. Create a single .options file from these and place it in the same directory as eclipsec.exe before starting eclipse.

I had the following options set to true in my .options file
###################################################################
# Turn on debug tracing for org.eclipse.jdt.core plugin
org.eclipse.jdt.core/debug=true

# Reports java builder activity : nature of build, built state reading, indictment process
org.eclipse.jdt.core/debug/builder=true

# Reports java builder stats
org.eclipse.jdt.core/debug/builder/stats=true

###################################################################
# Debugging options for the org.eclipse.core.resources plugin.

# Turn on debugging for the org.eclipse.core.resources plugin.
org.eclipse.core.resources/debug=true

# Reports the start and end of all builder invocations
org.eclipse.core.resources/build/invoking=true

# Reports the start and end of build delta calculations
org.eclipse.core.resources/build/delta=true

# For incremental builds, displays which builder is being run
# and because of changes in which project.
org.eclipse.core.resources/build/needbuild=true

# Prints a stack trace every time an operation finishes that requires a build
org.eclipse.core.resources/build/needbuildstack=true

###################################################################
# Turn on debug tracing for org.eclipse.pde.api.tools plugin
org.eclipse.pde.api.tools/debug=true

# Reports incremental builder activity : nature of build, indictment process,...
org.eclipse.pde.api.tools/debug/builder=true

# Print notified compatibility deltas
org.eclipse.pde.api.tools/debug/delta=true

# for the tag scanner
org.eclipse.pde.api.tools/debug/tagscanner=true

# for API profile
org.eclipse.pde.api.tools/debug/apiprofile=true

#for api analyzer
org.eclipse.pde.api.tools/debug/apianalyzer=true

#for our workspace delta processor
org.eclipse.pde.api.tools/debug/workspacedeltaprocessor=true
###################################################################

So far I have found a few scenarios where the builders could do less work - Bug 344090, Bug 344110, Bug 344163, Bug 344137. I think there are more issues, but getting a reproducible test case is proving to be a little hard in some cases.

JDT at Eclipse Day India

2011-04-28T20:27:00.000-07:00

Satyam and I will be speaking at Eclipse Day India 2011 in Bangalore next week. We have one session JDT Bootcamp. This session consists of two parts.

JDT - Tips and Tricks (30 min) - In the first 30 mins we will show off useful tips and tricks when working with JDT and Eclipse in general such as tricks in content assist, Java Editor tips, code navigation and debugging aids.

Extending JDT (60 min) - In the next one hour, we will take you through APIs and extension points that JDT exposes to enable you to extend and customize the Java tooling. Using these APIs, one could create their own cleaunps, refactorings, quick fixes and other utilities.

You may also be interested in Ayush's talk What's new in Java 7 (30 min). This talk intends to describe new features of Java 7 such as switch on strings, binary integral literals and underscores in numeric literals, multi-catch and precise rethrow, diamond, try with resources, etc. The talk will also be interesting to those who want to know the status of Java 7 work in Eclipse compiler.

The three of us will be around the whole day, and would love to answer any questions or get into interesting discussions around JDT :)

See you at Eclipse Day!

Evaluating expressions in JDT Debugger

2011-04-25T03:59:00.000-07:00

You can use the Display View to type in an expression and evaluate it in the context of the current stack frame. (The name Display is not great - see bug 342144).

- Use content assist to type expressions

- Select the expression and use Ctrl+Shift+I (Inspect) to show the result in a pop-up. You can also invoke the Inspect command from the context menu.

- Press Ctrl+Shift+I again to persist the result in the Expressions view.

See also Eclipse help.

JDT at EclipseCon 2011

2011-03-08T06:38:00.000-08:00

Raksha Vasisht and I will be speaking at EclipseCon 2011 in Santa Clara. We have the following 2 talks

What's new in JDT
Monday, March 21 14:00 - 14:20, Stevens Creek

JDT - Tips and Tricks
Tuesday, March 22 14:00 - 14:20, Stevens Creek

We are also organizing a Bof
Eclipse - Tips and Tricks
Wednesday, March 23 19:30, Sonoma

See you soon at EclipseCon !

JDT 3.7 M5 - New and Noteworthy

2011-02-06T19:58:00.000-08:00

This time there are a bunch of interesting items in the debug area

There is now a history for recently used breakpoint conditions:

The global history shows the saved conditions across all conditional breakpoints, while the local history shows the history of one particular breakpoint.

In the Java editor, if you delete a breakpoint that has a condition set on it, you will now be prompted before the breakpoint gets deleted:

You can specify that you would not like to be notified again when trying to remove a conditional breakpoint. This can later be changed again via Prompt for confirmation when deleting a conditional breakpoint from editor on the Java > Debug preference page.

If you accidentally removed a breakpoint from the editor's vertical ruler or the Breakpoints view, you can now get it back using the standard undo functionality - Edit > Undo Delete Breakpoint (Ctrl+Z) - in the Breakpoints view or any other view that works against the global undo history.

The Add missing case statements quick assist is now available in the body of the switch statement:

The Quick Outline shows inherited members of top-level types when Ctrl+O is pressed twice. Now, it also shows inherited members of the type that contains the current editor selection:

The focus types that can show inherited members are marked with a triangle.

Two new compiler options have been added that mark methods which can be made static because they only refer to static members.

The first option marks private and final methods than can always be made static. The second option also marks other methods. Note that methods can be overridden in a subclass, so if you make a "potentially static" method static, this may break existing clients. These options are disabled by default.

Another interesting feature in the SDK is detached editors. This can be really useful in a dual monitor setup.

Though while trying this out I 'lost' a couple of editors before filing Bug 336391

JDT 3.7 M4 - New and Noteworthy

2010-12-13T01:27:00.000-08:00

This time there are a bunch of interesting items in the quick assist (Ctrl+1) area

The Introduce new local with cast type quick assist is now not only available on the instanceof keyword, but also in the body of the conditional statement (before the first body statement).

The Join variable declaration quick assist is now also available for variables initialized to null.

The Exchange left and right operands for infix expression quick assist is now also available for the !=, <, <=, >, and >= operators.

The properties file editor now offers two new quick assists to escape or unescape backslashes.

The Escape backslashes quick assist is also offered automatically on paste if the pasted text contains backslashes that should be escaped. The next step is to provide a similar feature in the Java Editor, see Bug 332205.

Couple of irritating bugs that got fixed

Bug 327079 [JUnit] Can't run single test with JUnit 4 launcher if there's a suite() method
Bug 329677 [type hierarchy] view must honor package name abbreviation setting

e4 - Eclipse 4.x - Second Impression

2010-10-31T03:54:00.000-07:00

I have been using the latest builds of Eclipse 4.x SDK for my daily work for the last 6 weeks. The overall stability has improved gradually, and the NPEs are quite rare now. Some of the bugs I filed were also fixed quite quickly during M3 - Bug 325834 , Bug 327154. But there are still a few things which must work but don't.

Ability to customize a perspective (Bug 320478)
Ability to set or change key bindings (Bug 317299)
Plus I am a bit confused about the 'Editor Area' introduced in 4.1 M3. Does this mean I should not create multiple editor stacks? Should I create multiple editor stacks only in the editor area? Will this editor area continue to take extra space as it does in M3? In 3.x we had a editor only area, are we going back towards that? M4 is supposed to have a more polished implementation of the 'Editor area', I will wait for that.

I am also hoping that Editor tab rendering could be improved significantly in Eclipse 4.x (Bug 325422).

e4 - Eclipse 4.0 : First Impression

2010-09-18T02:09:00.000-07:00

Looks a bit funny

Off is On and On is Off - I saw that Build Automatically was Off so I switched it On, and then my code changes had no effect... few minutes later I realized that if something is turned Off in the UI, it may mean that it is actually turned On! e.g.Mark Occurrences, Build Automatically. Or in the case of 'Edit > Smart Insert Mode' I cannot even toggle it.

Layout and minimized Views - I like the overall layout and the fact that I can put views in the editor area. I also like the way when minimized views are selected they open in a pop-up sort of a way. Overall the UI/layout feels nice.

Custom Key Bindings - mmh...

Order of menu and toolbar items - The ordering of items in menus and toolbars can be a bit different from 3.x versions. e.g. navigate menu, run/debug toolbar

I can use it for my daily work, except for some minor glitches and some funny behavior I have been able to use it for last few days. And I do like the layout, mixing of editors and views, and the overall feel of the UI to not go back to 3.x (at least for now).

New Command in JDT : Open from Clipboard

2010-09-06T19:02:00.000-07:00

This is what I used to end up doing very frequently
- copy something like String#getBytes from a bug comment
- press Ctrl+Shift+T in Eclipse
- paste the copied text Open Type dialog
- argh... no matches
- delete the method name
- open the type in an editor
- press Ctrl+O
- argh.. what was that method again?
- go back to bugzilla and read/copy the method name
- come back to Quick Outline and filter the method
- and finally reach the method

The new command opens a Java element or a Java stack trace from clipboard. If the clipboard content spans multiple lines then the it is pasted to the Java Stack Trace Console. If the clipboard content is a single line the command tries to open the matching Java element in an editor. Some examples

java.lang.String
String#getBytes
java.lang.String.getBytes(String, int[], int)
String.java:123
at java.lang.String.matches(String.java:1550)
java.lang.String.valueOf(char) line: 1456

I use this command with a key binding of Ctrl+Shift+V. After doing a Ctrl+C the most natural thing to do is Ctrl+V so the key binding for this command should be similar. Plus Ctrl+Shift+V is also similar to Ctrl+Shift+T and Ctrl+Shift+R, making it a bit easier for me to remember it.

This command (Bug 48880) is already in nightly builds and will be in the today's I-build.

As a final note I should also mention 2 'nasty' Platform bugs that I faced while implementing this command

Bug 324160: [Commands] Platform should support to use the action IDs from the action set contribution in menuContribution
Bug 324161: menu contributions added using 'endof' should appear before contributions added using 'after'

I say nasty because in its current form the whole menu contribution, command, actionSet, action story can be very confusing...

JDT 3.7 M1 - New and Noteworthy

2010-08-07T07:21:00.000-07:00

Filter preferences on Java > Compiler > Errors/Warnings page

We have just too many options on this preference page (as does PDE and API tooling on some of their preference pages) and finding the option you are looking for can be quite difficult (and frustrating) with all the twisties and so much of scrolling involved.

You can now filter preferences on the Java > Compiler > Errors/Warnings page by preference label text or by preference value. A word in the filter string preceded by '~' is used to filter on preference values. Examples:

param
~off
~ignore
param ~enabled
~ignore param

Bug 321818 is the next item to do - allow to filter a section for a value e.g. 'code style ~error.

New 'Open Hyperlink' command

The new Open Hyperlink command opens one or more hyperlinks at the current caret location. The command has been added to the Navigate menu for the Java and properties file editors and can also be used in other text editors by assigning a key binding on the General > Keys preference page.

The command opens the hyperlink directly if there's only one link available. Otherwise, it shows a chooser with all the available hyperlinks at that location. The links are the same as when you move the mouse with Ctrl pressed.

So now you can assign a key to this command (say F6) and then use this command in Properties files to navigate to NLS key references, in Java editor to navigate to declaration or implementation for a method,and declaration for other Java elements, or for any other hyperlinks.

In short you can possibly stop using Open Declaration (F3) and start using this new command - depending on whether or not you would like to always make a choice between navigating to declaration or navigating to implementation for method invocations :)

Other New and Noteworthy items.

CVS vs Git: Local disk usage

2010-08-01T05:52:00.000-07:00

I was a bit skeptical about the local disk usage with Git, as every Git clone is a full-fledged repository with complete history, and apparently Git stores entire snapshots and not the deltas.

Everyone seemed to be claiming that Git is quite efficient in terms of storage space required, and I also found the following statistic on the web
"The Mozilla CVS repository was 2.7GB, imported to Subversion it grew to 8.2GB. Under Git, it shrunk to 450MB. Given that a Mozilla checkout is around 350MB, its fairly nice to have the whole project history (from 1998) in only slightly more space."
Source: http://keithp.com/blog/Repository_Formats_Matter/

But I was still a bit skeptical... :)

So I downloaded some of the JDT source from Eclipse Git repositories and compared the disk usage under Git with CVS. Here are the numbers. For these selected projects, Git on an average takes less than three times the space required by CVS. In my opinion this cost is nothing as compared to the benefits of having the entire history locally.

Eclipse Helios

2010-07-31T07:51:00.000-07:00

Going through the Helios Reviews I see that a number of bloggers have said good things about the new features in JDT :)

If you have not yet seen the new features of JDT then check out the 10 minute demo I recorded last month. This video shows what's new in JDT for Eclipse 3.6, the Helios release.What's shown in the video is just a part of all the new stuff within JDT. For more information see the 'What's New' document in the Java development user guide.

My favorite features being

Java breakpoint detail - No more opening a new dialog for editing breakpoint properties, I just love this one.

Package name abbreviations - This is a simple but very useful improvement, makes the Package Explorer a lot less cluttered.

Remove nodes from Call Hierarchy - While this is useful now, it should become better once Bug 304135 (Allow to pin Call Hierarchy) gets fixed.

Fix multiple problems via problem hover - This saves a lot of effort.

Work on Eclipse Indigo is already in full swing with M1 coming up next week. Some nice features have been implemented in M1, bugs - 78522 , 277862 , 315772 , 320876 , 310470.

Too many options in Eclipse?

2010-07-01T13:51:00.000-07:00

At times I wonder if we have too many actions, key bindings, preferences etc in Eclipse. I mean a beginner would probably find number of key bindings in the Ctrl+Shift+L pop-up overwhelming. This pop-up lists a number of 'Show View' key bindings, but I think listing only Quick Access (Ctrl+3) should suffice - at least for beginners.

This raises another question - how many users of Eclipse are beginners, how many some what comfortable, how many expert. I would assume a significant number in each category. Maybe we should have beginner, intermediate, expert modes/perspectives. For example in the beginner mode we can hide (not disable) the actions and preferences which are typically used by power users.

Mac : Windows :: iOS : Android ?

2010-06-20T00:58:00.000-07:00

In the late 70s and the early 80s Apple computers were the coolest devices around and everyone wanted to have one, and then Windows came along firstly with IBM PCs and then with IBM PC clones, i.e. Windows worked on hardware sold by most manufactures.

Now in 2010, iPhone is the coolest device out there and everyone wants to have one, but Android has come along which works on hardware sold by a number of manufactures.

Is history repeating itself?

The Executive Dashboard 2010

2010-06-19T03:10:00.000-07:00

This is the Executive Dashboard as presented at IBM Rational Innovate 2010. This looks to be quite a bit more sophisticated than last year.

Printpoints : Debugging by writing to console

2010-06-02T10:31:00.000-07:00

There are two ways of debugging

Breakpoints - I typically use breakpoints when

I do not have much idea of the code and need to inspect variables and expressions at a number of places to gain an understanding of what is happening.
I am making some changes and want to see how these changes affect a particular variable/expression, also I am confident that one or two iterations of this change-test process will suffice

Printpoints - There are scenarios when the breakpoints fail or are inefficient, in these cases I just use System.out.println(). This is typically when

the breakpoint hits too often, for example keypress, focus, mouse events
I want to see the order of thread execution
I am making some changes and want to see how these changes affect a 'few' variables/expressions, also I am confident that it will take 'a number' of iterations of this change-test process to fix the bug. Printing everything to console in this case proves to be much more efficient than stepping through the code.

Most developers (including me till recently) insert the print statements in their code and the problem with that is that you have to take them out later. I know you can sometimes leave them in the source as tracing statements, but most of the time they have to be taken out. But there is a solution...

The conditional breakpoint editor in Eclipse can be 'tricked' to create what I like to call as Printpoint - and define as a 'point' in code where the debugger does not 'break' but only 'prints' to console. Essentially a Printpoint is a conditional breakpoint that never suspends execution but only prints to console. To set a printpoint, set a conditional breakpoint with Suspend when 'true' option and a condition which is always false. e.g.

Code templates are available in the condition editor, so you can create a template under 'Java statements' context and use it here. Bug 315404 has been filed to have this available in JDT by default.

ECJ - Eclipse Compiler for Java

2010-05-29T18:34:00.000-07:00

Eclipse provides and uses its own compiler that is not javac

The Eclipse compiler is used inside the IDE (Eclipse)
The Eclipse compiler can also be used as a pure batch compiler outside of Eclipse

Finding the Batch compiler

The batch compiler class is located in the JDT Core plug-in. The name of the class is org.eclipse.jdt.compiler.batch.BatchCompiler. It is packaged into plugins/org.eclipse.jdt.core_3.5.2.v_981_R35x.jar. Since 3.2, it is also available as a separate download. The name of the file is ecj.jar. Its corresponding source is also available. To get them, go to the download page, select a build and search for the section JDT Core Batch Compiler. This jar contains the batch compiler and the javac ant adapter.

Running the batch compiler from command line

Check compiler version
$ java -jar ecj-3.5.2.jar -version
or

$ java -jar org.eclipse.jdt.core_3.5.2.v_981_R35x.jar -version

Eclipse Compiler for Java (TM) 0.981_R35x, 3.5.2 release, Copyright IBM  Corp 2000, 2009. All rights reserved.

Compile a source file
$ java -jar ecj-3.5.2.jar HelloWorld.java
or
$ java -jar org.eclipse.jdt.core_3.5.2.v_981_R35x.jar HelloWorld.java

Running the batch compiler programmatically
Use the static compile(String commandLine, PrintWriter outWriter, PrintWriter errWriter, CompilationProgress progress) method of the class BatchCompiler.


org.eclipse.jdt.compiler.CompilationProgress progress = null; // instantiate your subclass
org.eclipse.jdt.internal.compiler.batch.BatchCompiler.compile(
 "-classpath rt.jar A.java",
new PrintWriter(System.out),
new PrintWriter(System.err),
 progress);

You can control how progress is reported, or how the batch compiler is canceled, by subclassing the class org.eclipse.jdt.compiler.CompilationProgress.

Using the ant javac adapter

The Eclipse compiler can be used inside an Ant buildfile using the javac adapter. In order to use the Eclipse compiler, you simply need to define the build.compiler property in your buildfile.

property name="build.compiler" value="org.eclipse.jdt.core.JDTCompilerAdapter"

More Information
Look in Eclipse SDK - Help : JDT Plug-in Developer Guide > Programmer's Guide > JDT Core > Compiling Java code

So who all are using the Eclipse Java Compiler - besides developers using Eclipse for writing java code :) ? Apache Tomcat uses ECJ to compile JSPs, IntelliJ IDEA has support ECJ, as of GCJ 4.3, GCJ integrates with ECJ, Liferay Builds with ECJ, and there are many others.

Why Open Source?

2010-05-09T02:32:00.000-07:00

Now that I work on Eclipse which is Open Source, I decided to give some serious thought to the question - why allow your software to be used for free?

http://www.geograph.org.uk/photo/176270

Before getting to software lets see if some other things have been allowed to be used for free in the past. The first example I can think of is Roads - governments construct roads and let people use them for free. The goal of the government is to make places - markets, malls, industries, schools etc - on the road to be more accessible. These places in turn generate money and the government earns its taxes from them which in turn are used to construct more roads.

http://upload.wikimedia.org/wikipedia/commons/8/88/BomstasjonSvinesund.jpg

Now there are some 'Toll roads' as well where you pay for each usage of the road. People will pay for each usage of a road if firstly they have the money, and secondly they have no alternative free road to use.

In both cases the roads do not serve any purpose other than make places accessible where the actual work gets done and people make money. True you can go for a nice relaxing drive but that is not the primary use of a road.

In software world, an example of 'Toll Road' would be Microsoft Windows - people do not pay for Windows just to click around with a mouse; they probably need a word processor, a browser, a presentation maker etc to get some work done. Since historically there were not many choices in operating systems and Microsoft managed to market Windows well - people ended up paying for it.

Now Eclipse began as an IBM project which was later made open source. The Eclipse foundation has a number of strategic members and I think all of them sell products built of top of Eclipse platform and make money. Eclipse being a free and open road means that the road is just awesome and a lot of people use it, making the final destinations (commercial products) that much more profitable.

MySql also has a free version and an enterprise commercial version. Mozilla Foundation makes money from Search royalties and some donations. However if Netscape had defeated Microsoft in the browser wars over a decade ago then I do not think we would have been using Firefox for free. (Maybe all of us should thank Microsoft for this :p )

I assume something similar happens in Apache, Linux worlds and other open source projects. If you are not able to make people pay for the road, you give it away for free, create a huge user base or community, invite contributions from this community and then reap benefits from making money at the malls, industries, schools down the road.

3.6 M7 - New & Cool in JDT

2010-05-02T10:54:00.000-07:00

Till now Eclipse had a package name compression preference with which 'org.eclipse.ui.contentassist' could be compressed to 'o.e.u.contentassist'. From M7 onwards package names in Java views can be abbreviated with some custom rules as well.

Rules for this example:

org.eclipse.ui={UI}
org.eclipse.ui.texteditor={T}
org.eclipse.ui.internal.texteditor=[iT]

These rules can be configured in Preferences > Java > Appearance > Abbreviate package names.

I really like this feature. Thanks Guven Demir for contributing this(Bug 299514) !!

Also, we have a new decorator (a big red '!') on Java projects and working sets that contain build path errors. We went through a number of options (Bug 215980)before settling on this one. Helps to spot those build path problems really easily!

UI Patterns in Eclipse

2010-04-24T07:04:00.000-07:00

Slides for my talk at Eclipse Day India 2010

UI Patterns in Eclipse

View more presentations from deepakazad.

Eclipse Day India 2010

2010-04-24T03:01:00.000-07:00

Yesterday I presented at the first Eclipse Day to be organized in India. It was a great event, credit goes to Ankur and Prakash for organizing it, and to all the presenters and attendees (some of them had come from other cities) for making it successful.

The keynote was planned to be delivered by Daniel Megert, but the volcanic eruption in Iceland meant that he could not make it to Bangalore. However, Rajesh Thakkar, who stepped in at the last minute, delivered a nice keynote - Agility and Open Source. He is quite an inspirational speaker and I have heard him quite a few times inspiring people in the hallways of Rational Labs :). The keynote started off with a history of open source (not open source software), looks like open source has been around since at least 1857 when volunteers started work on the Oxford English Dictionary! I also liked his point on working at a 'sustainable pace', and not over committing. A lot of developers (me included) are guilty of saying 'no problem, it will be done' even when they no nothing about the problem at hand and then slogging days and nights trying to get it done.

Among the other talks I liked
- the OSGi tutorial by Prakash - modules in an application and rooms in a house analogy was nice!
- P2 talk by Pradeep,
- the one on RAP by Ankur ,
- and lastly Chetan's talk on dependency injection. I thought Chetan explained the topic really well with simple examples.

And oh yes, pizza and drinks with my team and Rajesh in the evening was fun. Guys we need to make this a tradition at every Eclipse event we organize!

Eclipse, NASA and the Mars rovers

2010-04-02T22:57:00.000-07:00

Dr Jeff Norris from NASA Jet Propulsion Laboratory gave an amazing keynote presentation at EclipseCon 2010. He showed how his team at NASA has been using Eclipse based clients to control Robots/Rovers. He also did some live demos - remotely controlled a giant ATHLETE rover, and controlled a robotic Socrates head. It was nice to see Eclipse being used for controlling those Mars rovers :).

While I was really impressed by the live demos and the rovers I think the highlight of his talk was something else. The talk was built around the point that 'An individual alone cannot construct a skyscraper (a complex system), it takes a group of people specialized in different skills to do that'. This means that an individual's contribution, however small it may appear, is important to the group's success and we at Eclipse can take some credit (however small) for those Mars Rovers :).

10 years ago I was writing essays as part of 'Red Rover goes to Mars' project, while my essays did not make the cut then, I now write software which is used for controlling those Mars Rovers! Pretty neat, I say :)

Open windows explorer from command line

2010-02-21T23:07:00.000-08:00

$start . // opens the current directory
$start C:\Downloads //opens the downloads directory

instead of 'start' 'explorer' also works

Open Services for Lifecycle Collaboration (OSLC)

2010-01-27T00:38:00.000-08:00

IBM Rational Jazz is a participant in OSLC.

For more info see http://open-services.net
OSLC white paper
Change Management 1.0 Specification

Scripted Data sets in BIRT

2010-01-25T06:13:00.000-08:00

Why/when do you need a Scripted data set in a BIRT report?
Existing tables in your database will not provide data in the way you need them in a report. You might have to query more than one table to get all the data, or you may want to do some computation which requires going through one table data more than once.

What scripting language can be used?
Javascript is the primary language to be used in BIRT. BIRT also uses the Mozilla Rhino JavaScript engine which provides excellent integration with Java, hence you can use Java libraries as well but with a Javascript like syntax.

How to do it?
- Create a global variable: declare the variable in the initialize event of the report
For example:


importPackage(Packages.java.util.*);
globalvarMap = new java.util.HashMap();
globalvarList = new java.util.ArrayList();

- Populate this variable with required data: Typically you would read a simple dataset and dump all the data in this global map with the primary key (or maybe some other value) of the table being the key of the hashmap. The necessary code goes in 'onFetch' event (method) of the dataset, and a table column is referred to as 'row["CUSTOMER_ID"]'. The onFetch event is called once per each table record, hence you get access to table data one record at a time.
For example:

var list = globalVarMap.get(row["CUSTOMER_ID"]);;
if(list == null) {
list = new java.util.ArrayList();
}

var data={};
data.customer_name = row["CUSTOMER_NAME"];
data.product_bought = row["PRODUCT_BOUGHT"];
data.price = row["PRICE"];

list.add(data);
globalVarMap.put(row["CUSTOMER_ID"], list);

Here the CUSTOMER_ID is not the primary key, and we are just sorting of various items bought by each customer.

- Create a scripted data set: The final step is to create a scripted data set with the required columns and use global variables like the one above to populate this data set. Since you have the necessary data in a bunch of global variables, you can do pretty much what you want. The necessary code goes in 'fetch' event (method) of the dataset.


if(customerCount < globalVarList.size()){
 var data = globalVarList.get(customerCount);

 row["CUSTOMER_ID"] = data.customer_id;
 row["CUSTOMER_NAME"] = data.customer_name;
 row["PRODUCT_ID"] =data.product_id;
 row["TOTAL_PURCHASE"] = data.total_purchase;
 row["QUARTER"] = data.quarter;
 row["COUNTRY"] = data.country;

 customerCount++;
 return true;
}

return false;

Here, we have the necessary data in a global list variable and we just have to populate the scripted data set. In the fetch method we return true to indicate that there is more data coming, and false to indicate that we are done.

Additional Info
BIRT/FAQ/Scripting
BIRT Java Reporting

Monitoring and Allocating Users Across Projects in Rational Team Concert

2010-01-20T20:41:00.000-08:00

Most views and reports in Rational Team Concert (RTC) are project centric. They give information about a particular project, its members and their utilization and various other facades. So far so good. But what if you wanted to maximize your resource (user) utilization across projects from within RTC. Who should the project manager pick up to assign to a new task?

Few custom reports can be created to provide a resource centric view of RTC.

Resource Assignment
This report gives how various resources are assigned to various projects. Essentially this report gives the overall 'Load' (as defined in the User admin page of RTC) for all users across all projects.

Resource Utilization
This report gives you how the users are utilized across projects. It shows one value for a user by doing a weighted average, with the weights being the user assignment in percentage.

Resource Utilization for a user for one project = Work Assigned (Hrs) in the project/ Total time (Hrs) available for the project

Resource Utilization per User
This will give a breakdown of resource utilization of a particular user.
Task Card
Users can use this Task card to see all their workitems across all projects.

Discussion and Downloads
The detailed discussion on these is captured in an RTC workitem on Jazz.net. The report designs can also be downloaded from there.
Create a report to see user utilization across all projects in the repository (100997)

Note:

These reports also deal with massive amounts of data and hence can be a bit slow.
They also span across multiple project areas which can have different timelines, hence the reports may or may not suit your needs. If the timelines are aligned, then these reports should work without problems.
These have been tested with RTC 2.0.0.1

Refactoring in JDT

2010-01-19T11:28:00.000-08:00

Eclipse Corner Article : Unleashing the Power of Refactoring

Eclipse Corner Article : The Language Toolkit: An API for Automated Refactorings in Eclipse-based IDEs

Asking questions the smart way

2010-01-14T00:14:00.000-08:00

The industry standard on this : http://catb.org/~esr/faqs/smart-questions.html

While this is a fairly long piece the following steps should work in most cases
-RTFM
-STFW
-While asking your question provide enough information so that no one needs to come back to you for clarification or more information, as no one will.
- And use general common sense ;-)

Some Misc Eclipse Links

2010-01-09T02:24:00.000-08:00

Eclipse and Java for total beginners. These are some nice video tutorials.

http://eclipsetutorial.sourceforge.net/totalbeginner.html
http://eclipsetutorial.sourceforge.net/workbench.html
http://eclipsetutorial.sourceforge.net/persistence.html
http://eclipsetutorial.sourceforge.net/debugger.html

Eclipse Webinars and Podcasts

http://live.eclipse.org/

Encoding strings to UTF-8 in Java

2009-12-16T00:58:00.000-08:00

The following code encodes the string in UTF-8 encoding.

 
      String s;
      .
      .
      byte[] b= null;
      try {
          b= s.getBytes("UTF-8"); //$NON-NLS-1$
      } catch (UnsupportedEncodingException e) {
          e.printStackTrace();
      }

However small errors can lead to interesting consequences. To type uppercase alphabets I hold down the shift key and type, I rarely use caps lock. While I was writing the above code, to be specific the "UTF-8" part, I accidentally typed in "UTF_8", as I was still holding down the shift key while pressing the -/_ key. I use IBM JREs (1.4.2,1.5, 1.6) and tried this with all three of them, and it worked like a charm. Now someone else tried the same code with another vm and it failed. I thought strange...

Digging a bit deeper, http://java.sun.com/j2se/1.3/docs/guide/intl/encoding.doc.html lists the correct name to be UTF8 or UTF-8, so UTF_8 should not work. Digging a bit more...IBM JRE 1.4.2 contains sun.io.CharacterEncoding in core.jar, the alias table in this also contains UTF8 and UTF-8 only. However this class also contains a private method 'replaceDash(String)' which seems to be replacing '_' with '-' , since I was looking at the class file I cant be too sure), and I could not find any other reason of why UTF_8 was working.

It looks to be a bit silly/dangerous of IBM JRE to support non-standard aliases, because things fail on other JREs.

See the standard charset names in the IANA registry

IBM Rational Insight - Various versions

2009-12-16T00:03:00.000-08:00

List of different versions of Rational Insight and the supported product integrations the links to download pages

Rational Insight 1.0 (Released May 2009)

Rational Team Concert
Rational Quality Manager
Rational ClearCase
Rational Clearquest
Rational Test Manager
Rational RequisitePro
Microsoft Project
HP Quality Center* (Released Aug 2009)

Rational Insight 1.0.0.1 (Released Sept 2009)

Rational Quality Manager 1.0.1.1
Rational Quality Manager 2.0
Rational Team Concert 1.0
Rational Team Concert 2.0

Rational Insight 1.0.0.2 (Released Dec 2009)

Rational Project Conductor 1.0
Rational DOORS 9.2.0.1.
Licensing enforcement, specific license keys for Rational Insight are now required

Creating BIRT reports in Rational Team Concert 2.0

2009-12-13T08:57:00.000-08:00

This video is a "hello world" introduction to creating reports in Rational Team Concert 2.0. James Moody demonstrates how to create a report that shows the historical data of open work items

James Moody demonstrates how to use Rational Team Concert 2.0 to write a report that includes the results of a work item query.

Download these reports

Reports wiki page

Reporting : Some common myths and misconceptions

2009-12-09T18:08:00.001-08:00

Reporting is same as charting
Most people tend to think that reporting is as simple as creating a chart. Reporting involves storing, retrieving, aggregating data in a manner to assist in creating cool charts quickly. Charting is just a small part of reporting, once you have the required data in a simple table then you can create a nice looking chart using all the nice colors etc. Note the key requirement for charting - 'once you have the required data'.

Anyone should be able to create reports
Yeah right. Any Tom Dick and Harry just cannot create reports, any TD&H should be able to create charts but not reports. Only a programmer knows how to deal with tonnes of data, how to store it efficiently, how to retrieve it efficiently, the relationships between entities etc. Any report worth having will be complex enough that only a programmer will be able to create it.

This report can be created in a day
Yeah right again... Creating reports is a time consuming job. If too much data is involved you want to store precomputed values in a data warehouse, if latest information is crucial then report should use operational data store, a user needs to be able to drill down and drill up in a report and most importantly the colors in the chart need to look perfect. All this can be 'easily' accomplished in a day!

Every report can run in 1 sec
This one is hilarious, you have millions of records in your DB and you expect the report to run in 1 sec. Reports based on data warehouse (pre-computed results) can be made to run very very fast, but sometimes the data is missing in the data warehouse and you need to create some custom reports from Operational data store, now these reports are going to be slow. Even data warehouse reports can take some time to run, depending upon how much data is there and what all needs to be aggregated. Sometime reports can take hours to run, schedule these overnight (if needed) and stop cribbing.

To be honest most people take reports for granted, I mean they just expect all sorts of good reports to be there, and they don't really appreciate the effort gone behind creating all those cool reports. The truth is : any report worth having is quite complex!

Excellent presentation on BIRT scripting

2009-12-07T09:25:00.000-08:00

BIRT Advanced Scripting EclipseCon 2008

BIRT Advanced Scripting EclipseCon 2008

This explains the BIRT events, report generation phases and scripting in a great detail.

IBM Timeline

2009-11-29T09:10:00.000-08:00

IBM has done some pretty neat things over the years.

Yet another blog post

2009-11-27T08:20:00.001-08:00

Ok, documenting some four letter acronyms that I have been using for some time now.

YALD - Yet another long day

YALN - Yet another long night
Do not get any wrong ideas :). This just refers to another night spent in office while writing/debugging/cursing/etc some code. And of course listening to Pink Flyod at 5 in the morning... I have become comfortably numb...

YAIP - Yet another impromptu presentation
Something funny always happens in a last minute presentation/demo. You find a bug in the code at the last minute which breaks everything (and you need some hacks to get things going), or during the presentation you are staring at a slide (given to you by someone just before the presentation) and trying to make some sense out of it :)

Looks like I have come up with another acronym while writing this - YABP (see the title)

PS: My favorite hack.. so far

for( String name : Names ) {
 //hack
 if ( name.equals("ABC") ) {
  continue;
 }
 // do something meaningful now :)
 .
 .
 .
 .
}

Hashing

2009-11-23T09:44:00.000-08:00

What is hashing?
Hashing can be thought of as a mapping of a set of values(S) to a set of discrete points(k1-kn) on a line (one dimension).

Generally the range of S is much larger than n, but count(S) is lesser than n. As a result most hash functions will try to distribute elements of S uniformly among the available keys. But there are bound to be collisions as in most situations perfect hashing is not possible.

Perfect hashing is possible when you know S in advance (a rare scenario). In this case you can simply have k1=1, k2=2 and so on.

Hashing in 2-D, 3-D... n-D
With hashing in one dimension collisions are inevitable. But if you think in 2 dimensions, then you are trying to map S to discrete values in a rectangle ( 32 bit squares in practical implementations). What this really means is that you generate 2 keys for the same element Si. The chances of collision decrease significantly in this case. For instance two 32 bits hashcodes used together are going to be much better than a single 64 bit hashcode.

In a similar way 3 hashcodes can be thought of as mapping S to a cuboid (32 bit cubes), and so on till n dimensions.

Rational Insight on the IBM Developer Cloud

2009-11-21T03:51:00.000-08:00

Demo of the usage of Rational Insight on the IBM Developer Cloud

Why IBM Developer Cloud ?
The cloud saves costs in aquiring, installing, configuring and managing software

Integration between Rational Focal Point and Rational Project Conductor

2009-11-21T03:13:00.000-08:00

This video demonstrates the integration between portfolio and project management. See how a project proposal created in Focal Point becomes a project in Project Conductor and how the two applications share data.

Demonstrates a project's round trip journey between Focal Point and Project Conductor. Projects are prioritized and approved in Focal Point, sent to Project Conductor for execution, and finally reviewed back in Focal Point.

Rational Project Conductor is built on the Jazz Foundation and is available for download from jazz.net.

An overview of Rational Project Conductor

JavaScript Development Toolkit (JSDT) – Getting Started

2009-11-05T00:41:00.000-08:00

What is JSDT?

A JavaScript IDE for Eclipse based on the Java Development Tools (JDT)
Has many of the rich editing features of JDT, facilities for error detection and correction, detailed flow analysis etc

How to get it?

As part of Eclipse IDE for Java EE Developers (since Eclipse 3.4)

By adding ‘Web tools platform’ to plain Eclipse

Also part of Rational Application Developer (RAD)

Pain Points in JavaScript Development

Text editor, firebug and browser refresh were the best tools available
Minimal content assist
Minimal static validation
No refactoring support
No source code navigation support

JSDT Library mechanism

Library mechanism to manage common objects, variables, and types in a project
JSDT library : prototyped object/class definitions and JSDoc
Prepackaged libraries
User defined libraries

Features

Content assistance

Script validation and error detection

Quick Fix

Refactoring

Same-word highlighting

Source code navigation

Challenges in software development

2009-09-19T11:46:00.000-07:00

As a developer I find writing code as the easiest part of my job as at most times I have total control over it. But working on complex software poses a number of challenges and writing code can sometimes be the last thing I am worried about.

The first challenge and probably the most irritating one is 'Marking the territory'. I hate to hear 'its my component', 'I know the best way to deal with it' , ' you worry about your component' and other variants of it. I guess its human behavior to be a bit protective of your work, but at times it goes out of hand. More often than not this curbs the flow of fresh ideas in the team.

The second challenge and an equally irritating one is 'Passing on the buck'. Now if you are working on a complex software, you will definitely be able to solve a particular problem in many ways (meaning in many components). However there is generally a best solution. But people have a tendency to pass on the buck to some other component by saying 'let them deal with this problem'. I hate it when this happens without reason. A problem passed on to other component must always be accompanied by a detailed explanation of why the problem has to be solved by the other component.

'Absolutely ridiculous schedules' is something that has me stumped most times and has also helped me in improving my negotiation skills :). Software delivery schedules seem to designed by people who have no idea of what it takes to develop software. Ok the last statement is bit of an exaggeration but there is always a tussle between management and developers. Management wants things to be ready day before yesterday, and developers need another year to write a Hello World program (ok exaggerating again :P ). Different technologies require different amount of effort, for instance writing Java code in Eclipse is a much easier job than writing an equal amount of JavaScript. People coming up with schedules need to understand these differences. In my opinion the management needs to sit with developers every once in a while and understand the various challenges they are facing with the technology involved. Or a better option is to make it mandatory for managers to write or test code (not a whole lot but at least some contribution). But probably the best option would be to teach developers to manage things in addition to developing software. I have seen a few people who are successful with the last option, but mostly its a tussle!

'Shouting from rooftops near a deadline' - Some folks have a tendency to create a lot of noise near a deadline to make it appear that without them everything will fall apart. Whenever this happens I always think 'you could have at least whispered a bit earlier and maybe we would have lesser problems to deal with now'.

Most of these challenges will vanish if only people are open to new ideas, do the right thing and have trust in others to do the right thing. If only if....

Method for dealing with temporary files in a java server program

2009-09-12T01:38:00.000-07:00

Method for dealing with temporary files in a server program

Problem

To handle temporary files Java provides two mechanisms

- File class provides a set of createTempFile methods which ensure that each file gets a unique name

- File class has a method deleteOnExit method which ensures that the file gets deleted when the JVM terminates.

But these methods prove insufficient while dealing with temporary files in a (java) server process. The server process (jvm) runs for a long time before crashing/restart, hence files cannot be cleaned only on process (jvm) start or process (jvm) exit, it has to be done regularly so that the files do not accumulate on the hard-disk.

Scenarios when manual deletion of files is not possible

An image file is referenced by html sent back to the web-browser. There is no way of knowing when the image file has been requested and downloaded by the web-browser.
A file cannot be deleted manually because an input-stream is opened on the file and passed to an asynchronous API.

Possible Solutions

File system itself to provide a file expiry attribute
Java to provide a file expiry attribute

The above 2 are not available

Proposed Solution

Provide a file expiry time while creating a temp file. All such files are marked to be deleted when the expiry time is over and can be deleted in an independent thread running on the server.

Sample Implementation

public class TempFile extends File {
               private Date d = null;
              /*  
             * The default expiry time is 1 day  
             */
              private Date getDefaultExpiry() {  
                        Calendar c = Calendar.getInstance();  
                        c.setTime(new Date());  
                        c.add(Calendar.DATE, 1);  
                        return c.getTime();  
            } 
              /*  
             * Constructor from super class  
             */
              public TempFile(String pathname) {  
                        super(pathname);  
                        setExpiry(getDefaultExpiry());  
            } 
              /*  
             * Constructors with expiry parameter  
             */
              public TempFile(String pathname, Date expiry) {  
                        super(pathname);  
                        setExpiry(expiry);  
            } 
              /*  
             * Let the user set the expiry attribute after construction of object  
             */
              public void setExpiry(Date d) {  
                        this.d = d;  
                        FileGarbageCollector collector = FileGarbageCollector.getInstance();  
                        collector.addFile(this);  
            }
  }
  public class FileGarbageCollector implements Runnable {  
            private static FileGarbageCollector ref = null;  
            Thread t = null; 
              public static FileGarbageCollector getInstance() {  
                        if (ref == null) {  
                                    ref = new FileGarbageCollector();  
                        }  
                        return ref;
              } 
              /*  
             * The files for which an expiry time is set.   
             */
              private static List files = null;  
            private FileGarbageCollector() {  
                        files = new ArrayList();  
            } 
              public void addFile(TempFile f) {  
                        files.add(f);
                          if (t == null || !t.isAlive()) {  
                                    t = new Thread(ref);  
                                    t.start();  
                        }  
            } 
              public void run() {  
                        while (files.size() > 0) {  
                                    Date d = new Date();  
                                    for (int i = 0; i <  files.size(); i++)  
                                                if ( d.getTime()  > files.get(i).getExpiry().getTime()  ) {
                                                            TempFile t = files.remove(i);  
                                                            i--;  
                                                            t.delete();   
                                                            System.out.println(t.getPath() + " deleted at "  
                                                                                    + new Date());  
                                                }  
                                    }  
                                    try {  
                                                Thread.sleep(8000);  
                                    } catch (InterruptedException e) {  
                                                e.printStackTrace();  
                                    }  
                        }  
            }  
}

Rational Software Conference 2009

2009-08-15T19:01:00.000-07:00

It was a busy week because of Rational Software Conference (RSC). RSC happens in multiple cities in India. I was supposed to speak at RSC Hyderabad and RSC Pune, and do a couple of demos in RSC Bangalore and RSC Hyderabad (everything on Rational Insight). Swine flu and some confusion with the schedule resulted in me speaking/demoing at Hyderabad, Bangalore and a client location in Bangalore.

All in all it was a good (and tiring) experience. Rational Insight was received quite well. For some 'Rational Insight was exactly what they needed'. With Insight being built on Cognos, I could answer a lot of questions in affirmative - ' can I see reports in pdf?', 'what about on mobile devices?', 'can i schedule the reports?', 'can I customize the reports?' , 'is it easy to to customize?' etc etc. The Insight data warehouse solves the problem of home grown or third party data sources, something which everyone seemed to have.

PS: I managed to have some Chicken Biryani at Paradise Hotel in Hyderabad as well :) (Ask any Hyderabadi about Biryani and they will send you to Paradise!)

Keeping Wordpress from overwriting .htaccess rules

2009-08-01T04:52:00.000-07:00

.htaccess file is a small Apache file that lets you do all sorts of funky things with requests made to your server.

A typical .htaccess file looks like this

# BEGIN wordpress
[ifmodule mod_rewrite.c]
rewriteEngine On
rewriteBase /
rewriteCond %{REQUEST_FILENAME}!-f
rewriteCond %{REQUEST_FILENAME}!-d
rewriteRule . /index.php [L]
[/ifmodule]
# END wordpress

Wordpress rewrites the section between '# BEGIN wordpress' and '# END wordpress' from time to time. Hence any custom rules written by you must be written outside this section. Never place your own rules within the ‘wordpress’ block

JavaScript Editors

2009-07-25T20:07:00.000-07:00

There really isn't much to talk about JavaScript editors. Most of the editors are just a little more than a text editor, providing some sort of syntax highlighting and a very minimal code completion and validation.

Notepad - If you have to write just a script or two then notepad or any text editor is good enough.

Aptana - Aptana Studio is a complete web development environment that combines powerful authoring tools with a collection of online hosting and collaboration services. The studio comes with number of editors - HTML, CSS, JavaScript, PHP etc. All the editors are fairly good with a decent code validation. The JavaScript editor comes with inbuilt JSLint script validator. JSLint catches a number of common errors and I have found it really useful.

Although the JavaScript editor that comes with Aptana Studio is good and the studio is eclipse based, installing the whole studio just for JavaScript editing can be a overkill.

Netbeans - Starting with version 6.1, NetBeans IDE provides enhanced JavaScript editing features that are modeled on support already provided for Java, Ruby, and other languages. This editor has a lot of features like Semantic Highlighting, Mark occurrences, Instant Rename, Refactoring, Quick Fixes and Semantic Checks, Code Completion and Type Analysis, Go To Declaration

While Netbeans has a rich feature set, I prefer Eclipse over Netbeans as my development environment.
JsEclipse - This is a relatively light weight eclipse based editor and provides code formatting, code completion etc. Download is available from a number of sites.
JavaScript Development Toolkit (JSDT) - This is a bunch of open source plug-ins that bring robust JavaScript programming tools to the Eclipse platform. JSDT is essentially built on the same codebase as Java development toolkit (JDT) and hence comes with many of the same features and core design found in JDT. It has all the features of Netbeans and more.
Feature list
- Syntax highlighting
- Folding/line numbers
- Full outlining, showing classes, functions, and fields
- Highlight and check of matching brackets/parentheses
- Auto-complete of brackets, parentheses, and indentation
- Error detection and correction
- Mark occurrence
- Comment toggle (line and block)
- Generate element JsDoc
- Surround with do, for, try/catch, while
- User-configurable completion templates
- Extract function/change function signature
- Indentation correction
- Open declaration
- Open-type hierarchy
- Open-call hierarchy
- Customizable code formating
- Full search
- Refactor/rename/move
- Breakpoint support
- Defined browser libraries with JsDoc for Firefox, Internet Explorer, and ECMA-3
- Support for user defined libraries using JsDoc + JavaScript prototype definitions
- Library image support
- Debugging support provided through the ATF Project
The concept of libraries is a great feature of JSDT, as it potentially allows all JavaScript toolkits to work well with it. Also its very lightweight (just 5-6 plugins), though currently it is available as part of Web Tools Platform it is possible to take just the JSDT plugins, drop them into an existing eclipse installation and get going.

Although JSDT's feature list is quite good, its a bit buggy. Also if you are using a JavaScript toolkit such as Dojo, you will have to create a library definition for it yourself.

Rational's new project management solution

2009-07-24T23:18:00.000-07:00

IBM Rational Focal Point for Project Management is a project and resource management system optimized for software and systems delivery. It allows managing activities such as Gantt charting and resource management. Focal Point manages day-to-day tasks while Rational Insight offers higher level metrics, they really work hand in hand.

Focal Point for Project Management is built on Jazz. But what does it mean to be “built on Jazz”?

The tasks developers see in their change management (CM) system are the same as the tasks the project managers see in the work breakdown structure (WBS)
Project managers assign tasks in the WBS and developers see their assignments in their CM system
Developers report their status in the CM system and project managers see that status in the WBS

It’s the same artifact – regardless of where it is visible in the system!

Here is a quick overview of Rational's new project management solution by Neil Leblanc, product manager at Rational. More information is also available on Jazz Team Blog.

Learn more about 'IBM Rational Focal Point for Project Management' from the official announcement page. Trial download is available as part of Rational Early Access Preview on Jazz.net

Focal Point for Project Management is also hosted on Jazz.net. Get the overview, features and release plan. ( Note : You will have to register on jazz.net to have a look at the release plan).

IBM Measured Capability Improvement Framework (MCIF) - Getting started

2009-07-11T19:41:00.000-07:00

Last month, IBM Rational announced their Measured Capability Improvement Framework (MCIF) offering, described in the IBM’s oficial news release. MCIF encapsulates 25 years of experience helping teams incrementally improve their practice maturity to deliver business results.

Learn more about MCIF.
Here is a short video on MCIF from Per Kroll, chief architect at IBM.

There is also a white paper on MCIF by Per Kroll and Murray Cantor.

Abstract : "In this paper, we describe how to govern the software and system delivery function to ensure favorable ROI by introducing a control framework that enables reasoning about those practices that work and those that don’t. Using this framework permits us to effectively manage risk or innovation and diseconomy of scale, and to understand the effectiveness of difference development models."

The paper also discusses an MCIF measurement solution implemented at IBM Rational using IBM Rational Insight - the 'Executive Dashboard'.

Also watch the presentation by Eric Larsen (Product Manager, Rational Insight) and Per Kroll (Chief Solution Arhitect, MCIF) on Make Better Decisions by Overcoming Information Blind Spots. This presentation talks about where how Rational Insight is an essential part of MCIF.

IBM Rational Software Conference 2009: Process, Project and Portfolio Management Track Keynote. This keynote talks about how Rational Insight and MCIF are part of the whole Rational solutions story

IBM Rational Open House

2009-07-07T11:06:00.001-07:00

Today a bunch of us at IBM Rational Software lab at Bangalore conducted this 'Rational Open House' event. It was done at 3 places in Bangalore (EGL Pyramid, EGL Rational Lab, ISL Manyata) and 1 place in Gurgaon (ISL Gurgaon). The idea behind the event was to let people in the lab know what we do in Rational, create a buzz about Rational tools and jazz.net, and also get some customers, after all money is an important thing :).

I was showcasing Rational Insight at EGL Pyramid along with few other folks who were showcasing other Rational products, including the 'rock star' Rational Team Concert. I say rock star because everyone who came wanted to know about it, and fell in love with it after seeing it. The story was the same at EGL Rational Lab and ISL Manyata. RTC was hogging all the limelight, rightly so, as its a great product.

There was quite a bit of interest in Rational Insight. Everyone who came was impressed by what she/he saw. The ability to summarize organization wide information in a dashboard, the ability to drill down to the exact cause of a problem and the ability to design a report in like 15 seconds really impressed people. Also Cognos has been a leader in BI space for a long time, so even though this is Insight's first release the underlying cognos infrastructure helps in gaining user confidence.

A few words about Jazz.net and RTC before I close. Jazz.net is the place where anyone can see what we are doing in the Rational labs, quite a few products are hosted there. Anyone can register and see all the plans and workitems for these products. This is not open source (nothing is free), though some source code is available for download. This is an Open Commercial way of software development. Our development process is open, which means our customers can see what is going on, they can provide feedback/requirements/comments early in the development process. Open development is one of the main reasons why open source projects do well. But IBM did not want Jazz platform and products on top of it to be open source like Eclipse.

According to me Open Commercial should be model for software development everywhere. After all money has to be made and salaries have to be paid, so you cant make everything open source. But you can make everything open, you can let your customers/users see what is going on, and let them interact directly with developers. Otherwise developers are hidden from customers and vice versa with layers of customer support and product managers. A direct interaction between users and developers is good for everyone. Also if you do things in open you try to do things better as everyone is watching :).

IBM Rational Insight - Getting Started

2009-07-04T14:30:00.000-07:00

Rational Insight is an enterprise reporting and performance measurement solution. It implements standard measurements, reports, and dashboards to provide accurate insight into systems and software delivery organization.

Seeing is believing, so here is a short demo of Rational Insight.

IBM Rational Executive Dashboard

Based on Rational Insight, the Executive Dashboard is designed around business and operational objectives. It pulls live data from a variety of sources

Rational Team Concert
Rational Quality Manager
Rational ClearCase
Rational Clearquest
Rational Test Manager
Rational RequisitePro
Microsoft Project

Rational Insight supports data retrieval from sources using either the REST architecture or direct database access. Hence it can support any data source that provides REST services for accessing data, or has direct database access. The above list represents the products supported out of the box.

Rational Insight is based on Cognos Business Intelligence and performance management technology. Founded in 1969, Cognos serves more than 23,000 customers in over 135 countries. Learn more about Cognos software

Rational Insight consists of the following components

IBM Cognos® Data Manager
IBM Rational Insight data warehouse
IBM Cognos Framework Manager
IBM Rational Insight report server
IBM Cognos Business Intelligence Server
IBM Rational Insight XML data configuration
IBM Rational Insight Data Services

It also works with other Cognos components, for instance with Cognos 8 Go to deliver reports on mobile devices.

Learn more about Rational Insight architecture

Rational Insight is a key part of IBM - Measured Capability Improvement Framework (MCIF). MCIF encapsulates 25 years of experience helping teams incrementally improve their practice maturity to deliver business results. Learn more about MCIF. Here is a short video on MCIF from Per Kroll, chief architect at IBM.

Cross site scripting

2009-06-30T21:38:00.001-07:00

Client side cross site scripting is restricted till before Firefox 3.5. With Firefox 3.5 there are a couple of new headers introduced to provide safe cross site scripting: Origin and Access-Control-Allow-Origin.
For more details : Http access control

Also read Server side access control

Facts and Dimensions

2009-06-23T09:37:00.000-07:00

Star schema is created for reporting or analyzing data by summarizing the data in charts. Now the easiest way to visualize the star schema i.e. facts and dimensions is to imagine a chart. Whatever is plotted on the axes is a dimension and the values that are plotted inside the chart are facts.

JSDT resources

2009-06-23T03:51:00.000-07:00

Meet the JavaScript Development Toolkit - Developer works article by Bradley Childs giving an overview of JSDT

JSDT Wiki Page

JSDT development Wiki page

JSDT and Dojo - Discussion page on dojotoolkit.org explaining how JSDT can be used with Dojo

Webtools downloads page - Download WTP builds, WTP includes JSDT

Eclipse downloads - Download Eclipse IDE for Java EE developers. This includes the web tools platform which in turn includes JSDT.

JSDT bugs (bugzilla)

UML tutorials

2009-06-17T04:44:00.000-07:00

Practical UML : A Hands-On Introduction for Developers : This one is more detailed

UML basics: An introduction to the Unified Modeling Language

Abstract Syntax Tree

2009-06-16T03:16:00.000-07:00

Summary

The Abstract Syntax Tree is the base framework for many powerful tools of the Eclipse IDE, including refactoring, Quick Fix and Quick Assist. The Abstract Syntax Tree maps plain Java source code in a tree form. This tree is more convenient and reliable to analyse and modify programmatically than text-based source. This article shows how you can use the Abstract Syntax Tree for your own applications.

By Thomas Kuhn, Eye Media GmbH
Olivier Thomann, IBM Ottawa Lab

Complete Article

JScript and JavaScript

2009-06-15T23:02:00.000-07:00

There are a number of similar languages or I should say implementations for ECMA -262 standard. Microsoft Internet Explorer has its own implementation and they call it JScript. Other browsers (including Firefox, chrome, safari, opera) have their own implementation called JavaScript.

JavaScript can be thought of as a subset of JScript. JavaScript conforms to the standard more than JScript, what this means is that as a developer you just worry about JavaScript as most of it is supported in JScript as well. But there are some differences in both, most notably in the event handlers.

A couple of neat articles on this topic
JScript
Not Quite JavaScript

Rational Insight

2009-06-10T23:44:00.000-07:00

Here is what we have been working on....

IBM - IBM Rational Insight - Rational Insight - Software

Introducing IBM Rational Insight V1.0

Infocenter

For help on Rational Insight refer http://publib.boulder.ibm.com/infocenter/rentrpt/v1r0m0/index.jsp

Javascript eval()

2009-05-06T02:37:00.000-07:00

The eval() function evaluates a string and executes it as if it was script code.

Say you have 10 span tags each named "myspan_"+ <>, and the numbers range from 0 to 9. If you want to call a function on each of them, you do not have to send the full name or search for the array of span tags and figure out what one you want. Just send the number to a function and use eval("myspan_"+number+...) to perform your desired task.

You should avoid using eval() as much as possible, but in some scenarios its simpler and elegant to use it.

More details : Mozilla Developer center

Using meta tags to block search engine access to your site

2009-04-22T23:53:00.000-07:00

The noindex meta standard is described at http://www.robotstxt.org/meta.html. This method is useful if you don't have root access to your server, as it allows you to control access to your site on a page-by-page basis.

To prevent all robots from indexing a page on your site, place the following meta tag into the section of your page:

< name="robots" content="noindex">

To allow other robots to index the page on your site, preventing only Google's robots from indexing the page:

< name="googlebot" content="noindex">

When we see the noindex meta tag on a page, Google will completely drop the page from our search results, even if other pages link to it. Other search engines, however, may interpret this directive differently. As a result, a link to the page can still appear in their search results.

Note that because we have to crawl your page in order to see the noindex meta tag, there's a small chance that Googlebot won't see and respect the noindex meta tag. If your page is still appearing in results, it's probably because we haven't crawled your site since you added the tag. (Also, if you've used your robots.txt file to block this page, we won't be able to see the tag either.)

If the content is currently in our index, we will remove it after the next time we crawl it. To expedite removal, use the URL removal request tool in Google Webmaster Tools

To entirely prevent a page's contents from being listed in the Google web index even if other sites link to it, use a noindex meta tag. As long as Googlebot fetches the page, it will see the noindex meta tag and prevent that page from showing up in the web index.

Source : Google Support

Robots.txt

2009-04-22T23:38:00.000-07:00

A robots.txt file restricts access to your site by search engine robots that crawl the web. These bots are automated, and before they access pages of a site, they check to see if a robots.txt file exists that prevents them from accessing certain pages. (All respectable robots will respect the directives in a robots.txt file, although some may interpret them differently. However, a robots.txt is not enforceable, and some spammers and other troublemakers may ignore it. For this reason, we recommend password protecting confidential information.)

You need a robots.txt file only if your site includes content that you don't want search engines to index. If you want search engines to index everything in your site, you don't need a robots.txt file (not even an empty one).

While Google won't crawl or index the content of pages blocked by robots.txt, we may still index the URLs if we find them on other pages on the web. As a result, the URL of the page and, potentially, other publicly available information such as anchor text in links to the site, or the title from the Open Directory Project (www.dmoz.org), can appear in Google search results.

In order to use a robots.txt file, you'll need to have access to the root of your domain (if you're not sure, check with your web hoster). If you don't have access to the root of a domain, you can restrict access using the robots meta tag.

Source : Google Support

Some WAS (Websphere application server) commads and tips

2009-04-19T21:44:00.000-07:00

- Start a WAS server : Open cmd and navigate to profile bin directory
bin > startserver server1

- Stop a WAS server : Open cmd and navigate to profile bin directory
Security disabled
bin > stopserver server1
Security enabled
bin > stopserver server1 -username -password

- Check the server status : Open cmd and navigate to profile bin directory
bin > serverstatus server1

- To modify the java process definition (jvm arguments, initial heap size, maximum heap size) directly open the server.xml (%WAS Install Dir%\profiles\AppSrv01\config\cells\%cell name%\nodes\%node name%\servers\server1\server.xml) and make the changes. Keep in mind that admin console is the recommended way for making the changes, directly modifying the xml is just a quick way of doing things.

- In case you modify some file used by an installed application, you need to clean (delete) the WAS temporary directory and restart the server. Location of the temp directory %WAS Install Dir%\profiles\AppSrv01\temp.
Webshpere Application server caches all application files in this directory, hence for the changes to take effect this needs to be deleted so that the cache can be created again with updated files.

- To check which ports the Websphere application server is running : Open the file (%WAS Install Dir%\profiles\AppSrv01\config\cells\%cell name%\nodes\%node name%\serverindex.xml). Look for WC_defaulthost, the corresponding port number (default 9080) is the port where WAS listens for web requests. Look for WC_adminhost, the corresponding port number is where the admin console listens. Information for all other ports used by WAS is also present in this file.

Note: These are for WAS v 6 and WAS v 6.1

Report server for ClearQuest

2009-03-07T01:35:00.000-08:00

The new way of Reporting with ClearQuest 7.1

The Report Server for ClearQuest is a new Web application bundled with Clearquest 7.1 that supports running, managing, and sharing of data-pull reports created by using the ClearQuest Reporting Driver and the BIRT or Crystal Reports reporting systems.

Data-pull reports are new with ClearQuest 7.1, earlier versions of ClearQuest supported only data-push reports.

Key advantages of data-pull model

Data-pull model allows reports to be built from multiple data sources and data sets. With data-push model, reports are limited to a single ClearQuest query.
The user has more choices for reporting systems: Eclipse™ BIRT and Business Objects® Crystal Reports®.

Key Features of Report Server of Clearquest

Manage Reports
- Upload report designs
- Organize reports in folders

Share Reports
- Share a report to make it visible to everyone who has access to the Report Server for IBM Rational ClearQuest on which the report is stored.
- Email Reports to selected users

Support for Eclipse™ BIRT reporting system
- Rich Charting Capabilities
- Support for drill down reports
- Save parameter values along with report design to create Report Queries
- Save snapshots of generated reports
- Export generated reports as a PDF or Microsoft word document.

Support for Business Objects® Crystal Reports® reporting system
- Crystal viewer is used to render the reports.
- Rich Charting Capabilities

Manage Users
- Report Server for Clearquest allows you to grant access to all or only a few selected ClearQuest users.

Resources

For information on how to configure Report Server for clearquest refer to ClearQuest Infocenter
For more detailed information on capabilities refer to the User Guide
Find answers to Frequently Asked Questions (FAQs)
To learn more or purchase Rational ClearQuest, visit the IBM Rational ClearQuest product page on ibm.com
To seek solution to a problem, visit the IBM Rational ClearQuest support page on ibm.com