I did a search on the structure of google search urls and found this post: http://www.our-picks.com/archives/2007/01/30/google-search-urls-revealed-or-how-to-create-your-own-search-url/

Here’s how to set up Chrome to use the past year as your default search range:

1. Go to settings.
2. Under the Search heading, click the Manage Search Engines… button.
3. Scroll to the bottom of the page, so you see the 3 fields for entering your own search engine.
4. Put these in the three fields:

   1. GoogleYear

   2. search.google.com

   3. {google:baseURL}search?q=%s&as_qdr=y&{google:RLZ}{google:acceptedSuggestion}{google:originalQueryForSuggestion}{google:assistedQueryStats}{google:searchFieldtrialParameter}{google:searchClient}{google:sourceId}{google:instantExtendedEnabledParameter}ie={inputEncoding}

5. Click the “Make default” button that appears at the end of the row you just made.
6. Click DONE and you’re set. Now your omnibox will always default search results to the past year unless you change it the usual way from the Search Tools at the top of the results page.

For other browsers, you can do something similar with a bookmark to the following: http://www.google.com/search?as_qdr=y or by setting up a custom search engine similarly.

Enjoy!

I recently installed the trial version of SourceMate 3.0 from Element River. It’s got a ton of productivity enhancements for Flash Builder 4.5+. It doesn’t have a bookmarks feature, but what does it does have is task tags. I really like this feature in general but I found it can be used to create bookmarks.

1. I created a new tag “BKMK” in the SourceMate tags preferences (Preferences > SourceMate > TaskTags).
   

   Add “BKMK” task tag

   Now, when I add a comment that starts with BKMK, it will show up in the tasks view.
   // BKMK Place where I go to often

2. Then, using the menu for the tasks view, I showed a new view and named it Bookmarks.
   

   Create a new Tasks view

3. I chose Configure Contents… from the menu and created a new configuration called Bookmarks. For that configuration, I added Text: contains BKMK.
   

   Create new Bookmarks configuration

4. Leaving that dialog and returning to the Flash Builder window, I chose Show > Bookmarks for that tasks view and viola, this Bookmarks view will always show the list of BKMK items I’ve placed inline in my code.
   

   Show Bookmarks configuration in the new view

This requires adding lines to the source code, so unlike breakpoints, it requires modification but can still be a pretty good workaround for the time being.

This was a new beginning though, because we could move over to Jenkins and be one of the modern cool kids. Yeah, not quite as plug-and-play as we hoped. We spent many days trying to get it to work. Through the process, we hit about every error it can spit out. I’ll try to detail what we ran into and how we solved it (to the best of my memory) in another post, if I have the time. In this post, I’ll just summarize the final solution in hopes it will help someone else out there.

Our environment

We’re running Windows 2008 R2 Datacenter SP1 on a virtual machine in Amazons Cloud. Our repository is hosted at codesion.com. After looking around the web for solutions to the errors I ran into, I wished we used GitHub since it seems like EVERYONE else out there does. That’s what most of the solutions are for. Luckily, codesion has enough on their site for me to wrap my head around what I needed to do. We have Git Bash installed on the server.

Install Jenkins

Do everything under the same account from now on, as long as you’re getting Jenkins all configured. Let’s say you’ve created a unique account for Jenkins so your team can all log in to the same account when working on Jenkins. That username is jenkinsuser for the examples here. Once that user is all set up, you can install the Jenkins application. This part is pretty straight forward so I won’t go into detail.

Set the HOME environment variable

Make sure the HOME environment variable is set to the jenkinsuser User directory. I’m actually not entirely sure it wasn’t in our case, but I saw some posts that stated it doesn’t do it automatically.

Create SSH Keys

This was the biggest stumbling block for me. We spent forever trying to get it to authenticate correctly. So, to summarize, you start Git Bash and follow the instructions here: https://help.github.com/articles/generating-ssh-keys. Don’t set a passphrase! It will save you time and frustration later.

In that github link, it talks about supplying your public SSH key. In codesion, this is under My Settings > SSH Keys. Then, go to the projects tab and click on the project you’re going to be building with Jenkins. On the right, is a services section where you can expand Git and see the ssh url. Copy this down because you’ll need it for Jenkins. It will probably say something like ssh://git_mydomain@mydomain.git.codesion.com/myproject.git.

