This is kind of a data dictionary for the type ahead search box providing suggestions.

This file is similar to the class MultiWordSuggestOracle provided by GWT. The behaviour of the GWT class was different from what was needed. Extending the class was not an option since many methods were private. Also member variables were private without any getters or setters.

The name Single Word Handler explains the purpose of class. Normally all characters are used in matching.

For example, the query “Ka” would match “Kangana Ranawat”, as well as “Shahid Kapoor”. This is because MultiWord considers each word separately for matching.

In case you do not want the match to happen, i.e. the query “Ka” would match “Kangana Ranawat”, but not “Shahid Kapoor”, then use this class provided.

The implementation of code is attached.

/**

* This is kind of a data dictionary for the type ahead search box providing suggestions.

*

* This file is similar to the class MutliWordSuggestOracle provided by GWT.

* The behaviour of the GWT class was different from what was needed.

* Extending the class was not an option since many methods were private. Also member

* variables were private without any getters or setters.

*

* The name Single Word Handler explains the purpose of class. All characters are used in

* matching. For example, the query “bar” would match “bar”, but not “foo bar”.

* In case you want the match to happen, you should use MultiWordSuggestOracle of GWT.

*/

/*

* Copyright 2007 Google Inc.

*

* Licensed under the Apache License, Version 2.0 (the “License”); you may not

* use this file except in compliance with the License. You may obtain a copy of

* the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an “AS IS” BASIS, WITHOUT

* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

* License for the specific language governing permissions and limitations under

* the License.

*/

package adv.client.tree;

import com.google.gwt.core.client.GWT;

import com.google.gwt.user.client.ui.HTML;

import com.google.gwt.user.client.ui.SuggestOracle;

import java.util.*;

public class AdvSingleWordSuggestOracle extends SuggestOracle

