Backup Review: Mozy vs iDrive
TL;DR: Mozy sucks, pay a little more for iDrive
I just cancelled my 2-year subscription to Mozy’s unlimited home online backup product after I upgraded to Windows 7. See, it thought I was on an entirely new computer, and asked me to backup everything again. This is not horribly unreasonable, so I said, OK–let’s setup a new backup set. After letting it run for days, it would backup a small subset of files (3%) and die. Not cool. Some of the well-known issues with Mozy include:
- If Mozy fails to access 10 files, it gives up entirely on your 100s of GB backup set.
- Mozy is rate-limited and slow, uploading is less than 1Mb/s
- Opening the Mozy backup set configuration window can take 5-10 minutes
- Mozy slows down your pc
Mozy’s status window while a backup is in-progress
On the plus side of Mozy, there are a few nice things about it:
- $4.95 a month for unlimited GB of files (if you can ever manage to upload them)
- Tech support is fairly responsive, they refunded my credit card promptly
Today I signed up for the free 2GB trial version of iDrive and I’m much more impressed. The service is quick and snappy, fast to let you pick out your backup set, and even faster to upload. I was able to sustain a transfer rate of 3.3Mb/s, and the GUI clearly showed me logs of what files had been backed up. My computer remained responsive while backing up.
The suave iDrive backup screen
The only downside to iDrive is price. You pay $150/yr for 500GB of space. Mozy would cost you just $60, roughly 1/3 as much. However, my overall experience with the iDrive software more than makes up for the price differential. There’s no point in backing up your precious files if the software you use has serious trouble doing so. While I have no doubt that should I need to restore my backup, Mozy would work fine, it’s getting files there in the first place that’s tough.
What’s your experience been?
Update: Wow, just going through my disk to free up space, and saw that after I uninstalled it MozyHome left an 800MB directory in Program Files. WTF!
New GMail Security Feature
I was using my GMail today and was surprised to see a little link that read “Last account activity: 1 minute ago at this IP (74.101.6.15). Details.” If you click on Details, it brings up a popup with the latest activity on your account–who accessed your email last, and from where:
Activity on this account: This feature provides information about the last activity on this mail account and any concurrent activity.
GMail now tells you with timestamps (a) what kind of thing (browser, IMAP client, etc) accessed your email (b) when it happened, and (c) what the IP address was. The only thing lacking is a log of what content precisely was downloaded. So finally Google has solved the “is my significant other spying on me” or “do my parents secretly read my email” questions.
Fixing Bugs with Genetic Algorithms
Wow, check out this preprint: A Genetic Programming Approach to Automated Software Repair. Essentially, the researchers used a suit of positive and negative unit tests as the distance scoring function for a genetic algorithm which operated on code to mutate branches. More interestingly, they did this on off-the-shelf legacy C programs.
Genetic programming is combined with program analysis methods to repair bugs in off-the-shelf legacy C programs. Fitness is defined using negative test cases that exercise the bug to be repaired and positive test cases that encode program requirements. Once a successful repair is discovered, structural differencing algorithms and delta debugging methods are used to minimize its size. Several modifications to the GP technique contribute to its success: (1) genetic operations are localized to the nodes along the execution path of the negative test case; (2) high-level statements are represented as single nodes in the program tree; (3) genetic operators use existing code in other parts of the program, so new code does not need to be invented. The paper describes the method, reviews earlier experiments that repaired 11 bugs in over 60,000 lines of code, reports results on new bug repairs, and describes experiments that analyze the performance and efficacy of the evolutionary components of the algorithm.
Literally, they wrote some small samples of code that said “here’s what I want this buggy program to do” and then their genetic algorithm actually went off and hacked away at the code (much like many of us flesh-and-blood programmers) and made it work. They have several nice examples, including one on automatically fixing the infamous Zune date bug.
The dream of automatic programming has eluded computer scientists for at least 50 years. Although the methods described in this paper do not evolve new programs from scratch, they do show how to evolve legacy software to repair existing faults.
