So here's a [relatively] straightforward recursive object comparison function that features optional loose type comparison (strict by default) for those times when you're working with data from different sources, (e.g., which give you quoted numbers ("3" == 3) or empty strings ("" == null == undefined == 0 == "0")), but your task at hand doesn't distinguish among these semantic differences.

Note that performance on huge objects has not been tested, but should be acceptable. Of course, there's likely room for improvement ;)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// compare two objects recursively
// doesn't rely on specifics of object creation or property order
// performs strict type comparison on values by default, unless loose is set to TRUE
 
// USAGE
 
// obj1 = {'key1': 1, 'key2': 2};
// obj2 = {'key2': 2, 'key1': 1};
// objectCompare(obj1, obj2); // returns true
 
// obj1 = {'a': 0, 'b': ''};
// obj2 = {'b': null}; // don't even declare an 'a' property, so it will be undefined - note that number of properties is ignored when doing loose comparison
// objectCompare(obj1, obj2, true); // returns true... for 'a', 0 == undefined, and for 'b', '' == null
 
// will even compare arrays:
// obj1 = [0, 1];
// obj2 = [null, '1'];
// objectCompare(obj1, obj2, true); // returns true
 
// or even arrays of objects:
// obj1 = [{'a': 1}, {'b': '0'}];
// obj2 = [{'a': '1'}, {'b': null}];
// objectCompare(obj1, obj2, true); // returns true
 
// note that arrays are compared by index, so out-of-sequence arrays should be sorted before comparing
 
function objectCompare(obj1, obj2, loose) {
 
  // if loose is NOT TRUE, first do a quick comparison of lengths
  // quick & dirty attempt to avoid comparing all property values on large or complex objects
  var count1 = 0, count2 = 0;
  if (!loose){
    for (i in obj1){
      count1++;
    }
    for (i in obj2){
      count2++;
    }
  }
 
  if (count1 != count2){ // lengths are different, so no need to compare values
    return false;
  }
  else { // lengths are the same (or loose is TRUE), so continue to compare individual property values
    for (i in obj1) {
      if (typeof obj1[i] == 'object' && typeof obj2[i] == 'object') { // both items are objects
        if (!objectCompare(obj1[i], obj2[i], loose)){ // see if objects match
          return false;
        }
      }
      else if (
        loose // loose comparison, 42 == "42", null == '' == undefined
        &&
        !(
          (obj1[i] || '') == (obj2[i] || '') // this will work in all cases EXCEPT ("0" ?= 0|null|undefined), which will evaluate to ("0" ?= ""), which is of course FALSE
          ||
          ( // if either value is a number, try to convert both to numbers and compare - this will work around above exception
            (typeof obj1[i] == 'number' || typeof obj2[i] == 'number')
            &&
            Number(obj1[i]) == Number(obj2[i])
          )
        )
      ){ // only one item is an object, or objects don't match
        return false;
      }
      else if (
        !loose // strict comparison, 42 != "42", null != '' != undefined
        &&
        !(obj1[i] === obj2[i])
      ){
        return false;
      }
    }
  }
 
  return true; // all tests passed, objects are equivalent
}

http://www.google.com/accounts/DisplayUnlockCaptcha

or if you use Google Apps:

https://www.google.com/a/yourdomain.com/UnlockCaptcha

I've had a number of issues with Outlook over the years, and it's always proven to be an uphill battle when something goes wrong. In this case, I was trying to setup POP access in Outlook 2003 (this same solution should apply to other Outlook versions as well), and Outlook would repeatedly pop up an "Invalid credentials" window when trying to send/receive, even though the "Test Settings" procedure during account setup was successful.

This wasn't a case of mistyping the password, or forgetting to check the Save Password box, or a corrupt profile, or missing registry settings, etc. (been there, done that, none of those solutions worked). What finally worked was the answer to the Top Most Common Error on, of all places, Google's own Gmail help website: clear the captcha.

Yes, I am that dense. I'm just glad I found this solution before completely wiping out and reinstalling Office.

In any case, not sure why the captcha was being triggered - I'm guessing this is usually only a result of too many invalid login attempts, so maybe something was tripped while doing the initial account setup in Outlook.

YMMV. Good luck!

I couldn't find any specifics elsewhere, but after a little tweaking I solved the problem:

1. Go into the Sandbox Settings for the sandbox in question.
2. Make sure you check the checkbox at the bottom left of the window labeled "Apply changes when switching to another page".
3. Under the Resource Access section, go into File Access, then Direct Access.
4. Next to the dropdown labeled "The list above applies to", click the Add Pgm button, and find your Chrome executable, e.g. for Windows XP:

   C:\Documents and Settings\[Your User Name]\Local Settings\Application Data\Google\Chrome\Application\chrome.exe

5. Make sure "chrome.exe" is selected next to "The list above applies to", then click the Add button, and find your Chrome User Data folder, e.g. for Windows XP:

   C:\Documents and Settings\[Your User Name]\Local Settings\Application Data\Google\Chrome\User Data