{

/**

* Suggestion class for {@link AdvMultiWordSuggestOracle}.

*/

public static class AdvSingleWordSuggestion implements Suggestion

{

private String displayString;

private String replacementString;

/**

* Constructor for <code>AdvMultiWordSuggestion</code>.

*

* @param replacementString the string to enter into the SuggestBox’s text

*          box if the suggestion is chosen

* @param displayString the display string

*/

public AdvSingleWordSuggestion(String replacementString, String displayString)

{

this.replacementString = replacementString;

this.displayString = displayString;

}

public String getDisplayString()

{

return displayString;

}

public String getReplacementString()

{

return replacementString;

}

}

private static final char WHITESPACE_CHAR = ‘ ‘;

private static final String WHITESPACE_STRING = ” “;

/**

* Regular expression used to collapse all whitespace in a query string.

*/

private static final String NORMALIZE_TO_SINGLE_WHITE_SPACE = “\\s+”;

private static HTML convertMe = GWT.isClient() ? new HTML() : null;

/**

* Associates substrings with words.

*/

private final TreeSet<String> tree = new TreeSet<String>();

/**

* Associates individual words with candidates.

*/

private HashMap<String, Set<String>> toCandidates = new HashMap<String, Set<String>>();

/**

* Associates candidates with their formatted suggestions.

*/

private HashMap<String, String> toRealSuggestions = new HashMap<String, String>();

private Response defaultResponse;

/**

* Adds a suggestion to the oracle. Each suggestion must be plain text.

*

* @param suggestion the suggestion

*/

public void add(String suggestion)

{

String candidate = normalizeSuggestion(suggestion);

// candidates –> real suggestions.

toRealSuggestions.put(candidate, suggestion);

tree.add(candidate);

Set<String> l = toCandidates.get(candidate);

if (l == null)

{

l = new HashSet<String>();

toCandidates.put(candidate, l);

}

l.add(candidate);

}

/**

* Adds all suggestions specified. Each suggestion must be plain text.

*

* @param collection the collection

*/

public final void addAll(Collection<String> collection)

{

for (String suggestion : collection)

{

add(suggestion);

}

}

/**

* Removes all of the suggestions from the oracle.

*/

public void clear()

{

tree.clear();

toCandidates.clear();

toRealSuggestions.clear();

}

@Override

public boolean isDisplayStringHTML()

{

return true;

}

@Override

public void requestDefaultSuggestions(Request request, Callback callback)

{

if (defaultResponse != null)

{

callback.onSuggestionsReady(request, defaultResponse);

}

else

{

super.requestDefaultSuggestions(request, callback);

}

}

@Override

public void requestSuggestions(Request request, Callback callback)

{

final List<AdvSingleWordSuggestion> suggestions = computeItemsFor(

request.getQuery(), request.getLimit());

Response response = new Response(suggestions);

callback.onSuggestionsReady(request, response);

}

/**

* Sets the default suggestion collection.

*

* @param suggestionList the default list of suggestions

*/

public void setDefaultSuggestions(Collection<Suggestion> suggestionList)

{

this.defaultResponse = new Response(suggestionList);

}

/**

* A convenience method to set default suggestions using plain text strings.

*

* Note to use this method each default suggestion must be plain text.

*

* @param suggestionList the default list of suggestions

*/

public final void setDefaultSuggestionsFromText(

Collection<String> suggestionList)

{

Collection<Suggestion> accum = new ArrayList<Suggestion>();

for (String candidate : suggestionList)

{

accum.add(createSuggestion(candidate, candidate));

}

setDefaultSuggestions(accum);

}

/**

* Creates the suggestion based on the given replacement and display strings.

*

* @param replacementString the string to enter into the SuggestBox’s text box

*          if the suggestion is chosen

* @param displayString the display string

*

* @return the suggestion created

*/

protected AdvSingleWordSuggestion createSuggestion(String replacementString,

String displayString)

{

return new AdvSingleWordSuggestion(replacementString, displayString);

}

String escapeText(String escapeMe)

{

convertMe.setText(escapeMe);

String escaped = convertMe.getHTML();

return escaped;

}

/**

* Compute the suggestions that are matches for a given query.

*

* @param query search string

* @param limit limit

* @return matching suggestions

*/

private List<AdvSingleWordSuggestion> computeItemsFor(String query, int limit)

{

query = normalizeSearch(query);

// Get candidates from search words.

List<String> candidates = createCandidatesFromSearch(query, limit);

// Convert candidates to suggestions.

return convertToFormattedSuggestions(query, candidates);

}

/**

* Returns real suggestions with the given query in <code>strong</code> html

* font.

*

* @param query query string

* @param candidates candidates

* @return real suggestions

*/

private List<AdvSingleWordSuggestion> convertToFormattedSuggestions(String query,

List<String> candidates)

{

List<AdvSingleWordSuggestion> suggestions = new ArrayList<AdvSingleWordSuggestion>();

for (int i = 0; i < candidates.size(); i++)

{

String candidate = candidates.get(i);

int index = 0;

int cursor = 0;

// Use real suggestion for assembly.

String formattedSuggestion = toRealSuggestions.get(candidate);

// Create strong search string.

StringBuffer accum = new StringBuffer();

while (true)

{

index = candidate.indexOf(query, index);

if (index == -1)

{

break;

}

int endIndex = index + query.length();

if (index == 0)

{

String part1 = escapeText(formattedSuggestion.substring(cursor, index));

String part2 = escapeText(formattedSuggestion.substring(index,

endIndex));

cursor = endIndex;

accum.append(part1).append(“<strong>”).append(part2).append(

“</strong>”);

}

index = endIndex;

}

// Check to make sure the search was found in the string.

if (cursor == 0)

{

continue;

}

// Finish creating the formatted string.

String end = escapeText(formattedSuggestion.substring(cursor));

// After “~”, we will have the EmpID; so adding some markup to it.

/*String[] larySugg = end.split(“~”);

end = larySugg[0] + “<span class=’treesuggestion’>” + larySugg[1] + “</span>”;

*/

accum.append(end);

AdvSingleWordSuggestion suggestion = createSuggestion(formattedSuggestion,

accum.toString());

suggestions.add(suggestion);

}

return suggestions;

}

/**

* Find the sorted list of candidates that are matches for the given query.

*/

private List<String> createCandidatesFromSearch(String query, int limit)

{

ArrayList<String> candidates = new ArrayList<String>();

if (query.length() == 0)

{

return candidates;

}

HashSet<String> candidateSet = null;

// Find the set of candidates that are associated with all the

// searchWords.

HashSet<String> thisWordChoices = createCandidatesFromWord(query);

if (candidateSet == null) {

candidateSet = thisWordChoices;

}

else

{

candidateSet.retainAll(thisWordChoices);

}

if (candidateSet != null) {

candidates.addAll(candidateSet);

Collections.sort(candidates);

// Respect limit for number of choices.

for (int i = candidates.size() – 1; i > limit; i–)

{

candidates.remove(i);

}

}

return candidates;

}

/**

* Creates a set of potential candidates that match the given query.

*

* @param query query string

* @return possible candidates

*/

private HashSet<String> createCandidatesFromWord(String query)

{

HashSet<String> candidateSet = new HashSet<String>();

ArrayList<String> words = new ArrayList<String>();

Iterator<String> loItr = tree.iterator();

while(loItr.hasNext())

{

String element = loItr.next();

if(element.contains(query))

{

words.add(element);

}

}

if (words != null)

{

// Find all candidates that contain the given word the search is a

// subset of.

for (int i = 0; i < words.size(); i++)

{

Collection<String> belongsTo = toCandidates.get(words.get(i));

if (belongsTo != null)

{

candidateSet.addAll(belongsTo);

}

}

}

return candidateSet;

}

/**

* Normalize the search key by making it lower case, removing multiple spaces,

* apply whitespace masks, and make it lower case.

*/

private String normalizeSearch(String search)

{

// Use the same whitespace masks and case normalization for the search

// string as was used with the candidate values.

search = normalizeSuggestion(search);

// Remove all excess whitespace from the search string.

search = search.replaceAll(NORMALIZE_TO_SINGLE_WHITE_SPACE,

WHITESPACE_STRING);

return search.trim();

}

/**

* Takes the formatted suggestion, makes it lower case and blanks out any

* existing whitespace for searching.

*/

private String normalizeSuggestion(String formattedSuggestion)

{

// Formatted suggestions should already have normalized whitespace. So we

// can skip that step.

// Lower case suggestion.

formattedSuggestion = formattedSuggestion.toLowerCase();

// Apply whitespace.

return formattedSuggestion;

}

}