Configure Jenkins

In Jenkins, you can now set up your project to connect to your git repo for builds. Under the project configuration, there will be a Source Code Management section. Choose Git and paste the ssh url from earlier into the Repository URL field. In the Build section, I just added a Windows batch command of echo HEY, I’M BUILDING, FINALLY!... That’s just so you can see that it got to that point and all was well. If you’re lucky, you can click SAVE and then build now and it will work. Check the Console of the build to see errors.

I wasn’t lucky. I ran into some other issues. The first, was that when I went to Manage Jenkins > Configure Jenkins, then scrolled down to the Git section, it had git.exe as the path to Git executable. I had to change this to the full path, despite what one blog post cautioned against.

The final one, that may have been what fixed many of the other issues, was to install the Jenkins git plugin instead of the Hudson version it comes with. Not sure why that isn’t default, but whatever. You can go to Manage Jenkins > Manage Plugins and choose the Installed tab. You should see your Git plugin there. Uncheck the check box to disable it. Restart Jenkins so it’s happy. Then, go here: http://updates.jenkins-ci.org/download/plugins/git/ to download the latest git.hpi file.

Go back to Jenkins then and to the Manage Plugins area, to the Advanced tab. There you’ll see where you can upload the file you just downloaded. Once it’s installed, you’ll have to back to that page, to the Installed tab and enable the plugin. Then back to the configure page for your project and enter the ssh url into the Git section again. This fixed it for me.

I hope this helps someone else out there. I’d love to save someone days or weeks of banging their head against a wall.

It’s been a great learning experience so far. I’ve learned a lot about working with TLF, images, sizing, template information generated from InDesign documents and more. I’ve used far more math than I ever thought I’d use in a lifetime. It’s allowed me to be creative in many new ways.

I’ve had to solve a lot of problems that were quite tough for me at the time until I wrapped my head around it. I suppose that’s how most problems are. Once you get the solution, you think “wow, I can’t believe it took me that long to get to such a simple solution.”

It’s been a little over a year since I blogged last. I’m not a very consistent blogger as you may have noticed. I’d like to start posting things I learn and problems I solve. We’ll see how that goes.

If your data coming from the backend is always the same structure and all the properties of your value objects are populated, the following gotchas probably won’t apply.  For me, I’m working with some complex objects that can have a lot of data associated with it.  Because of that, the objects returned from the server can have different amounts of data populated.

Let’s say you’re working with Contacts again.  If your contact table had the following fields that matched to basic properties of your value object, you’d be fine.

contactId, firstName, lastName, phone, email, street1, street2, city, state, zip

But what if your object was a little more complex, like this:

contactId:int
firstName:String
lastName:String
phone:String
email:String
address:Address
notes:ArrayCollection of potentially long Strings
purchases:ArrayCollection of Purchase
referrals:ArrayCollection of Contact

Now, the API for the database might need to have more than a simple getContacts call.  Maybe you need a getSimpleContacts that just populates the id, name, and contact info.  This would be useful for getting the list of your contacts to put in a list.  Then when you select a contact, you could make a getFullContact call so that potentially large sets of data don’t have to be sent if they might not be needed.

If this were the case, you’d make the initial getSimpleContacts call to populate your list.  That would sync the objects to your data cache, with null values for the properties that are ArrayCollections.  Then as you select items, those null values would get overwritten with the real data in the cache.  Here’s the updateProperties method in the cache I’ve been using:

private function updateProperties(itemA:Object, itemB:Object):void
{	
     for each (var property:Property in info.getProperties())
     {
          if (property.readable && property.writable)
          {
               property.setValue(itemA, property.getValue(itemB));
          }
     }
}

It simply copies the new data from the new object (itemB) to the cached object (itemA).  That seems simple and elegant.

If you have the multiple APIs I talked about earlier, this can pose a problem.  Let’s say you open the application, getSimpleContacts is called to populate the basic list, you select a couple which shows all the contacts information so you use the getFullContact API.  The Contact object comes back with all the fields populated.  You sync the contact object using the cache and all the values are copied over to the cached object.  This is good because now, the object in the cache is fully populated so wherever you use it in your application, you’ve already got all the data.  Maybe in the time since you called getSimpleContacts and getFullContact, the phone number was updated, so that is updated in the cached contact as well.