6. Now highlight the User Data entry you just added, click the Edit/Add button, and put an asterisk (*) at the end of the line, e.g. for Windows XP:e.g. for Windows XP:

   C:\Documents and Settings\[Your User Name]\Local Settings\Application Data\Google\Chrome\User Data\*

   Tthis will include all files and folders within the User Data folder.

7. Next, back under the Sandbox Settings configuration tree, go to Resource Access -> File Access -> Read-Only Access, and follow the above steps to add the Chrome Application folder - when you are done, your entry should read (again, for Windows XP):

   C:\Documents and Settings\[Your User Name]\Local Settings\Application Data\Google\Chrome\Application\*

Now click OK to get back out of the Sandbox Settings, close all your sandboxed programs and delete the contents. Now every time you run Chrome in this sandbox, it should be as fast as (or at most only fractionally slower than) Chrome outside the sandbox.

I haven't tested this thoroughly, but so far it seems a good compromise between allowing Chrome access to all of its own files (though it may stumble when trying to update to a new version - more testing needed), while preventing any possible drive-by downloads or other executables from entering and running on my system.

1. If it's a single word (no spaces): first attempt to prepend "www.", and/or append ".com", then lookup in OpenDNS to see if this makes a valid server name - if so, you are automatically redirected to this found server
2. If there is a space: it is assumed this is a search phrase, so the the input is passed (by default) to Google's Browse By Name service. This works similarly to a standard Google web search, however if the search phrase is associated with an "authoritative" server (as deemed by Google), you are automatically redirected to this server (similar to an I'm Feeling Lucky search).

To disable these behaviors, resulting in similar functionality to Google Chrome's address bar, just make a couple changes in Firefox's hidden about:config settings (that is, type "about:config" in the address bar and hit Enter):

1. Change the value of "browser.fixup.alternate.enabled" to false
2. Change the value of "keyword.URL" to

   http://www.google.com/search?q=

   Note that there is nothing after the equal sign.

This appears to work up through Firefox 3.5b4.

However, it appears to be an odd bug in Windows, the workaround for which may not work in all cases, but seems to fix this issue. I had the printer installed on a local TCP/IP port (it has a built-in print server with a static IP), but by following this advice, I assigned the NetBIOS name for the printer to an unused LPT port at a command prompt:

net use LPT2 \\printserver\printername

And then, in the printer's Properties window, under the Ports tab, I changed the port from the TCP/IP port I had originally used to LPT2.

Voila - instant fix.

javascript:(

function(){
  var c = unescape(document.documentElement.innerHTML);
  c=c.replace(/&/g,'&');
  c=c.replace(/%3C/g,'<');
  c=c.replace(/%3E/g,'>');
  var x = window.open();
  x.document.write('<html><head><title>Rendered Source</title></head><body bgcolor="#ffffcc"><pre>' + c + '</pre></body></html>');
  x.document.close();
}

)();

Looking at the above, we can see that we're getting the document's innerHTML, replacing HTML Entities with safe substitutes, opening a new popup window, and writing the source code to the popup.

Now you can at least see what your script is up to, as IE sees it.

@echo|find /I /V "echo" > file.txt

Most other, more straightforward techniques will result in a file size greater than zero bytes (usually containing spaces, linefeeds, or other less-than-obvious text).

• Very sluggish mouse input: Disable v-sync in the game options. You might still be able to force v-sync in your video driver configuration (see here for Nvidia driver) to eliminate tearing.
• Mouse input too slow / "swimmy": You can only increase the mouse sensitivity so far in the game options, but if that's still not sensitive enough for you, try editing the setting manually in the config file. Open the file called config.txt in this folder under Windows XP:

  C:\Documents and Settings\<YOUR USER NAME>\Local Settings\Application Data\Electronic Arts\Dead Space

  or this folder under Vista:

  C:\Users\<YOUR USER NAME>\Local Settings\Application Data\Electronic Arts\Dead Space

  Look for a setting for Control.MouseSensitivity - this only goes up to 1.0 from the in-game options menu, but you can theoretically set it quite a bit higher. I currently have it set to 2.0, which is a pretty decent improvement. Note: setting this too high will make the mouse much too sensitive in the in-game menus, so turn it up slowly and experiment.

• Brightness too high even at lowest setting: this one can also be tweaked in the config file above. The setting is called Window.Gamma - the in-game brightness adjustment only sets this as low as 0.0, but apparently it can go negative. Currently I have it set to -0.5, and it looks much more creepy and atmospheric.

Hopefully EA will patch the claustrophobic, controller-esque feeling of the mouse at some point in the future, but otherwise these settings make a huge improvement over the out-of-the-box experience.

After doing a little homework, I decided to modify this quicksort pseudocode to get the results I was after. Some would argue that quicksort's worst case performance is slower than mergesort, but for my purposes (small datasets) this was moot.

Here is the resulting code:

// STABLE implementation of quick sort to replace unstable Array.sort method in Firefox
quickSort = function(arr) {

  // return if array is unsortable
  if (arr.length <= 1){
    return arr;
  }

  var less = Array(), greater = Array();

  // select and remove a pivot value pivot from array
  // a pivot value closer to median of the dataset may result in better performance
  var pivotIndex = Math.floor(arr.length / 2);
  var pivot = arr.splice(pivotIndex, 1)[0];

  // step through all array elements
  for (var x = 0; x < arr.length; x++){

    // if (current value is less than pivot),
    // OR if (current value is the same as pivot AND this index is less than the index of the pivot in the original array)
    // then push onto end of less array
    if (
      (arr[x] < pivot)
      ||
      (arr[x] == pivot && x < pivotIndex)  // this maintains the original order of values equal to the pivot
    ){
      less.push(arr[x]);
    }

    // if (current value is greater than pivot),
    // OR if (current value is the same as pivot AND this index is greater than or equal to the index of the pivot in the original array)
    // then push onto end of greater array
    else {
      greater.push(arr[x]);
    }
  }

  // concatenate less+pivot+greater arrays
  return quickSort(less).concat([pivot], quickSort(greater));
};

Of course, this will only sort an array of values (strings, numbers), so to sort an array of objects by a given property, I modified the above to produce:

// STABLE implementation of quick sort to replace unstable Array.sort method in Firefox
// if sorting an array of objects, key = name of object property to compare
// otherwise leave key undefined
quickSort = function(arr, key) {

  // return if array is unsortable
  if (arr.length <= 1){
    return arr;
  }

  var less = Array(), greater = Array();

  // select and remove a pivot value pivot from array
  // a pivot value closer to median of the dataset may result in better performance
  var pivotIndex = Math.floor(arr.length / 2);
  var pivot = arr.splice(pivotIndex, 1)[0];

  // step through all array elements
  for (var x = 0; x < arr.length; x++){

    // if (current value is less than pivot),
    // OR if (current value is the same as pivot AND this index is less than the index of the pivot in the original array)
    // then push onto end of less array
    if (
      (
        !key  // no object property name passed
        &&
        (
          (arr[x] < pivot)
          ||
          (arr[x] == pivot && x < pivotIndex)  // this maintains the original order of values equal to the pivot
        )
      )
      ||
      (
        key  // object property name passed
        &&
        (
          (arr[x][key] < pivot[key])
          ||
          (arr[x][key] == pivot[key] && x < pivotIndex)  // this maintains the original order of values equal to the pivot
        )
      )
    ){
      less.push(arr[x]);
    }

    // if (current value is greater than pivot),
    // OR if (current value is the same as pivot AND this index is greater than or equal to the index of the pivot in the original array)
    // then push onto end of greater array
    else {
      greater.push(arr[x]);
    }
  }

  // concatenate less+pivot+greater arrays
  return quickSort(less, key).concat([pivot], quickSort(greater, key));
};

Code samples

Now we can define an array of objects such as:

var objects = [
  {id: 1, type: 'fruit', name: 'apple', color: 'yellow'},
  {id: 2, type: 'vegetable', name: 'tomato', color: 'red'},
  {id: 3, type: 'fruit', name: 'apple', color: 'red'},
  {id: 4, type: 'vegetable', name: 'pepper', color: 'red'}
];

Then sort by color with a call to:

objects = quickSort(objects, 'color');

// sorted
objects = [
  {id: 2, type: 'vegetable', name: 'tomato', color: 'red'},
  {id: 3, type: 'fruit', name: 'apple', color: 'red'},
  {id: 4, type: 'vegetable', name: 'pepper', color: 'red'},
  {id: 1, type: 'fruit', name: 'apple', color: 'yellow'}
];

Then sort by type:

objects = quickSort(objects, 'type');

// sorted
objects = [
  {id: 3, type: 'fruit', name: 'apple', color: 'red'},
  {id: 1, type: 'fruit', name: 'apple', color: 'yellow'},
  {id: 2, type: 'vegetable', name: 'tomato', color: 'red'},
  {id: 4, type: 'vegetable', name: 'pepper', color: 'red'}
];

Then sort by name:

objects = quickSort(objects, 'name');

// sorted
objects = [
  {id: 3, type: 'fruit', name: 'apple', color: 'red'},
  {id: 1, type: 'fruit', name: 'apple', color: 'yellow'},
  {id: 4, type: 'vegetable', name: 'pepper', color: 'red'},
  {id: 2, type: 'vegetable', name: 'tomato', color: 'red'}
];

UPDATE table1 AS target
SET field1 = (
    SELECT field2
    FROM table1 AS source
    WHERE source.id = target.id
)

is illegal in MySQL. To achieve the desired effect, you can perform an INNER JOIN in the UPDATE:

UPDATE table1 AS target
INNER JOIN table1 AS source USING(id)
SET target.field1 = source.field2