1. When testing for memory or timings, the first open of a document after bouncing server, always takes huge amount of resources. Hence this one should be ignored for the time being. But you should look into it atleast once to see if the first open can also be optimized.

2. When unsure of the results, perform the same scenario about 10 times to reach a conclusion

3. Compare timing results using a Stop watch with 3.7 and not with some previous build of 3.8.

4. To get real timings, deploy on some system test server for testing.

5. Lookout for methods being called more than the expected no. of times. But spend your energy only for functions that take a significant amount of time.

Javascript

1. Use a good profiler. For Firefox, Firebug profiler is too good. IE8 comes with a profiler but not so good. Nevertheless, something is better than Nothing.

2. In Java, a lot of optimizations are done by the compiler. But not so for Javascript, we have to do the optimizations ourselves.

3. Minimize DOM interactions. These are costly both in terms of timing and memory.

4. Write a destroy method so as to clean up all code before destroying or replacing the object or its reference.

5. Cleaning up all code – remove all listeners attached to each object. Specifically use the purge() method for it. Then set all variables to null.

6. Bubble Up events. Example having 20 onclick events on 20 buttons. Instead just put on onclick event on say the form tag.

Memory

1. To see the amount of memory consumed use Process Viewer. Avoid the default Windows one.

2. At a given time concentrate on 1 feature.