Now, you go back to your list and to be sure you get any contacts that have been added since you last looked at the list, you make the getSimpleContacts call again.  The contacts come back and you sync each one with the cache so any updates will be reflected in the cached contacts.

Do you see a problem with the updateProperties method in this case?  The simple contact objects will still have all the property definitions, but since the API only returns the basic stuff, the new object will have null values for notes, purchases and referrals.  The updateProperties method will copy those null values over, clearing those populated values you had.

As long as the API will never return null values for properties the API provides, you could add a check to the if statement that only does the copy if the new value is not null:

if (property.readable && property.writable && property.getValue(itemB) != null)
{
     property.setValue(itemA, property.getValue(itemB));
}

If the data your server provides has a dateModified field that gets updated whenever any property of the object changes, you could make a custom cache for that dataType that compares the dateModified values of the old and new data.  If the dateModified is the same, you can skip copying over the basic data, since all APIs retrieve that in our example, and just copy the last three properties that might be null.  You could check for nulls as well to further reduce the work involved.  Skipping all that data copying if you know it wasn’t modified might seem trivial for one object but imagine if you retrieved 1000 contacts and synced them all with the cache.  Skipping the copying for the majority of your data would vastly improve the time it takes to process all those objects.

If you’re working on an enterprise application like I am, you’ll most likely appreciate the performance improvement and the caching mechanism I’ve described.  When you’re working with really big data sets, every little bit of processing time saved on each item can translate to noticeable improvements in the performance of your application.  Mobile applications also benefit from any performance improvement you can give it.

Do you have other ideas on caching or performance improvements when dealing with large amounts of data?  I’d love to hear them in the comments.

Lets say you have an application that tracks contacts.  The Contact object has a number of properties and some of the properties are custom classes themselves, such as an Address class.  Your application displays the contact information for the contact and you bind the address view to properties of the address property, like this:

<s:Label id="street1" text="{contact.address.street1}"/>

At first glance, most people would think this is just fine.  But here’s the scenario where this becomes an issue:

Let’s say the contact application doesn’t cache the contact objects.  Instead, you just overwrite the original data with the updated data.  It’s fast and simple.  There is probably a var called contacts in a model that the rest of your application references to display information about the contacts.

You’re open the application and on startup, it fetches all the contacts.  You select one of the contacts to view all the details.  The label that displays the street binds to the contact you selected and displays the data.  Then your application fetches the contacts from the server again, in case someone else has made changes to the contacts.  This contact (we’ll call him Henry) lived on River Rd. but recently moved to live on Oak St.  While your application was open, someone else updated his address.  Now, when the application on your computer goes out and fetches the contact again, it replaces that object with the new contact object.  It’s the same information but a different object in memory.

Here’s where the problem comes into play.  The Label was bound to the street1 property of the address property of the original contact object.  That object still exists with the original address and street1 values, and the Label is still bound to it.  The new object that has replaced it happens to have the same name and contactId, etc. but ActionScript doesn’t assume anything so the label ends up showing out of date information even though you’ve fetched the updated information.

If the contact object was cached, what would end up happening is that the Label would bind to a property of the contact which was stored in the cache.  When the new object came back from the server, it would be sent to the cache to be syncronized.  The cache would find the contact object with the same contactId and copy values from the new object to the one already in the cache.  Any properties that are not base objects like String, int, etc. would need to be cached and synced as well.  So your Address instance associated with Henry’s Contact instance would be updated in the cache too.  That way, the Contact instance is always the same object in memory and the Address instance used for the address property would always be the same object in memory as well.

This method takes some more time to keep the objects up to date but makes it much simpler when it comes to referencing those objects throughout your application.  The flip side would be to do the basic swap of data, but use events to notify the rest of the application that things have changed and carefully deal with that change appropriately by reassigning references wherever needed.  That way would be much more complex on your part but could potentially be much faster than using the cache.

I was using an ArrayCollection to hold a collection of items. I had a custom sort applied since the items were typed objects that needed to be sorted according to certain, out-of-the-ordinary fields. In the sort method, I was comparing values and returning either -1 or 1.