3. Memory might not be recovered immediately but after sometime, so perform the same case repeatedly to check the amount of memory.

Timing

1. The Firebug profiler will show the absolute timings of methods. So suppose MethodA() calls MethodB() and MethodB() takes 100 ms to complete; then it will also add that timing to MethodA()’s execution.

2. So lookout for real methods which take the time. Here the IE Profiler shines, because it shows the methods in a tree view.

3. Target the top 20-30 methods.

4. Do not be afraid to change anything in the underlying framework. But please test…test….test.

5. For Loops: Normal: for(var i=0; i<array.length; i++) Optimized: for(var i=0, count = array.length; i=i+1)

6. Object References: Normal :

for(......)
{
   var Object = a.b.c.d.getElement();
   .....
}

Optimized:

var dObject = a.b.c.d; 

for(......)
{
   var Object = dObject.getElement();
   .....
}

]]> http://fazeel.wordpress.com/2009/08/11/performance-optimization-tips/feed/ 0 fazeelkazi http://fazeel.wordpress.com/2009/08/11/accessibility-links/ http://fazeel.wordpress.com/2009/08/11/accessibility-links/#comments Tue, 11 Aug 2009 20:27:18 +0000 fazeelkazi http://fazeel.wordpress.com/?p=20 ]]> W3ORG Specs:

1. Quick Tips - http://www.w3.org/WAI/quicktips/
2. Live Regions - http://www.w3.org/TR/aria-state/
3. Eg of Live Regions: - http://www.alistapart.com/articles/waiaria, http://accessibleajax.clcworld.net/
4. RIA - http://www.w3.org/TR/aria-roadmap/
5. Report on WAI Markup for AJAX Live Regions - http://developer.mozilla.org/en/docs/AJAX:WAI_ARIA_Live_Regions
6. ARIA Reference Implementation - http://test.cita.uiuc.edu//aria/

Accessibility Tools:

1. Firefox Accessibility Extension: https://addons.mozilla.org/en-US/firefox/addon/1891
2. Fire Vox: http://www.firevox.clcworld.net/
3. Windows Screen Reader: Start> Programs>Accessories> Accessibility> Narrator

JAWS:

1. http://juicystudio.com/article/improving-ajax-applications-for-jaws-users.php#theupdatefunction
2. http://donaldevans.com/guide/bestpractices/ajax.html

[edit]http://developer.mozilla.org/en/docs/Accessible_DHTML

Tools, Articles and resources: http://www.mcu.org.uk/resources/

E-book: Web Accessibility: Web Standards and Regulatory Compliance: http://mmlviewer.books24x7.com/toc.asp?bookid=14675

Downside of WCGAG 2.0 specs:

1. http://www.alistapart.com/articles/tohellwithwcag2
2. http://learningtheworld.eu/2006/to-hell-with-joe-clark/
3. http://www.thinkvitamin.com/features/design/whats-next-for-web-accessibility

Legal Issues:

1. http://ajaxian.com/archives/accessibility-use-ajax-get-sued

=Main site - http://www.maxkiesler.com/index.php/weblog/comments/how_to_make_your_ajax_applications_accessible/ =

Some imp. Links:

1. Ajax Best Practices – IBM Center. - http://www-03.ibm.com/able/resources/ajaxaccessibility.html#best
2. Testing Ajax with six different screen readers - http://www.sitepoint.com/article/ajax-screenreaders-work
3. Tests with blind screen-reader Users - http://joeclark.org/access/research/ice//iceweb2006-test-results.html
4. AJAX framework supporting Accessibility - http://ajaxdevelopersjournal.com/read/234219.htm
5. Making Ajax Work with JAWS - http://juicystudio.com/article/making-ajax-work-with-screen-readers.php
6. Lots of 508 Compliant examples - http://www.fiftyfoureleven.com/resources/accessibility
7. Accessibility tips for web development - http://www.evotech.net/blog/2007/06/making-the-web-accessible-2/
8. Jim Thatcher - http://jimthatcher.com
9. http://www.circlewebs.com/sitestats.php
10. http://www.wats.ca/show.php?contentid=43