return itemA > itemB ? -1 : 1;

From the docs for a compareFunction:

The method used to compare items when sorting. If you specify this property, Flex ignores any compareFunction properties that you specify in the ISortField objects that you use in this class.

The compare function must have the following signature:

         function [name](a:Object, b:Object, fields:Array = null):int

This function must return the following value:

• -1, if the Object a should appear before the Object b in the sorted sequence
• 0, if the Object a equals the Object b
• 1, if the Object a should appear after the Object b in the sorted sequence

To return to the internal comparision function, set this value to null.

I decided that instead of returning 0 if they were the same, I would just let it stick it below the item. No big deal.

Later, when checking to see if an item was selected, I used the contains() method to see if an item was in the ArrayCollection. I quickly noticed that it wasn’t finding my item, even when I knew it was in the list.  Stepping through the code, and diving in to the Flex framework classes, I found that the contains() method uses the custom sort compare method to compare the item you’re looking for with the items in the list. It determines it found the item when it gets 0 back from the compare function. Since my custom compare method never returned 0, it never found the item.

Knowing this also helped me optimize the compare method for finding items.  Instead of thinking just in terms of whether one item goes before or after another item (or at the same level), I could also think about the comparisons in terms of checking to see if itemA was itemB.

Here’s the scenario.  I created a custom component that contained a background rectangle for highlighting, a label to display the name of the item, a toggle button for expanding the item and a button for editing the item.  I won’t get into the specifics of what this component is for, but just stick to the high level concept.

[ [expandBtn:ToggleButton] [labelDisplay:Label] [editBtn:Button] ]

The component had a number of states:

[SkinState("up")]
[SkinState("over")]
[SkinState("down")]
[SkinState("upAndSelected")]
[SkinState("overAndSelected")]
[SkinState("downAndSelected")]

This is similar to the ToggleButton component in the SDK but didn’t need the disabled state.  I created mouseEvent handlers to take the rollOver, rollOut, mouseDown, mouseUp and click events so I could handle them appropriately, setting properties for the getCurrentSkinState() method to use and setting invalidateSkinState() after changing the properties.

In the components up state, I wanted just the label to show and then when the user hovers over the component, the expand and edit buttons show.  Using states, this is simple enough to accomplish in the skin for the component:

<s:states>
  <s:State name="up" />
  <s:State name="over" stateGroups="overStates" />
  <s:State name="down" stateGroups="downStates" />
  <s:State name="upAndSelected" stateGroups="selectedStates" />
  <s:State name="overAndSelected" stateGroups="overStates, selectedStates" />
  <s:State name="downAndSelected" stateGroups="downStates, selectedStates" />
</s:states>
...
<s:ToggleButton id="expandBtn" includeIn="overStates" .../>

<s:Label id="labelDisplay" ... />

<s:Button id="editBtn" includeIn="overStates" .../>

The ellipses indicate additional code that is irrelevant.

I added the click handlers for the buttons in the custom component so I could capture the clicks and dispatch my own custom event.

So this starts out looking fine.  The buttons show up when the mouse is hovered.  Great.  I click on the edit button and… nothing.  The click handler is never called.  Do you see why?

Hint: Because events like clicks travel the displayList, the surrounding component will react to the clicks of the buttons inside it too.

Ok, here’s the chain of events:

1. The user presses the mouse button down over the edit button.
2. The edit button gets the mouseDown and enters it’s down state (if it has one).
3. The surrounding component gets the mouseDown and changes it’s skin state to the down state.
4. The edit button is not included in the down state, so it is removed.
5. The user releases the mouse button.
6. The surrounding component gets the mouseUp and returns to the over state.
7. The edit button is included in the over state so it appears again.

Since the edit button wasn’t included in the down state, it never had a chance to react to a click event.  Click events occur when the user presses and releases the mouse button over a component and the edit button was not around for that whole chain of events.

Solution: Add the buttons into the downStates so they exist during the entire click action.  Problem solved.

Check out the AIR team blog to see their post on the subject.

Personally, I got the Motorola Droid for Christmas, and have been loving it.  I’m quite excited to have the opportunity to develop applications for my phone using technologies I already love and know so well.