Screen Reader Quick Reference

1. Fire Vox – FireVox_Ref
2. JAWS – JAWS_Ref

Scanner loScanner = new Scanner(new File("C://Fazeel-C//MSS//workspace//FastTreeProj//src//sample//JSONs.txt"));
loScanner.useDelimiter("\\Z");
String wholeFile = loScanner.next();       
loScanner.close();

The following steps outline the procedure for obtaining a migration certificate from Mumbai University. The procedure would mostly be different for other universities.

1. Download the migration certificate form from Mumbai University site. See if this link still works: http://www.mu.ac.in/migrationform.pdf. Else search on their site.
2. If you have not done a profession degree, your lucky, your last college will probably do everyhting for you. You just need to fill this form and submit it alongwith photocopies of 10th marksheet, 12th marksheet and Final year degree marksheet. That’s it just relax.
3. For others, the procedure continues. The institution that you last studied must have given you a Transfer Certificate (aka Leaving Certificate). Goto your last institution and submit an application asking for a duplicate copy of transfer certificate. This is required because the University takes the original one and seldom returns it back.
   
4. So now pack the Migration form duly filled, stamped, signed, TC, photocopies of 10th, 12th, Final Year marksheet and head to Mumbai University, Kalikna.
5. Go straight to the backyard of Ambedkar Bhavan.
   
6. Pay Rs. 220 and submit the documents. Get the receipt and hope you get it in 1 week.
7. After 1 week, go back again and check if it’s ready. Remember to go early since even though the line is small the productivity is only about 3 certificates per hour.
8. University is open on Saturday for the whole day except 2nd and 4th ones.

The above is the ideal scenario. If things go weird:

1. One guy paid a bribe at the time of form submission of about 150 bucks. He got it in an hour.
2. I didn’t get the certificate even after visiting twice and 1.5 month had passed. Suprisingly, it came by post a few days later.
3. Another girl, hadn’t got it and was waiting for 4 months. Eventually she went inside the building to “talk” to the officials inside.

No wonder nowadays, there is an increasing tendency to directly learn Java. But it there a problem in this? I always felt so.

Learning OOPS concepts through Java is possible; but do you think you can visualize the concepts to the extent you can with C++. Also basic CS stuff like Data Structures, Searching, Sorting is better understood through these languages than Java.

When I read Joel On Software’s post about this, it made 100% sense to me. You can read it at:
http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html

As far as I can see today Engineering, Medical and Management form the largest group of courses which lead to financial success.

Of course you could argue that people who haven’t studied or studied other courses have also succeeded. While this is true, this rags-to-riches stories aren’t many.
I feel that not even 10% of poor and lower middle class people could do it.

Today’s fee structure for these professional courses are well beyond the reach of these sections. There are hardly any subsidized seats available. The vast majority have to opt for other courses that do not offer such high salaries.

This is certainly going to increase the rich-poor divide.

While there isn’t much that can be done, what are the possible options available for people who can’t afford? All have their pros and cons:

1. Loans: Loans are available much more easily now. But security and willingness to take the risk is still a problem.
2. Study in some other state which has subsidies: The problem here is additional cost involved in staying away from your home. Also the worth of the university is important. Might be fine for medical courses. Say for medicine where the cost is Rs. 3,50,000 per year, if you can get in some other place for Rs. 50,000; it’s still worth it.
3. Correspondence courses: They are cheap, but their value is less especially at entry-level. But if you have some experience and just need a degree, this is a very cheap option.